Spark SQL

目录
一.Spark SQL基础
    1.Spark SQL简介
    2.Spark SQL的特点:
    3.基本概念:表:Datasets和DataFrames
    4.创建DataFrames
    5.操作DataFrame
    6.视图
    7.创建Datasets
二.使用数据源
    1.通用的Load/Save函数(load函数式加载数据,save函数式存储数据)
    2.Parquet文件(列式存储文件,是Spark SQL默认的数据源)
三.性能优化
    1.在内存中缓存数据
    2.性能优化相关参数

一.Spark SQL基础

1.Spark SQL简介

    Spark SQL是Spark用来处理结构化数据的一个模块,它提供了一个编程抽象叫做DataFrame并且作为分布式SQL查询引擎的作用。

    为什么要学习Spark SQL?Hive,它将Hive SQL转换成MapReduce然后提交到集群上执行,大大简化了编写MapReduce的程序的复杂性,由于MapReduce这种计算模型执行效率比较慢。所以Spark SQL的应运而生,它是将Spark SQL转换成RDD,然后提交到集群执行,执行效率非常快!同时Spark SQL也支持从Hive中读取数据。

2.Spark SQL的特点:

(1)容易整合(集成):安装Spark的时候,已经集成好了。不需要单独安装

(2)统一的数据访问方式
JDBC、JSON、Hive、parquet文件(一种列式存储文件,是SparkSQL默认的数据源)

(3)兼容Hive:可以将Hive中的数据,直接读取到Spark SQL中处理。

(4)标准的数据连接:JDBC

3.基本概念:表:Datasets和DataFrames

(0)表 = 表结构 + 数据
    DataFrame = Schema(表结构) + RDD(代表数据)

(1)DataFrame
    DataFrame是组织成命名列的数据集。它在概念上等同于关系数据库中的表,但在底层具有更丰富的优化。DataFrames可以从各种来源构建,

例如:

  • 结构化数据文件
  • hive中的表
  • 外部数据库或现有RDDs

DataFrame API支持的语言有Scala,Java,Python和R

    从上图可以看出,DataFrame多了数据的结构信息,即schema。RDD是分布式的 Java对象的集合。DataFrame是分布式的Row对象的集合。DataFrame除了提供了比RDD更丰富的算子以外,更重要的特点是提升执行效率、减少数据读取以及执行计划的优化

(2)Datasets
    Dataset是数据的分布式集合。Dataset是在Spark 1.6中添加的一个新接口,是DataFrame之上更高一级的抽象。它提供了RDD的优点(强类型化,使用强大的lambda函数的能力)以及Spark SQL优化后的执行引擎的优点。一个Dataset 可以从JVM对象构造,然后使用函数转换(map, flatMap,filter等)去操作。 Dataset API 支持Scala和Java。 Python不支持Dataset API。

4.创建DataFrames

(1)第一种方式:使用case class样本类创建DataFrames

(a)定义表的Schema

注意:由于mgr和comm列中包含null值,简单起见,将对应的case class类型定义为String

scala> case class Emp(empno:Int,ename:String,job:String,mgr:String,hiredate:String,sal:Int,comm:String,depno:Int)

(b)读入数据

//从hdfs中读入
scala> val lines = sc.textFile("hdfs://hadoop1:9000/emp.csv").map(_.split(","))

//从本地读入
scala> val lines = sc.textFile("/opt/module/datas/TestFile/emp.csv").map(_.split(","))

/opt/module/datas/TestFile

(c)把每行数据映射到Emp中。把表结构和数据,关联。

scala> val allEmp = lines.map(x => Emp(x(0).toInt,x(1),x(2),x(3),x(4),x(5).toInt,x(6),x(7).toInt))

(d)生成DataFrame

scala> val allEmpDF = allEmp.toDF

//展示 
scala> allEmpDF.show

(2)第二种方式:使用SparkSession

什么是SparkSession
    Apache Spark 2.0引入了SparkSession,其为用户提供了一个统一的切入点来使用Spark的各项功能,并且允许用户通过它调用DataFrame和Dataset相关API来编写Spark程序。最重要的是,它减少了用户需要了解的一些概念,使得我们可以很容易地与Spark交互。

    在2.0版本之前,与Spark交互之前必须先创建SparkConf和SparkContext。然而在Spark 2.0中,我们可以通过SparkSession来实现同样的功能,而不需要显式地创建SparkConf, SparkContext 以及 SQLContext,因为这些对象已经封装在SparkSession中。

