spark-sql-spark技术分享-第17页

ResolveAliases Logical Resolution Rule

ResolveAliases is a logical resolution rule that the logical query plan analyzer uses to FIXME in an entire logical query plan.

Technically, ResolveAliases is just a Catalyst rule for transforming logical plans, i.e. Rule[LogicalPlan].

ResolveAliases is part of Resolution fixed-point batch of rules.

Note	`ResolveAliases` is a Scala object inside Analyzer class.



import spark.sessionState.analyzer.ResolveAliases

// FIXME Using ResolveAliases rule

1

2

3

4

5

6

7

import spark.sessionState.analyzer.ResolveAliases

// FIXME Using ResolveAliases rule

Applying ResolveAliases to Logical Plan — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of Rule Contract to apply a rule to a logical plan.

apply…FIXME

`assignAliases` Internal Method



assignAliases(exprs: Seq[NamedExpression]): Seq[NamedExpression]

1

2

3

4

5

assignAliases(exprs: Seq[NamedExpression]): Seq[NamedExpression]

assignAliases…FIXME

Note	`assignAliases` is used when…FIXME

RelationConversions Logical PostHoc Evaluation Rule — Converting Hive Tables

RelationConversions is a logical posthoc resolution rule that the Hive-specific logical query plan analyzer uses to convert a Hive table…FIXME.

Note	A Hive table is when the `provider` is `hive` in table metadata.

Caution

FIXME Show example of a hive table, e.g. spark.table(…)

RelationConversions is created exclusively when the Hive-specific logical query plan analyzer is created.

Executing Rule — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of the Rule Contract to execute (apply) a rule on a TreeNode (e.g. LogicalPlan).

apply traverses the input logical plan looking for a InsertIntoTable with HiveTableRelation logical operators or HiveTableRelation logical operator alone.

For a InsertIntoTable with non-partitioned HiveTableRelation relation (that can be converted) apply converts the HiveTableRelation to a LogicalRelation.

For a HiveTableRelation logical operator alone apply…FIXME

Creating RelationConversions Instance

RelationConversions takes the following when created:

Does Table Use Parquet or ORC SerDe? — `isConvertible` Internal Method



isConvertible(relation: HiveTableRelation): Boolean

1

2

3

4

5

isConvertible(relation: HiveTableRelation): Boolean

isConvertible is positive when the input HiveTableRelation is a parquet or ORC table (and corresponding SQL properties are enabled).

Internally, isConvertible takes the Hive SerDe of the table (from table metadata) if available or assumes no SerDe.

isConvertible is turned on when either condition holds:

The Hive SerDe is parquet (aka parquet table) and spark.sql.hive.convertMetastoreParquet configuration property is enabled (which is by default)
The Hive SerDe is orc (aka orc table) and spark.sql.hive.convertMetastoreOrc internal configuration property is enabled (which is by default)

Note	`isConvertible` is used when `RelationConversions` is executed.

Converting HiveTableRelation to LogicalRelation — `convert` Internal Method



convert(relation: HiveTableRelation): LogicalRelation

1

2

3

4

5

convert(relation: HiveTableRelation): LogicalRelation

convert takes SerDe of (the storage of) the input HiveTableRelation and converts HiveTableRelation to LogicalRelation, i.e.

For parquet serde, convert adds mergeSchema option being the value of spark.sql.hive.convertMetastoreParquet.mergeSchema configuration property (disabled by default) and requests HiveMetastoreCatalog to convertToLogicalRelation (with ParquetFileFormat as fileFormatClass).

For non-parquet serde, convert assumes ORC format.

When spark.sql.orc.impl configuration property is native (default) convert requests HiveMetastoreCatalog to convertToLogicalRelation (with org.apache.spark.sql.execution.datasources.orc.OrcFileFormat as fileFormatClass).
Otherwise, convert requests HiveMetastoreCatalog to convertToLogicalRelation (with org.apache.spark.sql.hive.orc.OrcFileFormat as fileFormatClass).

Note	`convert` uses HiveSessionCatalog to access the HiveMetastoreCatalog.

