select fieldA, fieldB, filedC from tableA where fieldA > 10;

/** * 测试代码 */object TestSpark {  case class Person(name: String, age: Long)
  def main(args: Array[String]): Unit = {    val spark = SparkSession.builder().appName("test").master("local").getOrCreate()
    import spark.implicits._    val df: DataFrame = spark.sparkContext.parallelize(Array(      Person("zhangsan", 10),      Person("lisi", 20),      Person("wangwu", 30)))      .toDF("name", "age")
    df.createTempView("people")
    /**     * 1.SparkSqlParser中的AstBuilder将语法树的各个节点转换为对应LogicalPlan节点，组成未解析的逻辑算子树，不包含数据信息与列信息     *     * 2.Analyzer将一系列规则作用在未解析逻辑算子树上，生成解析后的逻辑算子树     *     * 3.Optimizer将一系列优化规则应用在逻辑算子树中，确保结果正确的前提下改进低效结构，生成优化后的逻辑算子树     */    val sql = spark.sql("select name from people where age >= 20")    sql.queryExecution.debug  }}

SELECT A FROM TABLE

/** * A logical plan node with no children. */trait LeafNode extends LogicalPlan with LeafLike[LogicalPlan] 
/** * A logical plan node with single child. */trait UnaryNode extends LogicalPlan with UnaryLike[LogicalPlan] 
/** * A logical plan node with a left and right child. */trait BinaryNode extends LogicalPlan with BinaryLike[LogicalPlan]

spark.sql("select name from people where age >= 20")
logicalPlan: 'Project ['name]+- 'Filter ('age >= 20)   +- 'UnresolvedRelation `people`