(a)使用StructType,来创建Schema

import org.apache.spark.sql.types._

val myschema = StructType(
                List(
                StructField("empno", DataTypes.IntegerType), 
                StructField("ename", DataTypes.StringType),
                StructField("job", DataTypes.StringType),
                StructField("mgr", DataTypes.IntegerType),
                StructField("hiredate", DataTypes.StringType),
                StructField("sal", DataTypes.IntegerType),
                StructField("comm", DataTypes.IntegerType),
                StructField("deptno", DataTypes.IntegerType)))

注意,需要:import org.apache.spark.sql.types._

(c)读取文件:

val lines= sc.textFile("/opt/module/datas/TestFile/emp.csv").map(_.split(","))

(d)数据与表结构匹配

import org.apache.spark.sql.Row

val allEmp = lines.map(x => Row(x(0).toInt,x(1),x(2),x(3).toInt,x(4),x(5).toInt,x(6).toInt,x(7).toInt))

注意,需要:import org.apache.spark.sql.Row
(e)创建DataFrames

val df2 = spark.createDataFrame(allEmp,myschema)

df2.show

(3)方式三,直接读取一个带格式的文件:Json
(a)读取文件:

val df3 = spark.read.json("/opt/module/datas/TestFile/emp.json")

df3.show

(b)另一种方式

val df4 = spark.read.format("json").load("/opt/module/datas/TestFile/emp.json")

df4.show
5.操作DataFrame

DataFrame操作也称为无类型的Dataset操作

(1)DSL语句

df1.show

df1.printSchema
df1.select("ename","sal").show

df1.select($"ename",$"sal",$"sal"+100).show

$代表 取出来以后,再做一些操作

df1.filter($"sal">2000).show

df1.groupBy($"depno").count.show

完整的例子,请参考:
http://spark.apache.org/docs/2.1.0/api/scala/index.html#org.apache.spark.sql.Dataset

(2)SQL语句

注意:不能直接执行sql。需要生成一个视图,再执行SQL。

(a)将DataFrame注册成表(视图):

df1.createOrReplaceTempView("emp")

(b)执行查询:

spark.sql("select * from emp").show

spark.sql("select * from emp where sal > 2000").show
spark.sql("select * from emp where depno=10").show

spark.sql("select depno,count(1) from emp group by depno").show 

spark.sql("select depno,sum(sal) from emp group by depno").show
image.png
df1.createOrReplaceTempView("emp12345")

spark.sql("select e.depno from emp12345 e").show

(3)多表查询

case class Dept(deptno:Int,dname:String,loc:String)

val lines = sc.textFile("/opt/module/datas/TestFile/dept.csv").map(_.split(","))

val allDept = lines.map(x=>Dept(x(0).toInt,x(1),x(2)))

val df2 = allDept.toDF

df2.create

df2.createOrReplaceTempView("dept")

spark.sql("select dname,ename from emp12345,dept where emp12345.depno=dept.deptno").show
6.视图

(1)视图是一个虚表,不存储数据

(2)两种类型视图:

(一)普通视图(本地视图):只在当前Session有效

(二)全局视图:在不同Session中都有用。全局视图创建在命名空间中:global_temp 类似于一个库。

    上面使用的是一个在Session生命周期中的临时views。在Spark SQL中,如果你想拥有一个临时的view,并想在不同的Session中共享,而且在application的运行周期内可用,那么就需要创建一个全局的临时view。并记得使用的时候加上global_temp作为前缀来引用它,因为全局的临时view是绑定到系统保留的数据库global_temp上。
(1)创建一个普通的view和一个全局的view

df1.createOrReplaceTempView("emp1")

df1.createGlobalTempView("emp2")

(2)在当前会话中执行查询,均可查询出结果。

spark.sql("select * from emp1").show
spark.sql("select * from global_temp.emp2").show

(3)开启一个新的会话,执行同样的查询