Note

convert is used when RelationConversions logical evaluation rule does the following transformations:

Transforms a InsertIntoTable with HiveTableRelation with a Hive table (i.e. with hive provider) that is not partitioned and uses parquet or orc data storage format
Transforms a HiveTableRelation with a Hive table (i.e. with hive provider) that uses parquet or orc data storage format

PreWriteCheck Extended Analysis Check

PreWriteCheck is an extended analysis check that verifies correctness of a logical query plan with regard to InsertIntoTable unary logical operator (right before analysis can be considered complete).

PreWriteCheck is part of the extended analysis check rules of the logical Analyzer in BaseSessionStateBuilder and HiveSessionStateBuilder.

PreWriteCheck is simply a function of LogicalPlan that…FIXME

Executing Function — `apply` Method



apply(plan: LogicalPlan): Unit

1

2

3

4

5

apply(plan: LogicalPlan): Unit

Note	`apply` is part of Scala’s scala.Function1 contract to create a function of one parameter.

apply traverses the input logical query plan and finds InsertIntoTable unary logical operators.

For an InsertIntoTable with a LogicalRelation…FIXME
For any InsertIntoTable, apply throws a AnalysisException if the logical plan for the table to insert into is neither a LeafNode nor one of the following leaf logical operators: Range, OneRowRelation, LocalRelation.

Inserting into an RDD-based table is not allowed.

1
2
3
4
5

Inserting into an RDD-based table is not allowed.

PreprocessTableCreation

2013-02-19admin阅读(1438)

PreprocessTableCreation PostHoc Logical Resolution Rule

PreprocessTableCreation is a posthoc logical resolution rule that resolves a logical query plan with CreateTable logical operators.

PreprocessTableCreation is part of the Post-Hoc Resolution once-executed batch of the Hive-specific and the default logical analyzers.

PreprocessTableCreation is simply a Catalyst rule for transforming logical plans, i.e. Rule[LogicalPlan].

PreprocessTableCreation takes a SparkSession when created.

Executing Rule — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of the Rule Contract to execute (apply) a rule on a TreeNode (e.g. LogicalPlan).

apply…FIXME

LookupFunctions

2013-02-18admin阅读(1768)

LookupFunctions Logical Rule — Checking Whether UnresolvedFunctions Are Resolvable

LookupFunctions is a logical rule that the logical query plan analyzer uses to make sure that UnresolvedFunction expressions can be resolved in an entire logical query plan.

LookupFunctions is similar to ResolveFunctions logical resolution rule, but it is ResolveFunctions to resolve UnresolvedFunction expressions while LookupFunctions is just a sanity check that a future resolution is possible if tried.

Technically, LookupFunctions is just a Catalyst rule for transforming logical plans, i.e. Rule[LogicalPlan].

Note	`LookupFunctions` does not however transform a logical plan.

LookupFunctions is part of Simple Sanity Check one-off batch of rules.

Note	`LookupFunctions` is a Scala object inside Analyzer class.



// Using Catalyst DSL to create a logical plan with an unregistered function
import org.apache.spark.sql.catalyst.dsl.plans._
val t1 = table("t1")

import org.apache.spark.sql.catalyst.dsl.expressions._
val f1 = 'f1.function()

val plan = t1.select(f1)
scala> println(plan.numberedTreeString)
00 'Project [unresolvedalias('f1(), None)]
01 +- 'UnresolvedRelation `t1`

// Make sure the function f1 does not exist
import org.apache.spark.sql.catalyst.FunctionIdentifier
spark.sessionState.catalog.dropFunction(FunctionIdentifier("f1"), ignoreIfNotExists = true)

assert(spark.catalog.functionExists("f1") == false)