override def batches: Seq[Batch] = Seq(    Batch("Substitution", fixedPoint,      // This rule optimizes `UpdateFields` expression chains so looks more like optimization rule.      // However, when manipulating deeply nested schema, `UpdateFields` expression tree could be      // very complex and make analysis impossible. Thus we need to optimize `UpdateFields` early      // at the beginning of analysis.      OptimizeUpdateFields,      CTESubstitution,      WindowsSubstitution,      EliminateUnions,      SubstituteUnresolvedOrdinals),    Batch("Disable Hints", Once,      new ResolveHints.DisableHints),    Batch("Hints", fixedPoint,      ResolveHints.ResolveJoinStrategyHints,      ResolveHints.ResolveCoalesceHints),    Batch("Simple Sanity Check", Once,      LookupFunctions),    Batch("Resolution", fixedPoint,      ResolveTableValuedFunctions(v1SessionCatalog) ::      ResolveNamespace(catalogManager) ::      new ResolveCatalogs(catalogManager) ::      ResolveUserSpecifiedColumns ::      ResolveInsertInto ::      ResolveRelations ::      ResolveTables ::      ResolvePartitionSpec ::      AddMetadataColumns ::      DeduplicateRelations ::      ResolveReferences ::      ResolveCreateNamedStruct ::      ResolveDeserializer ::      ResolveNewInstance ::      ResolveUpCast ::      ResolveGroupingAnalytics ::      ResolvePivot ::      ResolveOrdinalInOrderByAndGroupBy ::      ResolveAggAliasInGroupBy ::      ResolveMissingReferences ::      ExtractGenerator ::      ResolveGenerate ::      ResolveFunctions ::      ResolveAliases ::      ResolveSubquery ::      ResolveSubqueryColumnAliases ::      ResolveWindowOrder ::      ResolveWindowFrame ::      ResolveNaturalAndUsingJoin ::      ResolveOutputRelation ::      ExtractWindowExpressions ::      GlobalAggregates ::      ResolveAggregateFunctions ::      TimeWindowing ::      ResolveInlineTables ::      ResolveHigherOrderFunctions(catalogManager) ::      ResolveLambdaVariables ::      ResolveTimeZone ::      ResolveRandomSeed ::      ResolveBinaryArithmetic ::      ResolveUnion ::      typeCoercionRules ++      extendedResolutionRules : _*),    Batch("Remove TempResolvedColumn", Once, RemoveTempResolvedColumn),    Batch("Apply Char Padding", Once,      ApplyCharTypePadding),    Batch("Post-Hoc Resolution", Once,      Seq(ResolveCommandsWithIfExists) ++      postHocResolutionRules: _*),    Batch("Normalize Alter Table Field Names", Once, ResolveFieldNames),    Batch("Normalize Alter Table", Once, ResolveAlterTableChanges),    Batch("Remove Unresolved Hints", Once,      new ResolveHints.RemoveAllHints),    Batch("Nondeterministic", Once,      PullOutNondeterministic),    Batch("UDF", Once,      HandleNullInputsForUDF,      ResolveEncodersInUDF),    Batch("UpdateNullability", Once,      UpdateAttributeNullability),    Batch("Subquery", Once,      UpdateOuterReferences),    Batch("Cleanup", fixedPoint,      CleanupAliases),    Batch("HandleAnalysisOnlyCommand", Once,      HandleAnalysisOnlyCommand)  )

spark.sql("select name from people where age >= 20")
analyzed: Project [name#6]+- Filter (age#7L >= cast(20 as bigint))   +- SubqueryAlias `people`      +- Project [name#3 AS name#6, age#4L AS age#7L]         +- SerializeFromObject [staticinvoke(class org.apache.spark.unsafe.types.UTF8String, StringType, fromString, assertnotnull(assertnotnull(input[0, TestSpark$Person, true])).name, true, false) AS name#3, assertnotnull(assertnotnull(input[0, TestSpark$Person, true])).age AS age#4L]            +- ExternalRDD [obj#2]

 def defaultBatches: Seq[Batch] = {    val operatorOptimizationRuleSet =      Seq(        // Operator push down        PushProjectionThroughUnion,        ReorderJoin,        EliminateOuterJoin,        PushPredicateThroughJoin,        PushDownPredicate,        LimitPushDown,        ColumnPruning,        InferFiltersFromConstraints,        // Operator combine        CollapseRepartition,        CollapseProject,        CollapseWindow,        CombineFilters,        CombineLimits,        CombineUnions,        // Constant folding and strength reduction        NullPropagation,        ConstantPropagation,        FoldablePropagation,        OptimizeIn,        ConstantFolding,        ReorderAssociativeOperator,        LikeSimplification,        BooleanSimplification,        SimplifyConditionals,        RemoveDispensableExpressions,        SimplifyBinaryComparison,        PruneFilters,        EliminateSorts,        SimplifyCasts,        SimplifyCaseConversionExpressions,        RewriteCorrelatedScalarSubquery,        EliminateSerialization,        RemoveRedundantAliases,        RemoveRedundantProject,        SimplifyExtractValueOps,        CombineConcats) ++        extendedOperatorOptimizationRules
    val operatorOptimizationBatch: Seq[Batch] = {      val rulesWithoutInferFiltersFromConstraints =        operatorOptimizationRuleSet.filterNot(_ == InferFiltersFromConstraints)      Batch("Operator Optimization before Inferring Filters", fixedPoint,        rulesWithoutInferFiltersFromConstraints: _*) ::      Batch("Infer Filters", Once,        InferFiltersFromConstraints) ::      Batch("Operator Optimization after Inferring Filters", fixedPoint,        rulesWithoutInferFiltersFromConstraints: _*) :: Nil    }
    (Batch("Eliminate Distinct", Once, EliminateDistinct) ::    // Technically some of the rules in Finish Analysis are not optimizer rules and belong more    // in the analyzer, because they are needed for correctness (e.g. ComputeCurrentTime).    // However, because we also use the analyzer to canonicalized queries (for view definition),    // we do not eliminate subqueries or compute current time in the analyzer.    Batch("Finish Analysis", Once,      EliminateSubqueryAliases,      EliminateView,      ReplaceExpressions,      ComputeCurrentTime,      GetCurrentDatabase(sessionCatalog),      RewriteDistinctAggregates,      ReplaceDeduplicateWithAggregate) ::    //////////////////////////////////////////////////////////////////////////////////////////    // Optimizer rules start here    //////////////////////////////////////////////////////////////////////////////////////////    // - Do the first call of CombineUnions before starting the major Optimizer rules,    //   since it can reduce the number of iteration and the other rules could add/move    //   extra operators between two adjacent Union operators.    // - Call CombineUnions again in Batch("Operator Optimizations"),    //   since the other rules might make two separate Unions operators adjacent.    Batch("Union", Once,      CombineUnions) ::    // run this once earlier. this might simplify the plan and reduce cost of optimizer.    // for example, a query such as Filter(LocalRelation) would go through all the heavy    // optimizer rules that are triggered when there is a filter    // (e.g. InferFiltersFromConstraints). if we run this batch earlier, the query becomes just    // LocalRelation and does not trigger many rules    Batch("LocalRelation early", fixedPoint,      ConvertToLocalRelation,      PropagateEmptyRelation) ::    Batch("Pullup Correlated Expressions", Once,      PullupCorrelatedPredicates) ::    Batch("Subquery", Once,      OptimizeSubqueries) ::    Batch("Replace Operators", fixedPoint,      RewriteExceptAll,      RewriteIntersectAll,      ReplaceIntersectWithSemiJoin,      ReplaceExceptWithFilter,      ReplaceExceptWithAntiJoin,      ReplaceDistinctWithAggregate) ::    Batch("Aggregate", fixedPoint,      RemoveLiteralFromGroupExpressions,      RemoveRepetitionFromGroupExpressions) :: Nil ++    operatorOptimizationBatch) :+    Batch("Join Reorder", Once,      CostBasedJoinReorder) :+    Batch("Remove Redundant Sorts", Once,      RemoveRedundantSorts) :+    Batch("Decimal Optimizations", fixedPoint,      DecimalAggregates) :+    Batch("Object Expressions Optimization", fixedPoint,      EliminateMapObjects,      CombineTypedFilters) :+    Batch("LocalRelation", fixedPoint,      ConvertToLocalRelation,      PropagateEmptyRelation) :+    Batch("Extract PythonUDF From JoinCondition", Once,      PullOutPythonUDFInJoinCondition) :+    // The following batch should be executed after batch "Join Reorder" "LocalRelation" and    // "Extract PythonUDF From JoinCondition".    Batch("Check Cartesian Products", Once,      CheckCartesianProducts) :+    Batch("RewriteSubquery", Once,      RewritePredicateSubquery,      ColumnPruning,      CollapseProject,      RemoveRedundantProject) :+    Batch("UpdateAttributeReferences", Once,      UpdateNullabilityInAttributeReferences)  }

spark.sql("select name from people where age >= 20")
optimizedPlan: Project [name#3]+- Filter (age#4L >= 20)   +- SerializeFromObject [staticinvoke(class org.apache.spark.unsafe.types.UTF8String, StringType, fromString, assertnotnull(input[0, TestSpark$Person, true]).name, true, false) AS name#3, assertnotnull(input[0, TestSpark$Person, true]).age AS age#4L]      +- ExternalRDD [obj#2]

override def strategies: Seq[Strategy] =    experimentalMethods.extraStrategies ++      extraPlanningStrategies ++ (      PythonEvals ::      DataSourceV2Strategy ::      FileSourceStrategy ::      DataSourceStrategy(conf) ::      SpecialLimits ::      Aggregation ::      Window ::      JoinSelection ::      InMemoryScans ::      BasicOperators :: Nil)
  /**   * Override to add extra planning strategies to the planner. These strategies are tried after   * the strategies defined in [[ExperimentalMethods]], and before the regular strategies.   */  def extraPlanningStrategies: Seq[Strategy] = Nil

lazy val sparkPlan: SparkPlan = {    // We need to materialize the optimizedPlan here because sparkPlan is also tracked under    // the planning phase    assertOptimized()    executePhase(QueryPlanningTracker.PLANNING) {      // Clone the logical plan here, in case the planner rules change the states of the logical      // plan.      QueryExecution.createSparkPlan(sparkSession, planner, optimizedPlan.clone())    }  }
/**   * Transform a [[LogicalPlan]] into a [[SparkPlan]].   *   * Note that the returned physical plan still needs to be prepared for execution.   */  def createSparkPlan(      sparkSession: SparkSession,      planner: SparkPlanner,      plan: LogicalPlan): SparkPlan = {    // TODO: We use next(), i.e. take the first plan returned by the planner, here for now,    //       but we will implement to choose the best plan.    planner.plan(ReturnAnswer(plan)).next()  }

// executedPlan should not be used to initialize any SparkPlan. It should be  // only used for execution.  lazy val executedPlan: SparkPlan = {    // We need to materialize the optimizedPlan here, before tracking the planning phase, to ensure    // that the optimization time is not counted as part of the planning phase.    assertOptimized()    executePhase(QueryPlanningTracker.PLANNING) {      // clone the plan to avoid sharing the plan instance between different stages like analyzing,      // optimizing and planning.      QueryExecution.prepareForExecution(preparations, sparkPlan.clone())    }  }

lazy val toRdd: RDD[InternalRow] = new SQLExecutionRDD(    executedPlan.execute(), sparkSession.sessionState.conf)

  /**   * Returns the result of this query as an RDD[InternalRow] by delegating to `doExecute` after   * preparations.   *   * Concrete implementations of SparkPlan should override `doExecute`.   */  final def execute(): RDD[InternalRow] = executeQuery {    if (isCanonicalizedPlan) {      throw new IllegalStateException("A canonicalized plan is not supposed to be executed.")    }    doExecute()  }

spark.sql("select name from people where age >= 20")
sparkPlan: Project [name#3]+- Filter (age#4L >= 20)   +- SerializeFromObject [staticinvoke(class org.apache.spark.unsafe.types.UTF8String, StringType, fromString, assertnotnull(input[0, TestSpark$Person, true]).name, true, false) AS name#3, assertnotnull(input[0, TestSpark$Person, true]).age AS age#4L]      +- Scan[obj#2]