spark.newSession.sql("select * from emp1").show     //(运行出错)
spark.newSession.sql("select * from global_temp.emp2").show
7.创建Datasets

    DataFrame的引入,可以让Spark更好的处理结构数据的计算,但其中一个主要的问题是:缺乏编译时类型安全。为了解决这个问题,Spark采用新的Dataset API (DataFrame API的类型扩展)。

    Dataset是一个分布式的数据收集器。这是在Spark1.6之后新加的一个接口,兼顾了RDD的优点(强类型,可以使用功能强大的lambda)以及Spark SQL的执行器高效性的优点。所以可以把DataFrames看成是一种特殊的Datasets,即:Dataset(Row)

(1)创建DataSet

方式一:使用序列
(a)定义case class

scala >case class MyData(a:Int,b:String)

(b).生成序列,并创建DataSet

scala >val ds = Seq(MyData(1,"Tom"),MyData(2,"Mary")).toDS

(c).查看结果

scala >ds.show

ds.collect

方式二:使用JSON数据
(a)定义case class

case class Person(name: String, age: BigInt)

(b)通过JSON数据生成DataFrame

val df = spark.read.format("json").load("/opt/module/datas/TestFile/people.json")

(c)将DataFrame转成DataSet

df.as[Person].show
df.as[Person].collect

方式三:使用其他数据(RDD的操作和DataFrame操作结合)

(一)需求:分词;查询出长度大于3的单词
(a)读取数据,并创建DataSet

val linesDS = spark.read.text("/opt/module/datas/TestFile/test_WordCount.txt").as[String]

(b)对DataSet进行操作:分词后,查询长度大于3的单词

val words = linesDS.flatMap(_.split(" ")).filter(_.length > 3)

words.show

words.collect

(二)需求:执行WordCount程序

val result = linesDS.flatMap(_.split(" ")).map((_,1)).groupByKey(x => x._1).count

result.show

排序:

result.orderBy($"value").show

result.orderBy($"count(1)").show

(2).Datasets的操作案例
(一)使用emp.json 生成DataFrame

(a)数据:emp.json

(b)使用emp.json 生成DataFrame

val empDF = spark.read.json("/opt/module/datas/TestFile/emp.json")

emp.show

查询工资大于3000的员工

empDF.where($"sal" >= 3000).show

(c)创建case class,生成DataSets

case class Emp(empno:Long,ename:String,job:String,hiredate:String,mgr:String,sal:Long,comm:String,deptno:Long)

val empDS = empDF.as[Emp]

(d)查询数据

//查询工资大于3000的员工
empDS.filter(_.sal > 3000).show

//查看10号部门的员工 
empDS.filter(_.deptno == 10).show

(二)多表查询
(a)创建部门表

val deptRDD=sc.textFile("/opt/module/datas/TestFile/dept.csv").map(_.split(","))

case class Dept(deptno:Int,dname:String,loc:String)

val deptDS = deptRDD.map(x=>Dept(x(0).toInt,x(1),x(2))).toDS

deptDS.show

(b)创建员工表

case class Emp(empno:Int,ename:String,job:String,mgr:String,hiredate:String,sal:Int,comm:String,deptno:Int)

val empRDD = sc.textFile("/opt/module/datas/TestFile/emp.csv").map(_.split(","))

val empDS = empRDD.map(x => Emp(x(0).toInt,x(1),x(2),x(3),x(4),x(5).toInt,x(6),x(7).toInt)).toDS

empDS.show

(c)执行多表查询:等值链接

val result = deptDS.join(empDS,"deptno")

result.show

另一种写法:注意有三个等号

val result1 = deptDS.joinWith(empDS,deptDS("deptno")=== empDS("deptno"))

result1.show

joinWith和join的区别是连接后的新Dataset的schema会不一样

(e)多表条件查询:

val result = deptDS.join(empDS,"deptno").where("deptno==10") 

result.show

二.使用数据源

    在Spark SQL中,可以使用各种各样的数据源进行操作。Spark SQL 用于处理结构化的数据。

1.通用的Load/Save函数(load函数式加载数据,save函数式存储数据)

   注意:使用load或者save函数时,默认的数据源都是 Parquet文件。列式存储文件

(1)通用的Load/Save函数
(a)读取Parquet文件

val usersDF = spark.read.load("/root/resources/users.parquet")

(b)查询Schema和数据

scala> usersDF.printSchema

scala> usersDF.show

(c)查询用户的name和喜爱颜色,并保存

usersDF.select($"name",$"favorite_color").write.save("/root/result/parquet")

