SELECT  a1,a2,a3  FROM  tableA  Where  condition 

• TreeNode可以细分成三种类型的Node：
  • UnaryNode 一元节点，即只有一个子节点。如Limit、Filter操作
  • BinaryNode 二元节点，即有左右子节点的二叉节点。如Jion、Union操作
  • LeafNode 叶子节点，没有子节点的节点。主要用户命令类操作，如SetCommand

• Rule的相关代码定义在sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/rules
• Rule在sparkSQL的analyzer、optimizer、SparkPlan等各个组件中都有应用到
• Rule是一个抽象类，具体的Rule实现是通过RuleExecutor完成
• Rule通过定义batch和batchs，可以简便的、模块化地对Tree进行transform操作
• Rule通过定义Once和FixedPoint，可以对Tree进行一次操作或多次操作（如对某些Tree进行多次迭代操作的时候，达到FixedPoint次数迭代或达到前后两次的树结构没变化才停止操作，具体参看RuleExecutor.apply）

/**源自sql/core/src/main/scala/org/apache/spark/sql/SQLContext.scala  */
  def sql(sqlText: String): SchemaRDD = {
    if (dialect == "sql") {
      new SchemaRDD(this, parseSql(sqlText))   //parseSql(sqlText)对sql语句进行语法解析
    } else {
      sys.error(s"Unsupported SQL dialect: $dialect")
    }
  }

/**源自sql/core/src/main/scala/org/apache/spark/sql/SQLContext.scala  */
  protected[sql] val parser = new catalyst.SqlParser
  protected[sql] def parseSql(sql: String): LogicalPlan = parser(sql)

/**源自sql/core/src/main/scala/org/apache/spark/sql/SchemaRDD.scala  */
class SchemaRDD(
    @transient val sqlContext: SQLContext,
    @transient val baseLogicalPlan: LogicalPlan)
  extends RDD[Row](sqlContext.sparkContext, Nil) with SchemaRDDLike