import spark.sessionState.analyzer.LookupFunctions
scala> LookupFunctions(plan)
org.apache.spark.sql.AnalysisException: Undefined function: 'f1'. This function is neither a registered temporary function nor a permanent function registered in the database 'default'.;
  at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15$$anonfun$applyOrElse$49.apply(Analyzer.scala:1198)
  at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15$$anonfun$applyOrElse$49.apply(Analyzer.scala:1198)
  at org.apache.spark.sql.catalyst.analysis.package$.withPosition(package.scala:48)
  at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15.applyOrElse(Analyzer.scala:1197)
  at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15.applyOrElse(Analyzer.scala:1195)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

// Using Catalyst DSL to create a logical plan with an unregistered function

import org.apache.spark.sql.catalyst.dsl.plans._

val t1 = table("t1")

import org.apache.spark.sql.catalyst.dsl.expressions._

val f1 = 'f1.function()

val plan = t1.select(f1)

scala> println(plan.numberedTreeString)

00 'Project [unresolvedalias('f1(), None)]

01 +- 'UnresolvedRelation `t1`

// Make sure the function f1 does not exist

import org.apache.spark.sql.catalyst.FunctionIdentifier

spark.sessionState.catalog.dropFunction(FunctionIdentifier("f1"), ignoreIfNotExists = true)

assert(spark.catalog.functionExists("f1") == false)

import spark.sessionState.analyzer.LookupFunctions

scala> LookupFunctions(plan)

org.apache.spark.sql.AnalysisException: Undefined function: 'f1'. This function is neither a registered temporary function nor a permanent function registered in the database 'default'.;

at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15$$anonfun$applyOrElse$49.apply(Analyzer.scala:1198)

at org.apache.spark.sql.catalyst.analysis.package$.withPosition(package.scala:48)

at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15.applyOrElse(Analyzer.scala:1197)

at org.apache.spark.sql.catalyst.analysis.Analyzer$LookupFunctions$$anonfun$apply$15.applyOrElse(Analyzer.scala:1195)

Applying LookupFunctions to Logical Plan — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of Rule Contract to apply a rule to a logical plan.

apply finds all UnresolvedFunction expressions (in every logical operator in the input logical plan) and requests the SessionCatalog to check if their functions exist.

apply does nothing if a function exists or reports a NoSuchFunctionException (that fails logical analysis).



Undefined function: '[func]'. This function is neither a registered temporary function nor a permanent function registered in the database '[db]'.

1

2

3

4

5

Undefined function: '[func]'. This function is neither a registered temporary function nor a permanent function registered in the database '[db]'.

InConversion

2013-02-17admin阅读(2861)

InConversion Type Coercion Logical Rule

InConversion is a type coercion logical rule that coerceTypes in a logical plan.

Coercing Types in Logical Plan — `coerceTypes` Method