(d)验证结果

scala >val testResult = spark.read.load("/root/result/parquet/part-00000-8ffaac2e-aa81-4e63-89aa-15a8e4948a37.snappy.parquet")

scala >testResult.printSchema

scala >testResult.show

(2)显式指定文件格式:加载json格式
(a)直接加载:

val usersDF = spark.read.load("/root/resources/people.json")  //会出错

上面这个会出错

val usersDF = spark.read.format("json").load("/root/resources/people.json")

(3)存储模式(Save Modes)
    可以采用SaveMode执行存储操作,SaveMode定义了对数据的处理模式。需要注意的是,这些保存模式不使用任何锁定,不是原子操作。此外,当使用Overwrite方式执行时,在输出新数据之前原数据就已经被删除。SaveMode详细介绍如下表:

Demo:

usersDF.select($"name").write.save("/root/result/parquet1")

上面出错:因为/root/result/parquet1已经存在

usersDF.select($"name").write.mode("overwrite").save("/root/result/parquet1")

(4)将结果保存为表

usersDF.select($"name").write.saveAsTable("table1")

也可以进行分区、分桶等操作:partitionBy、bucketBy

2.Parquet文件(列式存储文件,是Spark SQL默认的数据源)

(1)什么是parquet文件?

Parquet是列式存储格式的一种文件类型,列式存储有以下的核心:

  • 可以跳过不符合条件的数据,只读取需要的数据,降低IO数据量。
  • 压缩编码可以降低磁盘存储空间。由于同一列的数据类型是一样的,可以使用更高效的压缩编码(例如Run Length Encoding和Delta Encoding)进一步节约存储空间。
  • 只读取需要的列,支持向量运算,能够获取更好的扫描性能。
  • Parquet格式是Spark SQL的默认数据源,可通过spark.sql.sources.default配置

    Parquet是一个列格式而且用于多个数据处理系统中。Spark SQL提供支持对于Parquet文件的读写,也就是自动保存原始数据的schema。当写Parquet文件时,所有的列被自动转化为nullable,因为兼容性的缘故。

(2)把其他文件,转换成Parquet文件()
    读入json格式的数据,将其转换成parquet格式,并创建相应的表来使用SQL进行查询。

scala >val empDF = spark.read.json("/opt/module/datas/TestFile/emp.json")

scala >empDF.show
scala >empDF.write.mode("overwrite").save("/opt/module/datas/TestFile/myresult/parquet")

//save和parquet都可以写入,是一样的
scala >empDF.write.mode("overwrite").parquet("/opt/module/datas/TestFile/myresult/parquet")

scala >val emp1=spark.read.parquet("/opt/module/datas/TestFile/myresult/parquet")

scala >emp1.show
scala >emp1.createOrReplaceTempView("emptable")

scala >spark.sql("select * from emptable where deptno =10 and sal >1500").show

(3)支持Schema的合并:
    Parquet支持Schema evolution(Schema演变,即:合并)。用户可以先定义一个简单的Schema,然后逐渐的向Schema中增加列描述。通过这种方式,用户可以获取多个有不同Schema但相互兼容的Parquet文件。
Demo:

val df1= sc.makeRDD(1 to 5).map(i => (i,i*2)).toDF("single","double")

df1.show

sc.makeRDD(1 to 5)

sc.makeRDD(1 to 5).collect

df1.write.parquet("/opt/module/datas/TestFile/test_table/key=1")

val df2 = sc.makeRDD(6 to 10).map(i=>(i,i*3)).toDF("single","triple")

df2.show

df2.write.parquet("/opt/module/datas/TestFile/test_table/key=2")

val df3 = spark.read.parquet("/opt/module/datas/TestFile/test_table")

df3.show
val df3 = spark.read.option("mergeSchema",true).parquet("/opt/module/datas/TestFile/test_table")

df3.show

(4).JSON 文件
    Spark SQL能自动解析JSON数据集的Schema,读取JSON数据集为DataFrame格式。读取JSON数据集方法为SQLContext.read().json()。该方法将String格式的RDD或JSON文件转换为DataFrame。

    需要注意的是,这里的JSON文件不是常规的JSON格式。JSON文件每一行必须包含一个独立的、自满足有效的JSON对象。如果用多行描述一个JSON对象,会导致读取出错。读取JSON数据集示例如下:
