Spark SQL之External DataSource外部数据源

2024-03-21 06:59
文章标签 sql external 外部 数据源 database spark datasource

本文主要是介绍Spark SQL之External DataSource外部数据源，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

http://blog.csdn.net/oopsoom/article/details/42061077

一、Spark SQL External DataSource简介

  随着Spark1.2的发布，Spark SQL开始正式支持外部数据源。Spark SQL开放了一系列接入外部数据源的接口，来让开发者可以实现。

  这使得Spark SQL支持了更多的类型数据源，如json, parquet, avro, csv格式。只要我们愿意，我们可以开发出任意的外部数据源来连接到Spark SQL。之前大家说的支持HBASE，Cassandra都可以用外部数据源的方式来实现无缝集成。 


二、External DataSource

  拿Spark1.2的json为例，它支持已经改为了实现了外部数据源的接口方式。所以除了先前我们操作json的API，又多了一种DDL创建外部数据源的方式。 

  parquetFile的操作方式也如下类似，就不一一列举了。

2.1 SQL方式 CREATE TEMPORARY TABLE USING OPTIONS

在Spark1.2之后，支持了一种CREATE TEMPORARY TABLE USING OPTIONS的DDL语法来创建外部数据源的表。

[sql]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. CREATE TEMPORARY TABLE jsonTable  
  2. USING org.apache.spark.sql.json  
  3. OPTIONS (  
  4.   path '/path/to/data.json'  
  5. )  

1、操作示例：

我们拿example下people.json文件来做示例。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. shengli-mac$ cat /Users/shengli/git_repos/spark/examples/src/main/resources/people.json  
  2. {"name":"Michael"}  
  3. {"name":"Andy", "age":30}  
  4. {"name":"Justin", "age":19}  
2、DDL创建外部数据源表jsonTable：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. 14/12/21 16:32:14 INFO repl.SparkILoop: Created spark context..  
  2. Spark context available as sc.  
  3.   
  4. scala> import org.apache.spark.sql.SQLContext  
  5. import org.apache.spark.sql.SQLContext  
  6.   
  7. scala> val sqlContext  = new SQLContext(sc)  
  8. sqlContext: org.apache.spark.sql.SQLContext = org.apache.spark.sql.SQLContext@7be62956  
  9.   
  10. scala> import sqlContext._  
  11. import sqlContext._  
  12. //创建jsonTable外部数据源表，并且指定其数数据源文件是people.json这个json文件，同时指定使用org.apache.spark.sql.json该类型的隐式转化类(这个后续文章会介绍)  
  13. scala> val jsonDDL = s"""  
  14.      | |CREATE TEMPORARY TABLE jsonTable  
  15.      | |USING org.apache.spark.sql.json  
  16.      | |OPTIONS (  
  17.      | | path  'file:///Users/shengli/git_repos/spark/examples/src/main/resources/people.json'  
  18.      | |)""".stripMargin  
  19. jsonDDL: String =   
  20. "  
  21. CREATE TEMPORARY TABLE jsonTable  
  22. USING org.apache.spark.sql.json  
  23. OPTIONS (  
  24.  path  'file:///Users/shengli/git_repos/spark/examples/src/main/resources/people.json'  
  25. )"  
  26.   
  27. scala> sqlContext.sql(jsonDDL).collect() //创建该外部数据源表jsonTable  
  28. 14/12/21 16:44:27 INFO scheduler.DAGScheduler: Job 0 finished: reduce at JsonRDD.scala:57, took 0.204461 s  
  29. res0: Array[org.apache.spark.sql.Row] = Array()  