coerceTypes(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

coerceTypes(plan: LogicalPlan): LogicalPlan

Note	`coerceTypes` is part of the TypeCoercionRule Contract to coerce types in a logical plan.

coerceTypes…FIXME

HiveAnalysis

2013-02-16admin阅读(1585)

HiveAnalysis PostHoc Logical Resolution Rule

HiveAnalysis is a logical posthoc resolution rule that the Hive-specific logical query plan analyzer uses to FIXME.

Technically, HiveAnalysis is a Catalyst rule for transforming logical plans, i.e. Rule[LogicalPlan].



// FIXME Example of HiveAnalysis

1

2

3

4

5

// FIXME Example of HiveAnalysis

Applying HiveAnalysis Rule to Logical Plan (Executing HiveAnalysis) — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of Rule Contract to apply a rule to a logical plan.

apply…FIXME

HandleNullInputsForUDF

2013-02-15admin阅读(1372)

HandleNullInputsForUDF Logical Evaluation Rule

HandleNullInputsForUDF is a logical evaluation rule (i.e. Rule[LogicalPlan]) that Spark SQL’s logical query plan analyzer uses to…FIXME

FindDataSourceTable

2013-02-14admin阅读(1646)

FindDataSourceTable Logical Evaluation Rule for Resolving UnresolvedCatalogRelations

FindDataSourceTable is a Catalyst rule that the default and Hive-specific logical query plan analyzers use for resolving UnresolvedCatalogRelations in a logical plan for the following cases:

InsertIntoTables with UnresolvedCatalogRelation (for datasource and hive tables)
“Standalone” UnresolvedCatalogRelations

Note	`UnresolvedCatalogRelation` leaf logical operator is a placeholder that ResolveRelations logical evaluation rule adds to a logical plan while resolving UnresolvedRelations leaf logical operators.

FindDataSourceTable is part of additional rules in Resolution fixed-point batch of rules.



scala> :type spark
org.apache.spark.sql.SparkSession

// Example: InsertIntoTable with UnresolvedCatalogRelation
// Drop tables to make the example reproducible
val db = spark.catalog.currentDatabase
Seq("t1", "t2").foreach { t =>
  spark.sharedState.externalCatalog.dropTable(db, t, ignoreIfNotExists = true, purge = true)
}

// Create tables
sql("CREATE TABLE t1 (id LONG) USING parquet")
sql("CREATE TABLE t2 (id LONG) USING orc")

import org.apache.spark.sql.catalyst.dsl.plans._
val plan = table("t1").insertInto(tableName = "t2", overwrite = true)
scala> println(plan.numberedTreeString)
00 'InsertIntoTable 'UnresolvedRelation `t2`, true, false
01 +- 'UnresolvedRelation `t1`

// Transform the logical plan with ResolveRelations logical rule first
// so UnresolvedRelations become UnresolvedCatalogRelations
import spark.sessionState.analyzer.ResolveRelations
val planWithUnresolvedCatalogRelations = ResolveRelations(plan)
scala> println(planWithUnresolvedCatalogRelations.numberedTreeString)
00 'InsertIntoTable 'UnresolvedRelation `t2`, true, false
01 +- 'SubqueryAlias t1
02    +- 'UnresolvedCatalogRelation `default`.`t1`, org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe

// Let's resolve UnresolvedCatalogRelations then
import org.apache.spark.sql.execution.datasources.FindDataSourceTable
val r = new FindDataSourceTable(spark)
val tablesResolvedPlan = r(planWithUnresolvedCatalogRelations)
// FIXME Why is t2 not resolved?!
scala> println(tablesResolvedPlan.numberedTreeString)
00 'InsertIntoTable 'UnresolvedRelation `t2`, true, false
01 +- SubqueryAlias t1
02    +- Relation[id#10L] parquet

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

scala> :type spark

org.apache.spark.sql.SparkSession

// Example: InsertIntoTable with UnresolvedCatalogRelation

// Drop tables to make the example reproducible

val db = spark.catalog.currentDatabase

Seq("t1", "t2").foreach { t =>

spark.sharedState.externalCatalog.dropTable(db, t, ignoreIfNotExists = true, purge = true)

}

// Create tables

sql("CREATE TABLE t1 (id LONG) USING parquet")

sql("CREATE TABLE t2 (id LONG) USING orc")

import org.apache.spark.sql.catalyst.dsl.plans._

val plan = table("t1").insertInto(tableName = "t2", overwrite = true)

scala> println(plan.numberedTreeString)

00 'InsertIntoTable 'UnresolvedRelation `t2`, true, false

01 +- 'UnresolvedRelation `t1`

// Transform the logical plan with ResolveRelations logical rule first

// so UnresolvedRelations become UnresolvedCatalogRelations

import spark.sessionState.analyzer.ResolveRelations

val planWithUnresolvedCatalogRelations = ResolveRelations(plan)

scala> println(planWithUnresolvedCatalogRelations.numberedTreeString)

00 'InsertIntoTable 'UnresolvedRelation `t2`, true, false

01 +- 'SubqueryAlias t1

02 +- 'UnresolvedCatalogRelation `default`.`t1`, org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe

// Let's resolve UnresolvedCatalogRelations then

import org.apache.spark.sql.execution.datasources.FindDataSourceTable

val r = new FindDataSourceTable(spark)

val tablesResolvedPlan = r(planWithUnresolvedCatalogRelations)

// FIXME Why is t2 not resolved?!

scala> println(tablesResolvedPlan.numberedTreeString)

00 'InsertIntoTable 'UnresolvedRelation `t2`, true, false

01 +- SubqueryAlias t1

02 +- Relation[id#10L] parquet

Applying FindDataSourceTable Rule to Logical Plan (and Resolving UnresolvedCatalogRelations in Logical Plan) — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of Rule Contract to apply a rule to a logical plan.

apply…FIXME

`readHiveTable` Internal Method



readHiveTable(table: CatalogTable): LogicalPlan

1

2

3

4

5

readHiveTable(table: CatalogTable): LogicalPlan

readHiveTable simply creates a HiveTableRelation for the input CatalogTable.

Note	`readHiveTable` is used when `FindDataSourceTable` is requested to resolving UnresolvedCatalogRelations in a logical plan.

`readDataSourceTable` Internal Method



readDataSourceTable(table: CatalogTable): LogicalPlan

1

2

3

4

5

readDataSourceTable(table: CatalogTable): LogicalPlan

readDataSourceTable…FIXME

Note	`readDataSourceTable` is used exclusively when `FindDataSourceTable` logical evaluation rule is executed (for data source tables).

ExtractWindowExpressions

2013-02-13admin阅读(1367)

ExtractWindowExpressions Logical Resolution Rule

ExtractWindowExpressions is a logical resolution rule that transforms a logical query plan and replaces (extracts) WindowExpression expressions with Window logical operators.

ExtractWindowExpressions is part of the Resolution fixed-point batch in the standard batches of the Analyzer.

ExtractWindowExpressions is simply a Catalyst rule for transforming logical plans, i.e. Rule[LogicalPlan].

Note	`ExtractWindowExpressions` is a Scala object inside Analyzer class (so you have to create an instance of the `Analyzer` class to access it or simply use SessionState).



import spark.sessionState.analyzer.ExtractWindowExpressions

// Example 1: Filter + Aggregate with WindowExpressions in aggregateExprs
val q = ???
val plan = q.queryExecution.logical
val afterExtractWindowExpressions = ExtractWindowExpressions(plan)

// Example 2: Aggregate with WindowExpressions in aggregateExprs
val q = ???
val plan = q.queryExecution.logical
val afterExtractWindowExpressions = ExtractWindowExpressions(plan)

// Example 3: Project with WindowExpressions in projectList
val q = ???
val plan = q.queryExecution.logical
val afterExtractWindowExpressions = ExtractWindowExpressions(plan)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

import spark.sessionState.analyzer.ExtractWindowExpressions

// Example 1: Filter + Aggregate with WindowExpressions in aggregateExprs

val q = ???

val plan = q.queryExecution.logical

val afterExtractWindowExpressions = ExtractWindowExpressions(plan)

// Example 2: Aggregate with WindowExpressions in aggregateExprs

val q = ???

val plan = q.queryExecution.logical

val afterExtractWindowExpressions = ExtractWindowExpressions(plan)

// Example 3: Project with WindowExpressions in projectList

val q = ???

val plan = q.queryExecution.logical

val afterExtractWindowExpressions = ExtractWindowExpressions(plan)

Executing Rule — `apply` Method



apply(plan: LogicalPlan): LogicalPlan

1

2

3

4

5

apply(plan: LogicalPlan): LogicalPlan

Note	`apply` is part of the Rule Contract to execute (apply) a rule on a TreeNode (e.g. LogicalPlan).

apply transforms the logical operators downwards in the input logical plan as follows:

For Filter unary operators with Aggregate operator (as the child) that has a window function in the aggregateExpressions, apply…FIXME
For Aggregate logical operators that have a window function in the aggregateExpressions, apply…FIXME
For Project logical operators that have a window function in the projectList, apply…FIXME

`hasWindowFunction` Internal Method



hasWindowFunction(projectList: Seq[NamedExpression]): Boolean (1)
hasWindowFunction(expr: NamedExpression): Boolean

1

2

3

4

5

6

hasWindowFunction(projectList: Seq[NamedExpression]): Boolean (1)

hasWindowFunction(expr: NamedExpression): Boolean

Executes the other hasWindowFunction on every NamedExpression in the projectList

hasWindowFunction is positive (true) when the input expr named expression is a WindowExpression expression. Otherwise, hasWindowFunction is negative (false).

Note	`hasWindowFunction` is used when `ExtractWindowExpressions` logical resolution rule is requested to extract and execute.

`extract` Internal Method



extract(expressions: Seq[NamedExpression]): (Seq[NamedExpression], Seq[NamedExpression])

1

2

3

4

5

extract(expressions: Seq[NamedExpression]): (Seq[NamedExpression], Seq[NamedExpression])

extract…FIXME

Note	`extract` is used exclusively when `ExtractWindowExpressions` logical resolution rule is executed.

Adding Project and Window Logical Operators to Logical Plan — `addWindow` Internal Method



addWindow(
  expressionsWithWindowFunctions: Seq[NamedExpression],
  child: LogicalPlan): LogicalPlan

1

2

3

4

5

6

7

addWindow(

expressionsWithWindowFunctions: Seq[NamedExpression],

child: LogicalPlan): LogicalPlan

addWindow adds a Project logical operator with one or more Window logical operators (for every WindowExpression in the input named expressions) to the input logical plan.

Internally, addWindow…FIXME

Note	`addWindow` is used exclusively when `ExtractWindowExpressions` logical resolution rule is executed.

spark-sql 第17页

ResolveAliases Logical Resolution Rule

Applying ResolveAliases to Logical Plan — apply Method

assignAliases Internal Method

RelationConversions Logical PostHoc Evaluation Rule — Converting Hive Tables

Executing Rule — apply Method

Creating RelationConversions Instance

Does Table Use Parquet or ORC SerDe? — isConvertible Internal Method

Converting HiveTableRelation to LogicalRelation — convert Internal Method

PreWriteCheck Extended Analysis Check

Executing Function — apply Method

PreprocessTableCreation PostHoc Logical Resolution Rule

Executing Rule — apply Method

LookupFunctions Logical Rule — Checking Whether UnresolvedFunctions Are Resolvable

Applying LookupFunctions to Logical Plan — apply Method

InConversion Type Coercion Logical Rule

Coercing Types in Logical Plan — coerceTypes Method

HiveAnalysis PostHoc Logical Resolution Rule

Applying HiveAnalysis Rule to Logical Plan (Executing HiveAnalysis) — apply Method

HandleNullInputsForUDF Logical Evaluation Rule

FindDataSourceTable Logical Evaluation Rule for Resolving UnresolvedCatalogRelations

Applying FindDataSourceTable Rule to Logical Plan (and Resolving UnresolvedCatalogRelations in Logical Plan) — apply Method

readHiveTable Internal Method

readDataSourceTable Internal Method

ExtractWindowExpressions Logical Resolution Rule

Executing Rule — apply Method

hasWindowFunction Internal Method

extract Internal Method

Adding Project and Window Logical Operators to Logical Plan — addWindow Internal Method

欢迎关注：spark技术分享

关注公众号：spark技术分享

QQ咨询

回顶部

Applying ResolveAliases to Logical Plan — `apply` Method

`assignAliases` Internal Method

Executing Rule — `apply` Method

Does Table Use Parquet or ORC SerDe? — `isConvertible` Internal Method

Converting HiveTableRelation to LogicalRelation — `convert` Internal Method

Executing Function — `apply` Method

Executing Rule — `apply` Method

Applying LookupFunctions to Logical Plan — `apply` Method

Coercing Types in Logical Plan — `coerceTypes` Method

Applying HiveAnalysis Rule to Logical Plan (Executing HiveAnalysis) — `apply` Method

Applying FindDataSourceTable Rule to Logical Plan (and Resolving UnresolvedCatalogRelations in Logical Plan) — `apply` Method

`readHiveTable` Internal Method

`readDataSourceTable` Internal Method

Executing Rule — `apply` Method

`hasWindowFunction` Internal Method

`extract` Internal Method

Adding Project and Window Logical Operators to Logical Plan — `addWindow` Internal Method