(1)Demo1:使用Spark自带的示例文件 --> people.json 文件

//定义路径:
val path ="/opt/module/datas/TestFile/people.json"

//读取Json文件,生成DataFrame:
val peopleDF = spark.read.json(path)

//打印Schema结构信息:
peopleDF.printSchema()

//创建临时视图:
peopleDF.createOrReplaceTempView("people")

//执行查询
spark.sql("SELECT name FROM people WHERE age=18").show

(5).使用JDBC(通过JDBC操作关系型数据库,mysql中的数据,通过JDBC加载到Spark中进行分析和处理)

    Spark SQL同样支持通过JDBC读取其他数据库的数据作为数据源。

Demo演示:使用Spark SQL读取Oracle数据库中的表。
(1)启动Spark Shell的时候,指定Oracle数据库的驱动

bin/spark-shell --master spark://hadoop:7077 --jars /opt/soft/mysql-connector-java-5.1.27.jar --driver-class-path /opt/soft/mysql-connector-java-5.1.27.jar 

(2)读取mysql数据库中的数据

(a)方式一:

val mysqlDF = spark.read.format("jdbc").
         option("url","jdbc:mysql://192.168.1.120:3306/company?serverTimezone=UTC&characterEncoding=utf-8").
         option("dbtable","emp").
         option("user","root").
         option("password","000000").load


mysqlDF.show

(b)方式二:定义 Properities类

//导入需要的类:
import java.util.Properties   

//定义属性:               
val mysqlProps = new Properties()
mysqlProps.setProperty("user","root")
mysqlProps.setProperty("password","000000")
//读取数据:

val mysqlDF1 = spark.read.jdbc("jdbc:mysql://192.168.1.120:3306/company?serverTimezone=UTC&characterEncoding=utf-8","emp",mysqlProps)

mysqlDF1.show

(6).使用Hive Table(把Hive中的数据,读取到Spark SQL 中)
(1)首先,搭建好Hive的环境(需要Hadoop)
(a)搭建台Hive,一台Hive Server(hadoop2),一台Hive Client(hadoop1)
这两台hive中其他配置文件一样,知识hive-site.xml有区别
其中Hive Server的hive-site.xml配置如下:

<configuration> 
    <property> 
        <name>hive.metastore.warehouse.dir</name>  
        <value>/user/hive/warehouse</value> 
    </property>  
    <property> 
        <name>javax.jdo.option.ConnectionURL</name>  
        <value>jdbc:mysql://hadoop1:3306/hive?serverTimezone=UTC</value> 
    </property>  
    <property> 
        <name>javax.jdo.option.ConnectionDriverName</name>  
        <value>com.mysql.jdbc.Driver</value> 
    </property>  
    <property> 
        <name>javax.jdo.option.ConnectionUserName</name>  
        <value>root</value> 
    </property>  
    <property> 
        <name>javax.jdo.option.ConnectionPassword</name>  
        <value>123456</value> 
    </property>  
    <property> 
        <name>hive.querylog.location</name>  
        <value>/data/hive/iotmp</value> 
    </property>  
    <property> 
        <name>hive.server2.logging.operation.log.location</name>  
    <value>/data/hive/operation_logs</value> 
    </property>  
    <property> 
        <name>datanucleus.readOnlyDatastore</name>  
        <value>false</value> 
    </property>  
    <property> 
        <name>datanucleus.fixedDatastore</name>  
        <value>false</value> 
    </property>  
    <property> 
        <name>datanucleus.autoCreateSchema</name>  
        <value>true</value> 
    </property>  
    <property> 
        <name>datanucleus.autoCreateTables</name>  
        <value>true</value> 
    </property>  
    <property> 
        <name>datanucleus.autoCreateColumns</name>  
        <value>true</value> 
    </property> 
    <property>
        <name>datanucleus.schema.autoCreateAll</name>
        <value>true</value>
    </property>
</configuration>

Hive Client 中hive-site.xml配置如下:

<configuration>
          <property>
                <name>hive.metastore.warehouse.dir</name>
                <value>/user/hive/warehouse</value>
          </property>
          <property>
                <name>hive.metastore.local</name>
                <value>false</value>
          </property>
          <property>
                <name>hive.metastore.uris</name>
                <value>thrift://192.168.1.122:9083</value>
          </property>
