SparkSession是在使用类型化数据集(或基于非类型化Row-基于DataFrame)数据抽象开发Spark SQL应用程序时创建的首批对象之一。
在Spark 2.0中，SparkSession将SQLContext和HiveContext合并到一个对象中。
使用SparkSession.builder方法来创建一个SparkSession实例，使用stop方法停止SparkSession实例。
import org.apache.spark.sql.SparkSession val spark: SparkSession = SparkSession.builder .appName("My Spark Application") // optional and will be auto generated if not specified .master("local[*]") // only for demo and testing purposes, use spark-submit instead .enableHiveSupport() // self-explanatory, isn't it? .config("spark.sql.warehouse.dir", "target/spark-warehouse") .getOrCreate
...
...
spark.stop // 停止当前的SparkSession的方法
一个Spark SQL应用中可以有多个SparkSession。通常的用例是在每个SparkSession的catalog中保持关系实体在逻辑上独立。
可以通过支持外部的Hive metastore来启用Hive支持(这在使用Apache Impala等其他大数据项目的项目中尤其有用）。
implicitis对象
implicits对象是一个具有Scala隐式方法(又名转换)的助手类，用于将Scala对象转换为Datasets、DataFrame和Columns对象。它还为Scala的“基本”类型定义了编码器(Encoder)，例如Int、Double、String , 以及它们的Product和集合。
val spark = SparkSession.builder.getOrCreate() import spark.implicits._
implicits对象支持从任何类型(存在于Encoder范围内)的RDD创建数据集，或case类或元组，和Seq。implicits对象还提供从Scala Symbol或 $ 到 Column 的转换。
它也提供从RDD或Product类型（如case类或元组）的Seq到DataFrame的转换。它能直接把Int、Long、String的RDD转化为带有单个列名为"_1"的列的DataFrame。只允许对Int、Long、String等原始类型的RDD调用toDF方法
根据给定的Encoder创建空Dataset—— emptyDataset算子
emptyDataset 创建一个空 Dataset，类型为T。emptyDataset 创建了一个 LocalRelation logical query plan 。
emptyDataset[T: Encoder]: Dataset[T] scala> val strings = spark.emptyDataset[String] strings: org.apache.spark.sql.Dataset[String] = [value: string] scala> strings.printSchema root |-- value: string (nullable = true)
从本地Collection或RDD创建Dataset —— createDataset方法
createDataset是一个实验性的API，用于从本地Scala集合(即Seq[T]、Java List[T]或分布式RDD[T])创建Dataset。
createDataset[T : Encoder](data: Seq[T]): Dataset[T] createDataset[T : Encoder](data: RDD[T]): Dataset[T] scala> val one = spark.createDataset(Seq(1)) one: org.apache.spark.sql.Dataset[Int] = [value: int] scala> one.show +-----+ |value| +-----+ | 1| +-----+
createDataset 创建一个 LocalRelation（为输入的集合数据）或 LogicalRDD（为输入的 RDD[T]）。
提示：最好使用 scala implicits 和 toDS方法，而不是creatDataset创建数据集，这样就会自动进行类型转换
val spark: SparkSession = ... import spark.implicits._ scala> val one = Seq(1).toDS one: org.apache.spark.sql.Dataset[Int] = [value: int]
在内部，createDataset首先在范围内查找隐式表达式Encoder以访问schema的AttributeReference。目前只支持未解决的表达式Encoder。
表达式编码器被用来将（输入的Seq[T]的）元素映射到 InternalRows 集合中。 有了引用和行，createDataset返回一个带有LocalRelation逻辑查询计划的Dataset。
创建单长列的Dataset——range算子
range(end: Long): Dataset[java.lang.Long]
range(start: Long, end: Long): Dataset[java.lang.Long]
range(start: Long, end: Long, step: Long): Dataset[java.lang.Long]
range(start: Long, end: Long, step: Long, numPartitions: Int): Dataset[java.lang.Long]
range方法族创建Long类型数值的Dataset
scala> spark.range(start = 0, end = 4, step = 2, numPartitions = 5).show +---+ | id| +---+ | 0| | 2| +---+
在内部，range 创建了一个新的带有logical plan和Encoder.LONG encoder 的 Dataset[Long]。
创建空的DataFrame—— emptyDataFrame方法
emptyDataFrame: DataFrame
它调用了 createDataFrame方法，传入空的RDD[Row]和空schema的StructType(Nil)。它创建了一个没有行和列的空DataFrame
通过局部Collections或RDD来创建DataFrame——createDataFrame方法
createDataFrame[A <: Product : TypeTag](rdd: RDD[A]): DataFrame createDataFrame[A <: Product : TypeTag](data: Seq[A]): DataFrame createDataFrame(rowRDD: RDD[Row], schema: StructType): DataFrame // private[sql] createDataFrame(rowRDD: RDD[Row], schema: StructType, needsConversion: Boolean): DataFrame
它使用RDD[Row]和输入的schema来创建DataFrame，假定rowRDD中的行都匹配这个schema。
执行SQL查询（SQL模式）——sql方法
sql(sqlText: String): DataFrame
sql方法执行sqlText这个SQL语句块，并创建DataFrame。
sql在spark-shell中已经被import了，可以直接使用。
scala> sql("SHOW TABLES").show +---------+-----------+ |tableName|isTemporary| +---------+-----------+ | testdata| false| +---------+-----------+
在内部，sql 请求当前的 ParserInterface去执行一个SQL查询，给出LogicalPlan。sql使用 SessionState访问当前的 ParserInterface。
然后，sql使用当前的 SparkSession和这个LogicalPlan创建 DataFrame。
访问UDF注册接口—— udf 属性
udf: UDFRegistration
udf 属性可以用来访问UDFRegistration，UDFRegistration允许为基于SQL的查询注册user-defined function（用户自定义函数）。
val spark: SparkSession = ... spark.udf.register("myUpper", (s: String) => s.toUpperCase) val strs = ('a' to 'c').map(_.toString).toDS strs.registerTempTable("strs") scala> sql("SELECT *, myUpper(value) UPPER FROM strs").show +-----+-----+ |value|UPPER| +-----+-----+ | a| A| | b| B| | c| C| +-----+-----+
在内部，udf 仅仅是SessionState.udfRegistration的别名。
// In org.apache.spark.sql.SparkSession.scala def udf: UDFRegistration = sessionState.udfRegistration
为表创建DataFrame（把表加载成DataFrame）—— table 方法
table(tableName: String): DataFrame (1) table(tableIdent: TableIdentifier): DataFrame // private[sql]
方法1 把 tableName 解析成为一个 TableIdentifier，然后调用另一个table 方法。
table方法把输入的表tableName（仅在session catalog会话目录中可用）封装成一个DataFrame
scala> spark.version res0: String = 2.3.0 scala> spark.catalog.tableExists("t1") res1: Boolean = true // t1 exists in the catalog // let's load it val t1 = spark.table("t1")
访问元数据存储—— catalog 属性
catalog: Catalog
catalog 属性是一个惰性接口，它可以访问当前元数据存储，例如（关系型实体如数据库、表、函数、表的列和视图）的 data catalog。
通过catalog，用户可以create、drop、alter或query数据库、表、函数。
scala> spark.catalog.listTables.show +------------------+--------+-----------+---------+-----------+ | name|database|description|tableType|isTemporary| +------------------+--------+-----------+---------+-----------+ |my_permanent_table| default| null| MANAGED| false| | strs| null| null|TEMPORARY| true| +------------------+--------+-----------+---------+-----------+
在内部，catalog创建了一个使用当前SparkSession的CatalogImpl对象
@transient lazy val catalog: Catalog = new CatalogImpl(self)
访问 DataFrameReader —— read 方法
read 方法返回一个 DataFrameReader，DataFrameReader用来从外部存储系统读取数据并把数据加载成一个 DataFrame
read: DataFrameReader val spark: SparkSession = // create instance val dfReader: DataFrameReader = spark.read
运行时配置 —— conf 属性
@transient lazy val conf: RuntimeConfig = new RuntimeConfig(sessionState.conf)
conf 返回当前运行时的配置（作为一个RuntimeConfig对象），这个配置封装了 SQLConf。
readStream 方法返回一个 DataStreamReader
streams 属性
def stream: StreamingQueryManager = sessionState.streamingQueryManager
streams 属性通过 SessionState访问StreamingQueryManager，返回的StreamingQueryManager可以激活所有的StreamingQuery
val spark: SparkSession = ...
spark.streams.active.foreach(println)
experimentalMethods 属性
def experimental: ExperimentalMethods = sessionState.experimentalMethods
experimentalMethods是一个带有 ExperimentalMethods 的扩展点，它是每个会话中额外策略和Rule[LogicalPlan]的集合。
experimental 在 SparkPlanner和 SparkOptimizer中被使用。Hive和Structured Streaming将其用于自己的额外策略和优化规则。
newSession 方法
// Start a new session with isolated SQL configurations, temporary tables, registered functions are isolated, // but sharing the underlying `SparkContext` and cached data. def newSession(): SparkSession = { new SparkSession(sparkContext, Some(sharedState), parentSessionState = None, extensions) }
newSession 使用当前的SparkContext和SharedState 创建（启动）一个新的 SparkSession。
scala> println(sc.version) 2.3.0 scala> val newSession = spark.newSession newSession: org.apache.spark.sql.SparkSession = org.apache.spark.sql.SparkSession@122f58a
关停 SparkSession —— stop 方法
/** * Stop the underlying `SparkContext`. * * @since 2.0.0 */ def stop(): Unit = { sparkContext.stop() }
从 BaseRelation 创建DataFrame —— baseRelationToDataFrame 方法
/** * Convert a `BaseRelation` created for external data sources into a `DataFrame`. * * @since 2.0.0 */ def baseRelationToDataFrame(baseRelation: BaseRelation): DataFrame = { Dataset.ofRows(self, LogicalRelation(baseRelation)) }
此方法将输入的BaseRelation对象封装到LogicalRelation内部，并通过这个LogicalRelation对象创建 DataFrame。
LogicalRelation是 BaseRelation 的一个逻辑计划适配器，所以 BaseRelation可以是一个逻辑计划的一部分。
baseRelationToDataFrame被使用的场景：
1. DataFrameReader：从一个支持多路径的数据源中加载数据
2. DataFrameReader：使用jdbc从一个外部表中加载数据
3. TextInputCSVDataSource：创建一个String的 Dataset
4. TextInputJsonDataSource：创建一个String的 Dataset
构造 SessionState —— instantiateSessionState 内部方法（私有方法）
/** * Helper method to create an instance of `SessionState` based on `className` from conf. * The result is either `SessionState` or a Hive based `SessionState`. */ private def instantiateSessionState( className: String, sparkSession: SparkSession): SessionState = {...}
instantiateSessionState 利用 className 创建和构造一个BaseSessionStateBuilder，初始化SessionState类时可能会抛出IllegalArgumentException。
sessionStateClassName 内部方法
private def sessionStateClassName(conf: SparkConf): String = { conf.get(CATALOG_IMPLEMENTATION) match { case "hive" => HIVE_SESSION_STATE_BUILDER_CLASS_NAME case "in-memory" => classOf[SessionStateBuilder].getCanonicalName } }
对于每个spark.sql.catalogImplementation，sessionStateClassName都给出了SessionState的类名：
hive - org.apache.spark.sql.hive.HiveSessionStateBuilder
in-memory - org.apache.spark.sql.internal.SessionStateBuilder
从内部二进制行的RDD创建DataFrame —— internalCreateDataFrame 内部方法
/** * Creates a `DataFrame` from an `RDD[InternalRow]`. */ private[sql] def internalCreateDataFrame( catalystRows: RDD[InternalRow], schema: StructType, isStreaming: Boolean = false): DataFrame = { // TODO: use MutableProjection when rowRDD is another DataFrame and the applied // schema differs from the existing schema on any field data type. val logicalPlan = LogicalRDD( schema.toAttributes, catalystRows, isStreaming = isStreaming)(self) Dataset.ofRows(self, logicalPlan) }
此方法使用 LogicalRDD创建DataFrame。使用情景为：
1. DataFrameReader 被请求以JSON或CSV的Dataset创建一个DataFrame
2. SparkSession 被请求 以行的RDD创建一个DataFrame
3. InsertIntoDataSourceCommand 被执行