/**源自sql/core/src/main/scala/org/apache/spark/sql/SchemaRDDLike.scala  */
private[sql] trait SchemaRDDLike {
  @transient val sqlContext: SQLContext
  @transient val baseLogicalPlan: LogicalPlan
  private[sql] def baseSchemaRDD: SchemaRDD

  lazy val queryExecution = sqlContext.executePlan(baseLogicalPlan)

/**源自sql/core/src/main/scala/org/apache/spark/sql/SQLContext.scala  */
protected abstract class QueryExecution {
    def logical: LogicalPlan
   
    //对Unresolved LogicalPlan进行analyzer，生成resolved LogicalPlan
    lazy val analyzed = ExtractPythonUdfs(analyzer(logical))    
    //对resolved LogicalPlan进行optimizer，生成optimized LogicalPlan
    lazy val optimizedPlan = optimizer(analyzed)  
    // 将optimized LogicalPlan转换成PhysicalPlan
    lazy val sparkPlan = {
      SparkPlan.currentContext.set(self)
      planner(optimizedPlan).next()
    }
    // PhysicalPlan执行前的准备工作，生成可执行的物理计划
    lazy val executedPlan: SparkPlan = prepareForExecution(sparkPlan)

    //执行可执行物理计划
    lazy val toRdd: RDD[Row] = executedPlan.execute()

    ......
  }

1. SQL语句经过SqlParse解析成UnresolvedLogicalPlan；
2. 使用analyzer结合数据数据字典（catalog）进行绑定，生成resolvedLogicalPlan；
3. 使用optimizer对resolvedLogicalPlan进行优化，生成optimizedLogicalPlan；
4. 使用SparkPlan将LogicalPlan转换成PhysicalPlan；
5. 使用prepareForExecution()将PhysicalPlan转换成可执行物理计划；
6. 使用execute()执行可执行物理计划；
7. 生成SchemaRDD。

/**源自sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveContext.scala  */
override def sql(sqlText: String): SchemaRDD = {
    // 使用spark.sql.dialect定义采用的语法解析器
    if (dialect == "sql") {
      super.sql(sqlText)    //如果使用sql解析器，则使用sqlContext的sql方法
    } else if (dialect == "hiveql") {     //如果使用和hiveql解析器，则使用HiveQl.parseSql
      new SchemaRDD(this, HiveQl.parseSql(sqlText))
    }  else {
      sys.error(s"Unsupported SQL dialect: $dialect.  Try 'sql' or 'hiveql'")
    }
  }

/**源自src/main/scala/org/apache/spark/sql/hive/HiveQl.scala  */
  /** Returns a LogicalPlan for a given HiveQL string. */
  def parseSql(sql: String): LogicalPlan = {
    try {
      if (条件)   {
      //非hive命令的处理，如set、cache table、add jar等直接转化成command类型的LogicalPlan
      .....  
      } else {
        val tree = getAst(sql)
        if (nativeCommands contains tree.getText) {
          NativeCommand(sql)
        } else {
          nodeToPlan(tree) match {
            case NativePlaceholder => NativeCommand(sql)
            case other => other
          }
        }
      }
    } catch {
      //异常处理
      ......
    }
  }

• 首先考虑一些非hive语句的处理，这些命令属于sparkSQL本身的命令语句，如设置sparkSQL运行参数的set命令、cache table、add jar等，将这些语句转换成command类型的LogicalPlan；
• 如果是hive语句，则调用getAst(sql)使用hive的ParseUtils将该语句先解析成AST树，然后根据AST树中的关键字进行转换：类似命令型的语句、DDL类型的语句转换成command类型的LogicalPlan；其他的转换通过nodeToPlan转换成LogicalPlan。

/**源自src/main/scala/org/apache/spark/sql/hive/HiveQl.scala  */  
/** * Returns the AST for the given SQL string.    */
  def getAst(sql: String): ASTNode = ParseUtils.findRootNonNullToken((new ParseDriver).parse(sql))

/**源自sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveContext.scala  */ 
override protected[sql] def executePlan(plan: LogicalPlan): this.QueryExecution =
    new this.QueryExecution { val logical = plan }

/**源自sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveContext.scala  */
 protected[sql] abstract class QueryExecution extends super.QueryExecution {
    // TODO: Create mixin for the analyzer instead of overriding things here.
    override lazy val optimizedPlan =
      optimizer(ExtractPythonUdfs(catalog.PreInsertionCasts(catalog.CreateTables(analyzed))))

    override lazy val toRdd: RDD[Row] = executedPlan.execute().map(_.copy())
    ......
  }

/**源自sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveContext.scala  */
/* A catalyst metadata catalog that points to the Hive Metastore. */
  @transient
  override protected[sql] lazy val catalog = new HiveMetastoreCatalog(this) with OverrideCatalog {
    override def lookupRelation(
      databaseName: Option[String],
      tableName: String,
      alias: Option[String] = None): LogicalPlan = {

      LowerCaseSchema(super.lookupRelation(databaseName, tableName, alias))
    }
  }

/**源自sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveContext.scala  */
  /* An analyzer that uses the Hive metastore. */
  @transient
  override protected[sql] lazy val analyzer =
    new Analyzer(catalog, functionRegistry, caseSensitive = false)

/**源自sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveContext.scala  */
  @transient
  override protected[sql] val planner = hivePlanner

1. SQL语句经过HiveQl.parseSql解析成UnresolvedLogicalPlan，在这个解析过程中对hiveql语句使用getAst()获取AST树，然后再进行解析；
2. 使用analyzer结合数据hive源数据Metastore（新的catalog）进行绑定，生成resolvedLogicalPlan；
3. 使用optimizer对resolvedLogicalPlan进行优化，生成optimizedLogicalPlan，优化前使用了ExtractPythonUdfs(catalog.PreInsertionCasts(catalog.CreateTables(analyzed)))进行预处理；
4. 使用hivePlanner将LogicalPlan转换成PhysicalPlan；
5. 使用prepareForExecution()将PhysicalPlan转换成可执行物理计划；
6. 使用execute()执行可执行物理计划；
7. 执行后，使用map(_.copy)将结果导入SchemaRDD。

 

• core处理数据的输入输出，从不同的数据源获取数据（RDD、Parquet、json等），将查询结果输出成schemaRDD；
• catalyst处理查询语句的整个处理过程，包括解析、绑定、优化、物理计划等，说其是优化器，还不如说是查询引擎；
• hive对hive数据的处理
• hive-ThriftServer提供CLI和JDBC/ODBC接口

      在这四个模块中，catalyst处于最核心的部分，其性能优劣将影响整体的性能。由于发展时间尚短，还有很多不足的地方，但其插件式的设计，为未来的发展留下了很大的空间。下面是catalyst的一个设计图：

 其中虚线部分是以后版本要实现的功能，实线部分是已经实现的功能。从上图看，catalyst主要的实现组件有：

• sqlParse，完成sql语句的语法解析功能，目前只提供了一个简单的sql解析器；
• Analyzer，主要完成绑定工作，将不同来源的UnresolvedLogicalPlan 和数据元数据（如hive metastore、Schema catalog）进行绑定，生成resolvedLogicalPlan；
• optimizer对resolvedLogicalPlan进行优化，生成optimizedLogicalPlan；
• Planner将LogicalPlan转换成PhysicalPlan；
• CostModel，主要根据过去的性能统计数据，选择最佳的物理执行计划

这些组件的基本实现方法：

• 先将sql语句通过解析生成Tree，然后在不同阶段使用不同的Rule应用到Tree上，通过转换完成各个组件的功能。
• Analyzer使用Analysis Rules，配合数据元数据（如hive metastore、Schema catalog），完善UnresolvedLogicalPlan的属性而转换成resolvedLogicalPlan；
• optimizer使用Optimization Rules，对resolvedLogicalPlan进行合并、列裁剪、过滤器下推等优化作业而转换成optimizedLogicalPlan；
• Planner使用Planning Strategies，对optimizedLogicalPlan

关于本篇中涉及到的相关概念和组件在下篇再详细介绍。