</configuration>    
Hive Client

(2)配置Spark SQL支持Hive
(a)只需要将以下文件拷贝到$SPARK_HOME/conf的目录下,即可

  • $HIVE_HOME/conf/hive-site.xml(拷贝Hive Client中的hive-site.xml)
  • $HADOOP_CONF_DIR/core-site.xml
  • $HADOOP_CONF_DIR/hdfs-site.xml

(3)启动hive:
启动Hive Server

cd /opt/module/hive-1.2.1

bin/hive --service metastore
Hive Server

启动Hive Client

cd /opt/module/hive-1.2.1

bin/hive
Hive Client

(3)使用Spark Shell操作Hive
(a)启动Spark Shell的时候,需要使用--jars指定mysql的驱动程序

启动Spark

cd /opt/module/spark-2.1.0-bin-hadoop2.7

bin/spark-shell --master://hadoop1:7077

spark.sql("select * from default.emp").show
查询Hive中的表

(b)创建表

spark.sql("create table movle.src (key INT, value STRING) row format    delimited fields terminated by ','")
创建表1
创建表2

(c)导入数据

spark.sql("load data local path '/root/temp/data.txt' into table src")

(d)查询数据

spark.sql("select * from src").show

(4)使用spark-sql操作Hive
(a)启动spark-sql的时候,需要使用--jars指定mysql的驱动程序
(b)操作Hive

spark.sql("show tables").show

三.性能优化

1.在内存中缓存数据

    性能调优主要是将数据放入内存中操作。通过spark.cacheTable("tableName")或者dataFrame.cache()。使用spark.uncacheTable("tableName")来从内存中去除table。
Demo案例:
(1)从Oracle数据库中读取数据,生成DataFrame

val mysqlDF = spark.read.format("jdbc")
        .option("url","jdbc:mysql://192.168.109.1:3306/company?serverTimezone=UTC&characterEncoding=utf-8")
        .option("dbtable","company.emp")
        .option("user","root")
        .option("password","000000").load
scala> val mysqlDF = spark.read.format("jdbc").option("url","jdbc:mysql://192.168.109.1:3306/company?serverTimezone=UTC&characterEncoding=utf-8").option("user","root").option("password","000000").option("dbtable","emp").option("driver","com.mysql.jdbc.Driver").load

(2)将DataFrame注册成表:

mysqlDF.registerTempTable("emp")

注意:必须注册成一张表,才可以缓存
(3)执行查询,并通过Web Console监控执行的时间

spark.sql("select * from emp").show

(4)将表进行缓存,并查询两次,并通过Web Console监控执行的时间

 spark.sqlContext.cacheTable("emp")

spark.sql("select * from emp").show

(5)清空缓存:

spark.sqlContext.cacheTable("emp")

spark.sqlContext.clearCache
2.性能优化相关参数

(1)将数据缓存到内存中的相关优化参数

spark.sql.inMemoryColumnarStorage.compressed
//默认为 true
//Spark SQL 将会基于统计信息自动地为每一列选择一种压缩编码方式。

spark.sql.inMemoryColumnarStorage.batchSize
//默认值:10000
//缓存批处理大小。缓存数据时, 较大的批处理大小可以提高内存利用率和压缩率,但同时也会带来 OOM(Out Of Memory)的风险。

(2)其他性能相关的配置选项(不过不推荐手动修改,可能在后续版本自动的自适应修改)

spark.sql.files.maxPartitionBytes
//默认值:128 MB
//读取文件时单个分区可容纳的最大字节数

spark.sql.files.openCostInBytes
//默认值:4M
//打开文件的估算成本, 按照同一时间能够扫描的字节数来测量。当往一个分区写入多个文件的时候会使用。高估更好, 这样的话小文件分区将比大文件分区更快 (先被调度)。

spark.sql.autoBroadcastJoinThreshold
//默认值:10M
//用于配置一个表在执行 join 操作时能够广播给所有 worker 节点的最大字节大小。通过将这个值设置为 -1 可以禁用广播。注意,当前数据统计仅支持已经运行了 ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan 命令的 Hive Metastore 表。

spark.sql.shuffle.partitions
//默认值:200
//用于配置 join 或聚合操作混洗(shuffle)数据时使用的分区数。

推荐阅读更多精彩内容