我们来看下该schemaRDD:

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. scala> val jsonSchema = sqlContext.sql(jsonDDL)  
  2. jsonSchema: org.apache.spark.sql.SchemaRDD =   
  3. SchemaRDD[7] at RDD at SchemaRDD.scala:108  
  4. == Query Plan ==  
  5. == Physical Plan ==  
  6. ExecutedCommand (CreateTableUsing jsonTable, org.apache.spark.sql.json, Map(path -> file:///Users/shengli/git_repos/spark/examples/src/main/resources/people.json))  

ExecutedCommand来取把数据用spark.sql.json的方式从path加载到jsonTable中。涉及到得类是CreateTableUsing，后续源码分析会讲到。

各阶段执行计划情况：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. scala> sqlContext.sql("select * from jsonTable").queryExecution  
  2. res6: org.apache.spark.sql.SQLContext#QueryExecution =   
  3. == Parsed Logical Plan ==  
  4. 'Project [*]  
  5.  'UnresolvedRelation None, jsonTable, None  
  6.   
  7. == Analyzed Logical Plan ==  
  8. Project [age#0,name#1]  
  9.  Relation[age#0,name#1] JSONRelation(file:///Users/shengli/git_repos/spark/examples/src/main/resources/people.json,1.0)  
  10.   
  11. == Optimized Logical Plan ==  
  12. Relation[age#0,name#1] JSONRelation(file:///Users/shengli/git_repos/spark/examples/src/main/resources/people.json,1.0)  
  13.   
  14. == Physical Plan ==  
  15. PhysicalRDD [age#0,name#1], MapPartitionsRDD[27] at map at JsonRDD.scala:47  
  16.   
  17. Code Generation: false  
  18. == RDD ==  

至此，创建加载外部数据源到Spark SQL已经完成。

我们可以使用任何我们希望的方式来查询：

3、SQL查询方式：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. scala> sqlContext.sql("select * from jsonTable")  
  2. 21 16:52:13 INFO spark.SparkContext: Created broadcast 6 from textFile at JSONRelation.scala:39  
  3. res2: org.apache.spark.sql.SchemaRDD =   
  4. SchemaRDD[20] at RDD at SchemaRDD.scala:108  
  5. == Query Plan ==  
  6. == Physical Plan ==  
  7. PhysicalRDD [age#2,name#3], MapPartitionsRDD[24] at map at JsonRDD.scala:47  

执行查询：

scala> sqlContext.sql("select * from jsonTable").collect()
res1: Array[org.apache.spark.sql.Row] = Array([null,Michael], [30,Andy], [19,Justin])
 

 

2.2 API方式
 

sqlContext.jsonFile
 

 

 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. scala> val json = sqlContext.jsonFile("file:///Users/shengli/git_repos/spark/examples/src/main/resources/people.json")  
  2. scala> json.registerTempTable("jsonFile")  
  3.   
  4. scala> sql("select * from jsonFile").collect()  
  5. res2: Array[org.apache.spark.sql.Row] = Array([null,Michael], [30,Andy], [19,Justin])  
 

 

  总的来说，Spark SQL 在努力的向各种数据源靠拢，希望让Spark SQL能和其它许多类型的数据源的集成。
 

  Spark SQL提供的了一种创建加载外部数据源表的DDL语法：CREATE TEMPORARY TABLE USING OPTIONS
 

  Spark SQL对外开放了一系列的扩展接口，能够通过实现这些接口，来实现对不同的数据源接入，如avro, csv, parquet,json, etc
 


 

三、Sources包核心
 

    Spark SQL在Spark1.2中提供了External DataSource API，开发者可以根据接口来实现自己的外部数据源，如avro, csv, json, parquet等等。
 

    在Spark SQL源代码的org/spark/sql/sources目录下，我们会看到关于External DataSource的相关代码。这里特别介绍几个:
 

    1、DDLParser 
 

    专门负责解析外部数据源SQL的SqlParser，解析create temporary table xxx using options (key 'value', key 'value') 创建加载外部数据源表的语句。
 

 

 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. protected lazy val createTable: Parser[LogicalPlan] =  
  2.    CREATE ~ TEMPORARY ~ TABLE ~> ident ~ (USING ~> className) ~ (OPTIONS ~> options) ^^ {  
  3.      case tableName ~ provider ~ opts =>  
  4.        CreateTableUsing(tableName, provider, opts)  
  5.    }  
 

 

 

    2、CreateTableUsing
 

   一个RunnableCommand，通过反射从外部数据源lib中实例化Relation，然后注册到为temp table。
 

 

 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. private[sql] case class CreateTableUsing(  
  2.     tableName: String,  
  3.     provider: String,  // org.apache.spark.sql.json   
  4.     options: Map[String, String]) extends RunnableCommand {  
  5.   
  6.   def run(sqlContext: SQLContext) = {  
  7.     val loader = Utils.getContextOrSparkClassLoader  
  8.     val clazz: Class[_] = try loader.loadClass(provider) catch { //do reflection  
  9.       case cnf: java.lang.ClassNotFoundException =>  
  10.         try loader.loadClass(provider + ".DefaultSource") catch {  
  11.           case cnf: java.lang.ClassNotFoundException =>  
  12.             sys.error(s"Failed to load class for data source: $provider")  
  13.         }  
  14.     }  
  15.     val dataSource = clazz.newInstance().asInstanceOf[org.apache.spark.sql.sources.RelationProvider] //json包DefaultDataSource  
  16.     val relation = dataSource.createRelation(sqlContext, new CaseInsensitiveMap(options))//创建JsonRelation  
  17.   
  18.     sqlContext.baseRelationToSchemaRDD(relation).registerTempTable(tableName)//注册  
  19.     Seq.empty  
  20.   }  
  21. }  
 

 

    2、DataSourcesStrategy
 

    在 Strategy 一文中，我已讲过Streategy的作用，用来Plan生成物理计划的。这里提供了一种专门为了解析外部数据源的策略。
 

    最后会根据不同的BaseRelation生产不同的PhysicalRDD。不同的BaseRelation的scan策略下文会介绍。
 

 

 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. private[sql] object DataSourceStrategy extends Strategy {  
  2.   def apply(plan: LogicalPlan): Seq[SparkPlan] = plan match {  
  3.     case PhysicalOperation(projectList, filters, l @ LogicalRelation(t: CatalystScan)) =>  
  4.       pruneFilterProjectRaw(  
  5.         l,  
  6.         projectList,  
  7.         filters,  
  8.         (a, f) => t.buildScan(a, f)) :: Nil  
  9.     ......  
  10.     case l @ LogicalRelation(t: TableScan) =>  
  11.       execution.PhysicalRDD(l.output, t.buildScan()) :: Nil  
  12.   
  13.     case _ => Nil  
  14.   }  
 

 
    
3、interfaces.scala 
  

 

    该文件定义了一系列可扩展的外部数据源接口，对于想要接入的外部数据源，我们只需实现该接口即可。里面比较重要的trait RelationProvider 和 BaseRelation，下文会详细介绍。
 

    4、filters.scala
 

    该Filter定义了如何在加载外部数据源的时候，就进行过滤。注意哦，是加载外部数据源到Table里的时候，而不是Spark里进行filter。这个有点像hbase的coprocessor，查询过滤在Server上就做了，不在Client端做过滤。
 

   5、LogicalRelation
 

   封装了baseRelation，继承了catalyst的LeafNode,实现MultiInstanceRelation。
 

        
 

四、External DataSource注册流程
 

用spark sql下sql/json来做示例, 画了一张流程图，如下： 

 

  
 

 

 
 

 

 
 

 

 注册外部数据源的表的流程： 

 

1、提供一个外部数据源文件，比如json文件。 

 

2、提供一个实现了外部数据源所需要的interfaces的类库，比如sql下得json包，在1.2版本后改为了External Datasource实现。 

 

3、引入SQLContext，使用DDL创建表，如create temporary table xxx using options (key 'value', key 'value')  

 

4、External Datasource的DDLParser将对该SQL进行Parse 

 

5、Parse后封装成为一个CreateTableUsing类的对象。该类是一个RunnableCommand，其run方法会直接执行创建表语句。 

 

6、该类会通过反射来创建一个org.apache.spark.sql.sources.RelationProvider，该trait定义要createRelation，如json，则创建JSONRelation，若avro,则创建AvroRelation。 

 

7、得到external releation后，直接调用SQLContext的baseRelationToSchemaRDD转换为SchemaRDD 

 

8、最后registerTempTable(tableName) 来注册为Table，可以用SQL来查询了。 

 

 
 

 

五、External DataSource解析流程
 

先看图，图如下： 

 

  
 

 

 
 

 

Spark SQL解析SQL流程如下： 

 

1、Analyzer通过Rule解析，将UnresolvedRelation解析为JsonRelation。 

 

2、通过Parse，Analyzer，Optimizer最后得到JSONRelation(file:///path/to/shengli.json,1.0)   

 

3、通过sources下得DataSourceStrategy将LogicalPlan映射到物理计划PhysicalRDD。 

 

4、PhysicalRDD里包含了如何查询外部数据的规则，可以调用execute()方法来执行Spark查询。 

 

 
 

 

六、External Datasource Interfaces
 

在第一节我已经介绍过，主要的interfaces，主要看一下BaseRelation和RelationProvider。 

 

如果我们要实现一个外部数据源，比如avro数据源，支持spark sql操作avro file。那么久必须定义AvroRelation来继承BaseRelation。同时也要实现一个RelationProvider。 

 

  
 

 

 
 

 

 BaseRelation： 

 

是外部数据源的抽象，里面存放了 schema的映射，和 如何scan数据的规则。 

 

 
 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. abstract class BaseRelation {  
  2.   def sqlContext: SQLContext  
  3.   def schema: StructType  
 
 
 
 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. abstract class PrunedFilteredScan extends BaseRelation {  
  2.   def buildScan(requiredColumns: Array[String], filters: Array[Filter]): RDD[Row]  
  3. }  
 
 
 
1、schema我们如果自定义Relation，必须重写schema，就是我们必须描述对于外部数据源的Schema。 

 

2、buildScan我们定义如何查询外部数据源，提供了4种Scan的策略，对应4种BaseRelation。 

 

 
 

 

 
 

 

我们支持4种BaseRelation，分为TableScan， PrunedScan，PrunedFilterScan，CatalystScan。 

 

1、 TableScan： 
 

 

默认的Scan策略。 

 

2、 PrunedScan： 

 

这里可以传入指定的列，requiredColumns，列裁剪，不需要的列不会从外部数据源加载。 

 

3、 PrunedFilterScan： 

 

在列裁剪的基础上，并且加入Filter机制，在加载数据也的时候就进行过滤，而不是在客户端请求返回时做Filter。 

 

4、 CatalystScan： 

 

Catalyst的支持传入expressions来进行Scan。支持列裁剪和Filter。 

 

 
 

 

 RelationProvider： 

 

我们要实现这个，接受Parse后传入的参数，来生成对应的External Relation，就是一个反射生产外部数据源Relation的接口。 

 

 
 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. trait RelationProvider {  
  2.   /** 
  3.    * Returns a new base relation with the given parameters. 
  4.    * Note: the parameters' keywords are case insensitive and this insensitivity is enforced 
  5.    * by the Map that is passed to the function. 
  6.    */  
  7.   def createRelation(sqlContext: SQLContext, parameters: Map[String, String]): BaseRelation  
  8. }  
 
 
 
七、External Datasource定义示例
 

 

在Spark1.2之后，json和parquet也改为通过实现External API来进行外部数据源查询的。 

 

下面以json的外部数据源定义为示例，说明是如何实现的： 

 

  
 

 

 
 

 

 1、JsonRelation 

 

 
 

 

定义处理对于json文件的，schema和Scan策略，均基于JsonRDD，细节可以自行阅读JsonRDD。 

 

 
 

 

 
 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. private[sql] case class JSONRelation(fileName: String, samplingRatio: Double)(  
  2.     @transient val sqlContext: SQLContext)  
  3.   extends TableScan {  
  4.   
  5.   private def baseRDD = sqlContext.sparkContext.textFile(fileName) //读取json file  
  6.   
  7.   override val schema =  
  8.     JsonRDD.inferSchema(  // jsonRDD的inferSchema方法，能自动识别json的schema，和类型type。  
  9.       baseRDD,  
  10.       samplingRatio,  
  11.       sqlContext.columnNameOfCorruptRecord)  
  12.   
  13.   override def buildScan() =  
  14.     JsonRDD.jsonStringToRow(baseRDD, schema, sqlContext.columnNameOfCorruptRecord) //这里还是JsonRDD，调用jsonStringToRow查询返回Row  
  15. }  
 
 

 

 
 

 

 2、DefaultSource 

 

parameters中可以获取到options中传入的path等自定义参数。 
 

 

这里接受传入的参数，来狗仔JsonRelation。 

 

 
 
 
 [java]  view plain copy 在CODE上查看代码片 派生到我的代码片 
 
 
 
  1. private[sql] class DefaultSource extends RelationProvider {  
  2.   /** Returns a new base relation with the given parameters. */  
  3.   override def createRelation(  
  4.       sqlContext: SQLContext,  
  5.       parameters: Map[String, String]): BaseRelation = {  
  6.     val fileName = parameters.getOrElse("path", sys.error("Option 'path' not specified"))  
  7.     val samplingRatio = parameters.get("samplingRatio").map(_.toDouble).getOrElse(1.0)  
  8.   
  9.     JSONRelation(fileName, samplingRatio)(sqlContext)  
  10.   }  
  11. }  
 
 
 

 

 八、总结 

 

External DataSource源码分析下来，可以总结为3部分。 

 

1、外部数据源的注册流程 

 

2、外部数据源Table查询的计划解析流程 

 

3、如何自定义一个外部数据源，重写BaseRelation定义外部数据源的schema和scan的规则。定义RelationProvider，如何生成外部数据源Relation。 

 

 

External Datasource此部分API还有可能在后续的build中改动，目前只是涉及到了查询，关于其它的操作还未涉及。 

 

——EOF—— 

 

 
 

 

 
原创文章，转载请注明：
 
转载自：OopsOutOfMemory盛利的Blog，作者： OopsOutOfMemory
 
本文链接地址：http://blog.csdn.net/oopsoom/article/details/42064075  
 
注：本文基于署名-非商业性使用-禁止演绎 2.5 中国大陆(CC BY-NC-ND 2.5 CN)协议，欢迎转载、转发和评论，但是请保留本文作者署名和文章链接。如若需要用于商业目的或者与授权方面的协商，请联系我。
 
image
 
 
 
 

 


                                    

                                        这篇关于Spark SQL之External DataSource外部数据源的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
                                    

                                    

                                

                            

                            

                        

                    

                    

                        

                            

                            http://www.chinasem.cn/article/832040。
                            
                        

                    

                    
                    

                        
                            
                        
                    

                

                

                    相关文章
                

                    

                        

                            

                                

                                    
                                        MySQL数据库双机热备的配置方法详解
                                    
                                

                            

                            

                                

                                    MySQL数据库双机热备的配置方法详解
                                

                                

                                    《MySQL数据库双机热备的配置方法详解》在企业级应用中,数据库的高可用性和数据的安全性是至关重要的,MySQL作为最流行的开源关系型数据库管理系统之一,提供了多种方式来实现高可用性,其中双机热备（M...																									目录1. 环境准备1.1 安装mysql1.2 配置MySQL1.2.1 主服务器配置1.2.2 从
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        深入理解Mysql OnlineDDL的算法
                                    
                                

                            

                            

                                

                                    深入理解Mysql OnlineDDL的算法
                                

                                

                                    《深入理解MysqlOnlineDDL的算法》本文主要介绍了讲解MysqlOnlineDDL的算法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小...																									目录一、Online DDL 是什么？二、Online DDL 的三种主要算法2.1COPY（复制法）
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        mysql8.0.43使用InnoDB Cluster配置主从复制
                                    
                                

                            

                            

                                

                                    mysql8.0.43使用InnoDB Cluster配置主从复制
                                

                                

                                    《mysql8.0.43使用InnoDBCluster配置主从复制》本文主要介绍了mysql8.0.43使用InnoDBCluster配置主从复制,文中通过示例代码介绍的非常详细,对大家的学习或者...																									目录1、配置Hosts解析(所有服务器都要执行)2、安装mysql shell(所有服务器都要执行)3、
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        k8s中实现mysql主备过程详解
                                    
                                

                            

                            

                                

                                    k8s中实现mysql主备过程详解
                                

                                

                                    《k8s中实现mysql主备过程详解》文章讲解了在K8s中使用StatefulSet部署MySQL主备架构,包含NFS安装、storageClass配置、MySQL部署及同步检查步骤,确保主备数据一致...																									目录一、k8s中实现mysql主备1.1 环境信息1.2 部署nfs-provisioner1.2.
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        MySQL中VARCHAR和TEXT的区别小结
                                    
                                

                            

                            

                                

                                    MySQL中VARCHAR和TEXT的区别小结
                                

                                

                                    《MySQL中VARCHAR和TEXT的区别小结》MySQL中VARCHAR和TEXT用于存储字符串,VARCHAR可变长度存储在行内,适合短文本；TEXT存储在溢出页,适合大文本,下面就来具体的了解...																									目录一、VARCHAR 和 TEXT 基本介绍1. VARCHAR2. TEXT二、VARCHAR
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        MySQL中C接口的实现
                                    
                                

                            

                            

                                

                                    MySQL中C接口的实现
                                

                                

                                    《MySQL中C接口的实现》本节内容介绍使用C/C++访问数据库,包括对数据库的增删查改操作,主要是学习一些接口的调用,具有一定的参考价值,感兴趣的可以了解一下...																									目录准备mysql库使用mysql库编译文件官方API文档对象的创建和关闭链接数据库下达sql指令select语句前言：本节内容介绍使用C/
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        mybatis直接执行完整sql及踩坑解决
                                    
                                

                            

                            

                                

                                    mybatis直接执行完整sql及踩坑解决
                                

                                

                                    《mybatis直接执行完整sql及踩坑解决》MyBatis可通过select标签执行动态SQL,DQL用ListLinkedHashMap接收结果,DML用int处理,注意防御SQL注入,优先使用#...																									目录myBATiFBNZQs直接执行完整sql及踩坑select语句采用count、insert、u
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        MySQL之搜索引擎使用解读
                                    
                                

                            

                            

                                

                                    MySQL之搜索引擎使用解读
                                

                                

                                    《MySQL之搜索引擎使用解读》MySQL存储引擎是数据存储和管理的核心组件,不同引擎（如InnoDB、MyISAM）采用不同机制,InnoDB支持事务与行锁,适合高并发场景；MyISAM不支持事务,...																									目录mysql的存储引擎是什么MySQL存储引擎的功能MySQL的存储引擎的分类查看存储引擎1.命令
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        一文详解MySQL索引(六张图彻底搞懂)
                                    
                                

                            

                            

                                

                                    一文详解MySQL索引(六张图彻底搞懂)
                                

                                

                                    《一文详解MySQL索引(六张图彻底搞懂)》MySQL索引的建立对于MySQL的高效运行是很重要的,索引可以大大提高MySQL的检索速度,：本文主要介绍MySQL索引的相关资料,文中通过代码介绍的...																									目录一、什么是索引？为什么需要索引？二、索引该用哪种数据结构？1. 哈希表2. 跳表3. 二叉排序树4.
                                

                                

                                    阅读更多...
                                

                            

                        

                    

                    

                        

                            

                                

                                    
                                        MySQL批量替换数据库字符集的实用方法(附详细代码)
                                    
                                

                            

                            

                                

                                    MySQL批量替换数据库字符集的实用方法(附详细代码)
                                

                                

                                    《MySQL批量替换数据库字符集的实用方法(附详细代码)》当需要修改数据库编码和字符集时,通常需要对其下属的所有表及表中所有字段进行修改,下面：本文主要介绍MySQL批量替换数据库字符集的实用方法...																									目录前言为什么要批量修改字符集？整体脚本脚本逻辑解析1. 设置目标参数2. 生成修改表默认字符集的语句3
                                

                                

                                    阅读更多...
                                

                            

                        

                    

            

        

    


    


    

        

            Copyright China编程   23002807@qq.com
        

        

            沪ICP备2023033072号-2