Packages

class Analyzer extends RuleExecutor[LogicalPlan] with CheckAnalysis with SQLConfHelper

Provides a logical query plan analyzer, which translates UnresolvedAttributes and UnresolvedRelations into fully typed objects using information in a SessionCatalog.

Linear Supertypes
SQLConfHelper, CheckAnalysis, LookupCatalog, PredicateHelper, AliasHelper, RuleExecutor[LogicalPlan], Logging, AnyRef, Any
Known Subclasses
SimpleAnalyzer
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Analyzer
  2. SQLConfHelper
  3. CheckAnalysis
  4. LookupCatalog
  5. PredicateHelper
  6. AliasHelper
  7. RuleExecutor
  8. Logging
  9. AnyRef
  10. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Analyzer(catalog: SessionCatalog)
  2. new Analyzer(catalogManager: CatalogManager)

Type Members

  1. case class ResolveNamespace(catalogManager: CatalogManager) extends Rule[LogicalPlan] with LookupCatalog with Product with Serializable
  2. case class Batch(name: String, strategy: Strategy, rules: Rule[TreeType]*) extends Product with Serializable

    A batch of rules.

    A batch of rules.

    Attributes
    protected
    Definition Classes
    RuleExecutor
  3. case class FixedPoint(maxIterations: Int, errorOnExceed: Boolean = false, maxIterationsSetting: String = null) extends Strategy with Product with Serializable

    A strategy that runs until fix point or maxIterations times, whichever comes first.

    A strategy that runs until fix point or maxIterations times, whichever comes first. Especially, a FixedPoint(1) batch is supposed to run only once.

    Definition Classes
    RuleExecutor
  4. abstract class Strategy extends AnyRef

    An execution strategy for rules that indicates the maximum number of executions.

    An execution strategy for rules that indicates the maximum number of executions. If the execution reaches fix point (i.e. converge) before maxIterations, it will stop.

    Definition Classes
    RuleExecutor

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def batches: Seq[Batch]

    Defines a sequence of rule batches, to be overridden by the implementation.

    Defines a sequence of rule batches, to be overridden by the implementation.

    Definition Classes
    Analyzer → RuleExecutor
  6. def buildBalancedPredicate(expressions: Seq[Expression], op: (Expression, Expression) ⇒ Expression): Expression

    Builds a balanced output predicate in bottom up approach, by applying binary operator op pair by pair on input predicates exprs recursively.

    Builds a balanced output predicate in bottom up approach, by applying binary operator op pair by pair on input predicates exprs recursively. Example: exprs = [a, b, c, d], op = And, returns (a And b) And (c And d) exprs = [a, b, c, d, e, f], op = And, returns ((a And b) And (c And d)) And (e And f)

    Attributes
    protected
    Definition Classes
    PredicateHelper
  7. def canEvaluate(expr: Expression, plan: LogicalPlan): Boolean

    Returns true if expr can be evaluated using only the output of plan.

    Returns true if expr can be evaluated using only the output of plan. This method can be used to determine when it is acceptable to move expression evaluation within a query plan.

    For example consider a join between two relations R(a, b) and S(c, d).

    - canEvaluate(EqualTo(a,b), R) returns true - canEvaluate(EqualTo(a,c), R) returns false - canEvaluate(Literal(1), R) returns true as literals CAN be evaluated on any plan

    Attributes
    protected
    Definition Classes
    PredicateHelper
  8. def canEvaluateWithinJoin(expr: Expression): Boolean

    Returns true iff expr could be evaluated as a condition within join.

    Returns true iff expr could be evaluated as a condition within join.

    Attributes
    protected
    Definition Classes
    PredicateHelper
  9. val catalogManager: CatalogManager
    Definition Classes
    Analyzer → LookupCatalog
  10. def checkAnalysis(plan: LogicalPlan): Unit
    Definition Classes
    CheckAnalysis
  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  12. def conf: SQLConf

    The active config object within the current scope.

    The active config object within the current scope. See SQLConf.get for more information.

    Definition Classes
    SQLConfHelper
  13. def containsMultipleGenerators(exprs: Seq[Expression]): Boolean
    Attributes
    protected
    Definition Classes
    CheckAnalysis
  14. def currentCatalog: CatalogPlugin

    Returns the current catalog set.

    Returns the current catalog set.

    Definition Classes
    LookupCatalog
  15. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  17. val excludedOnceBatches: Set[String]

    Once batches that are excluded in the idempotence checker

    Once batches that are excluded in the idempotence checker

    Attributes
    protected
    Definition Classes
    RuleExecutor
  18. def execute(plan: LogicalPlan): LogicalPlan

    Executes the batches of rules defined by the subclass.

    Executes the batches of rules defined by the subclass. The batches are executed serially using the defined execution strategy. Within each batch, rules are also executed serially.

    Definition Classes
    Analyzer → RuleExecutor
  19. def executeAndCheck(plan: LogicalPlan, tracker: QueryPlanningTracker): LogicalPlan
  20. def executeAndTrack(plan: LogicalPlan, tracker: QueryPlanningTracker): LogicalPlan

    Executes the batches of rules defined by the subclass, and also tracks timing info for each rule using the provided tracker.

    Executes the batches of rules defined by the subclass, and also tracks timing info for each rule using the provided tracker.

    Definition Classes
    RuleExecutor
    See also

    execute

  21. val extendedCheckRules: Seq[(LogicalPlan) ⇒ Unit]

    Override to provide additional checks for correct analysis.

    Override to provide additional checks for correct analysis. These rules will be evaluated after our built-in check rules.

    Definition Classes
    CheckAnalysis
  22. val extendedResolutionRules: Seq[Rule[LogicalPlan]]

    Override to provide additional rules for the "Resolution" batch.

  23. def extractPredicatesWithinOutputSet(condition: Expression, outputSet: AttributeSet): Option[Expression]

    Returns a filter that its reference is a subset of outputSet and it contains the maximum constraints from condition.

    Returns a filter that its reference is a subset of outputSet and it contains the maximum constraints from condition. This is used for predicate pushdown. When there is no such filter, None is returned.

    Attributes
    protected
    Definition Classes
    PredicateHelper
  24. def failAnalysis(msg: String): Nothing
    Attributes
    protected
    Definition Classes
    CheckAnalysis
  25. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  26. def findExpressionAndTrackLineageDown(exp: Expression, plan: LogicalPlan): Option[(Expression, LogicalPlan)]

    Find the origin of where the input references of expression exp were scanned in the tree of plan, and if they originate from a single leaf node.

    Find the origin of where the input references of expression exp were scanned in the tree of plan, and if they originate from a single leaf node. Returns optional tuple with Expression, undoing any projections and aliasing that has been done along the way from plan to origin, and the origin LeafNode plan from which all the exp

    Definition Classes
    PredicateHelper
  27. def fixedPoint: FixedPoint

    If the plan cannot be resolved within maxIterations, analyzer will throw exception to inform user to increase the value of SQLConf.ANALYZER_MAX_ITERATIONS.

    If the plan cannot be resolved within maxIterations, analyzer will throw exception to inform user to increase the value of SQLConf.ANALYZER_MAX_ITERATIONS.

    Attributes
    protected
  28. def getAliasMap(exprs: Seq[NamedExpression]): AttributeMap[Alias]
    Attributes
    protected
    Definition Classes
    AliasHelper
  29. def getAliasMap(plan: Aggregate): AttributeMap[Alias]
    Attributes
    protected
    Definition Classes
    AliasHelper
  30. def getAliasMap(plan: Project): AttributeMap[Alias]
    Attributes
    protected
    Definition Classes
    AliasHelper
  31. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  32. def hasMapType(dt: DataType): Boolean
    Attributes
    protected
    Definition Classes
    CheckAnalysis
  33. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  34. def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
    Attributes
    protected
    Definition Classes
    Logging
  35. def initializeLogIfNecessary(isInterpreter: Boolean): Unit
    Attributes
    protected
    Definition Classes
    Logging
  36. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  37. def isNullIntolerant(expr: Expression): Boolean
    Attributes
    protected
    Definition Classes
    PredicateHelper
  38. def isPlanIntegral(previousPlan: LogicalPlan, currentPlan: LogicalPlan): Boolean

    Defines a check function that checks for structural integrity of the plan after the execution of each rule.

    Defines a check function that checks for structural integrity of the plan after the execution of each rule. For example, we can check whether a plan is still resolved after each rule in Optimizer, so we can catch rules that return invalid plans. The check function returns false if the given plan doesn't pass the structural integrity check.

    Attributes
    protected
    Definition Classes
    Analyzer → RuleExecutor
  39. def isTraceEnabled(): Boolean
    Attributes
    protected
    Definition Classes
    Logging
  40. def isView(nameParts: Seq[String]): Boolean
    Definition Classes
    Analyzer → CheckAnalysis
  41. def log: Logger
    Attributes
    protected
    Definition Classes
    Logging
  42. def logDebug(msg: ⇒ String, throwable: Throwable): Unit
    Attributes
    protected
    Definition Classes
    Logging
  43. def logDebug(msg: ⇒ String): Unit
    Attributes
    protected
    Definition Classes
    Logging
  44. def logError(msg: ⇒ String, throwable: Throwable): Unit
    Attributes
    protected
    Definition Classes
    Logging
  45. def logError(msg: ⇒ String): Unit
    Attributes
    protected
    Definition Classes
    Logging
  46. def logInfo(msg: ⇒ String, throwable: Throwable): Unit
    Attributes
    protected
    Definition Classes
    Logging
  47. def logInfo(msg: ⇒ String): Unit
    Attributes
    protected
    Definition Classes
    Logging
  48. def logName: String
    Attributes
    protected
    Definition Classes
    Logging
  49. def logTrace(msg: ⇒ String, throwable: Throwable): Unit
    Attributes
    protected
    Definition Classes
    Logging
  50. def logTrace(msg: ⇒ String): Unit
    Attributes
    protected
    Definition Classes
    Logging
  51. def logWarning(msg: ⇒ String, throwable: Throwable): Unit
    Attributes
    protected
    Definition Classes
    Logging
  52. def logWarning(msg: ⇒ String): Unit
    Attributes
    protected
    Definition Classes
    Logging
  53. def mapColumnInSetOperation(plan: LogicalPlan): Option[Attribute]
    Attributes
    protected
    Definition Classes
    CheckAnalysis
  54. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  55. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  56. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  57. def outputWithNullability(output: Seq[Attribute], nonNullAttrExprIds: Seq[ExprId]): Seq[Attribute]
    Attributes
    protected
    Definition Classes
    PredicateHelper
  58. def parseSessionCatalogFunctionIdentifier(nameParts: Seq[String]): FunctionIdentifier
    Definition Classes
    LookupCatalog
  59. val postHocResolutionRules: Seq[Rule[LogicalPlan]]

    Override to provide rules to do post-hoc resolution.

    Override to provide rules to do post-hoc resolution. Note that these rules will be executed in an individual batch. This batch is to run right after the normal resolution batch and execute its rules in one pass.

  60. def replaceAlias(expr: Expression, aliasMap: AttributeMap[Alias]): Expression

    Replace all attributes, that reference an alias, with the aliased expression

    Replace all attributes, that reference an alias, with the aliased expression

    Attributes
    protected
    Definition Classes
    AliasHelper
  61. def replaceAliasButKeepName(expr: NamedExpression, aliasMap: AttributeMap[Alias]): NamedExpression

    Replace all attributes, that reference an alias, with the aliased expression, but keep the name of the outermost attribute.

    Replace all attributes, that reference an alias, with the aliased expression, but keep the name of the outermost attribute.

    Attributes
    protected
    Definition Classes
    AliasHelper
  62. def resolveExpressionByPlanChildren(e: Expression, q: LogicalPlan): Expression

    Resolves UnresolvedAttribute, GetColumnByOrdinal and extract value expressions(s) by the input plan's children output attributes.

    Resolves UnresolvedAttribute, GetColumnByOrdinal and extract value expressions(s) by the input plan's children output attributes.

    e

    The expression need to be resolved.

    q

    The LogicalPlan whose children are used to resolve expression's attribute.

    returns

    resolved Expression.

  63. def resolveExpressionByPlanOutput(expr: Expression, plan: LogicalPlan, throws: Boolean = false): Expression

    Resolves UnresolvedAttribute, GetColumnByOrdinal and extract value expressions(s) by the input plan's output attributes.

    Resolves UnresolvedAttribute, GetColumnByOrdinal and extract value expressions(s) by the input plan's output attributes. In order to resolve the nested fields correctly, this function makes use of throws parameter to control when to raise an AnalysisException.

    Example : SELECT * FROM t ORDER BY a.b

    In the above example, after a is resolved to a struct-type column, we may fail to resolve b if there is no such nested field named "b". We should not fail and wait for other rules to resolve it if possible.

  64. def resolver: Resolver
  65. def splitConjunctivePredicates(condition: Expression): Seq[Expression]
    Attributes
    protected
    Definition Classes
    PredicateHelper
  66. def splitDisjunctivePredicates(condition: Expression): Seq[Expression]
    Attributes
    protected
    Definition Classes
    PredicateHelper
  67. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  68. def toString(): String
    Definition Classes
    AnyRef → Any
  69. def trimAliases(e: Expression): Expression
    Attributes
    protected
    Definition Classes
    AliasHelper
  70. def trimNonTopLevelAliases[T <: Expression](e: T): T
    Attributes
    protected
    Definition Classes
    AliasHelper
  71. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  72. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  73. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  74. object AddMetadataColumns extends Rule[LogicalPlan]

    Adds metadata columns to output for child relations when nodes are missing resolved attributes.

    Adds metadata columns to output for child relations when nodes are missing resolved attributes.

    References to metadata columns are resolved using columns from LogicalPlan.metadataOutput, but the relation's output does not include the metadata columns until the relation is replaced. Unless this rule adds metadata to the relation's output, the analyzer will detect that nothing produces the columns.

    This rule only adds metadata columns when a node is resolved but is missing input from its children. This ensures that metadata columns are not added to the plan unless they are used. By checking only resolved nodes, this ensures that * expansion is already done so that metadata columns are not accidentally selected by *. This rule resolves operators downwards to avoid projecting away metadata columns prematurely.

  75. object AsFunctionIdentifier
    Definition Classes
    LookupCatalog
  76. object AsTableIdentifier

    Extract legacy table identifier from a multi-part identifier.

    Extract legacy table identifier from a multi-part identifier.

    For legacy support only. Please use CatalogAndIdentifier instead on DSv2 code paths.

    Definition Classes
    LookupCatalog
  77. object CatalogAndIdentifier

    Extract catalog and identifier from a multi-part name with the current catalog if needed.

    Extract catalog and identifier from a multi-part name with the current catalog if needed. Catalog name takes precedence over identifier, but for a single-part name, identifier takes precedence over catalog name.

    Note that, this pattern is used to look up permanent catalog objects like table, view, function, etc. If you need to look up temp objects like temp view, please do it separately before calling this pattern, as temp objects don't belong to any catalog.

    Definition Classes
    LookupCatalog
  78. object CatalogAndNamespace

    Extract catalog and namespace from a multi-part name with the current catalog if needed.

    Extract catalog and namespace from a multi-part name with the current catalog if needed. Catalog name takes precedence over namespaces.

    Definition Classes
    LookupCatalog
  79. object ExtractGenerator extends Rule[LogicalPlan]

    Extracts Generator from the projectList of a Project operator and creates Generate operator under Project.

    Extracts Generator from the projectList of a Project operator and creates Generate operator under Project.

    This rule will throw AnalysisException for following cases: 1. Generator is nested in expressions, e.g. SELECT explode(list) + 1 FROM tbl 2. more than one Generator is found in projectList, e.g. SELECT explode(list), explode(list) FROM tbl 3. Generator is found in other operators that are not Project or Generate, e.g. SELECT * FROM tbl SORT BY explode(list)

  80. object ExtractWindowExpressions extends Rule[LogicalPlan]

    Extracts WindowExpressions from the projectList of a Project operator and aggregateExpressions of an Aggregate operator and creates individual Window operators for every distinct WindowSpecDefinition.

    Extracts WindowExpressions from the projectList of a Project operator and aggregateExpressions of an Aggregate operator and creates individual Window operators for every distinct WindowSpecDefinition.

    This rule handles three cases:

    • A Project having WindowExpressions in its projectList;
    • An Aggregate having WindowExpressions in its aggregateExpressions.
    • A Filter->Aggregate pattern representing GROUP BY with a HAVING clause and the Aggregate has WindowExpressions in its aggregateExpressions. Note: If there is a GROUP BY clause in the query, aggregations and corresponding filters (expressions in the HAVING clause) should be evaluated before any WindowExpression. If a query has SELECT DISTINCT, the DISTINCT part should be evaluated after all WindowExpressions.

    For every case, the transformation works as follows: 1. For a list of Expressions (a projectList or an aggregateExpressions), partitions it two lists of Expressions, one for all WindowExpressions and another for all regular expressions. 2. For all WindowExpressions, groups them based on their WindowSpecDefinitions and WindowFunctionTypes. 3. For every distinct WindowSpecDefinition and WindowFunctionType, creates a Window operator and inserts it into the plan tree.

  81. object GlobalAggregates extends Rule[LogicalPlan]

    Turns projections that contain aggregate expressions into aggregations.

  82. object HandleAnalysisOnlyCommand extends Rule[LogicalPlan]

    A rule that marks a command as analyzed so that its children are removed to avoid being optimized.

    A rule that marks a command as analyzed so that its children are removed to avoid being optimized. This rule should run after all other analysis rules are run.

  83. object HandleNullInputsForUDF extends Rule[LogicalPlan]

    Correctly handle null primitive inputs for UDF by adding extra If expression to do the null check.

    Correctly handle null primitive inputs for UDF by adding extra If expression to do the null check. When user defines a UDF with primitive parameters, there is no way to tell if the primitive parameter is null or not, so here we assume the primitive input is null-propagatable and we should return null if the input is null.

  84. object LookupFunctions extends Rule[LogicalPlan]

    Checks whether a function identifier referenced by an UnresolvedFunction is defined in the function registry.

    Checks whether a function identifier referenced by an UnresolvedFunction is defined in the function registry. Note that this rule doesn't try to resolve the UnresolvedFunction. It only performs simple existence check according to the function identifier to quickly identify undefined functions without triggering relation resolution, which may incur potentially expensive partition/schema discovery process in some cases. In order to avoid duplicate external functions lookup, the external function identifier will store in the local hash set externalFunctionNameSet.

    See also

    ResolveFunctions

    https://issues.apache.org/jira/browse/SPARK-19737

  85. object NonSessionCatalogAndIdentifier

    Extract non-session catalog and identifier from a multi-part identifier.

    Extract non-session catalog and identifier from a multi-part identifier.

    Definition Classes
    LookupCatalog
  86. object ResolveAggAliasInGroupBy extends Rule[LogicalPlan]

    Replace unresolved expressions in grouping keys with resolved ones in SELECT clauses.

    Replace unresolved expressions in grouping keys with resolved ones in SELECT clauses. This rule is expected to run after ResolveReferences applied.

  87. object ResolveAggregateFunctions extends Rule[LogicalPlan] with AliasHelper

    This rule finds aggregate expressions that are not in an aggregate operator.

    This rule finds aggregate expressions that are not in an aggregate operator. For example, those in a HAVING clause or ORDER BY clause. These expressions are pushed down to the underlying aggregate operator and then projected away after the original operator.

  88. object ResolveAliases extends Rule[LogicalPlan]

    Replaces UnresolvedAliass with concrete aliases.

  89. object ResolveAlterTableCommands extends Rule[LogicalPlan]

    Rule to mostly resolve, normalize and rewrite column names based on case sensitivity for alter table column commands.

  90. object ResolveBinaryArithmetic extends Rule[LogicalPlan]

    For Add: 1.

    For Add: 1. if both side are interval, stays the same; 2. else if one side is date and the other is interval, turns it to DateAddInterval; 3. else if one side is interval, turns it to TimeAdd; 4. else if one side is date, turns it to DateAdd ; 5. else stays the same.

    For Subtract: 1. if both side are interval, stays the same; 2. else if the left side is date and the right side is interval, turns it to -r); 3. else if the right side is an interval, turns it to -r); 4. else if one side is timestamp, turns it to SubtractTimestamps; 5. else if the right side is date, turns it to DateDiff/SubtractDates; 6. else if the left side is date, turns it to DateSub; 7. else turns it to stays the same.

    For Multiply: 1. If one side is interval, turns it to MultiplyInterval; 2. otherwise, stays the same.

    For Divide: 1. If the left side is interval, turns it to DivideInterval; 2. otherwise, stays the same.

  91. object ResolveDeserializer extends Rule[LogicalPlan]

    Replaces UnresolvedDeserializer with the deserialization expression that has been resolved to the given input attributes.

  92. object ResolveEncodersInUDF extends Rule[LogicalPlan]

    Resolve the encoders for the UDF by explicitly given the attributes.

    Resolve the encoders for the UDF by explicitly given the attributes. We give the attributes explicitly in order to handle the case where the data type of the input value is not the same with the internal schema of the encoder, which could cause data loss. For example, the encoder should not cast the input value to Decimal(38, 18) if the actual data type is Decimal(30, 0).

    The resolved encoders then will be used to deserialize the internal row to Scala value.

  93. object ResolveFunctions extends Rule[LogicalPlan]

    Replaces UnresolvedFuncs with concrete LogicalPlans.

    Replaces UnresolvedFuncs with concrete LogicalPlans. Replaces UnresolvedFunctions with concrete Expressions.

  94. object ResolveGenerate extends Rule[LogicalPlan]

    Rewrites table generating expressions that either need one or more of the following in order to be resolved:

    Rewrites table generating expressions that either need one or more of the following in order to be resolved:

    • concrete attribute references for their output.
    • to be relocated from a SELECT clause (i.e. from a Project) into a Generate).

    Names for the output Attributes are extracted from Alias or MultiAlias expressions that wrap the Generator.

  95. object ResolveGroupingAnalytics extends Rule[LogicalPlan]
  96. object ResolveInsertInto extends Rule[LogicalPlan]
  97. object ResolveMissingReferences extends Rule[LogicalPlan]

    In many dialects of SQL it is valid to sort by attributes that are not present in the SELECT clause.

    In many dialects of SQL it is valid to sort by attributes that are not present in the SELECT clause. This rule detects such queries and adds the required attributes to the original projection, so that they will be available during sorting. Another projection is added to remove these attributes after sorting.

    The HAVING clause could also used a grouping columns that is not presented in the SELECT.

  98. object ResolveNaturalAndUsingJoin extends Rule[LogicalPlan]

    Removes natural or using joins by calculating output columns based on output from two sides, Then apply a Project on a normal Join to eliminate natural or using join.

  99. object ResolveNewInstance extends Rule[LogicalPlan]

    Resolves NewInstance by finding and adding the outer scope to it if the object being constructed is an inner class.

  100. object ResolveOrdinalInOrderByAndGroupBy extends Rule[LogicalPlan]

    In many dialects of SQL it is valid to use ordinal positions in order/sort by and group by clauses.

    In many dialects of SQL it is valid to use ordinal positions in order/sort by and group by clauses. This rule is to convert ordinal positions to the corresponding expressions in the select list. This support is introduced in Spark 2.0.

    - When the sort references or group by expressions are not integer but foldable expressions, just ignore them. - When spark.sql.orderByOrdinal/spark.sql.groupByOrdinal is set to false, ignore the position numbers too.

    Before the release of Spark 2.0, the literals in order/sort by and group by clauses have no effect on the results.

  101. object ResolveOutputRelation extends Rule[LogicalPlan]

    Resolves columns of an output table from the data in a logical plan.

    Resolves columns of an output table from the data in a logical plan. This rule will:

    - Reorder columns when the write is by name - Insert casts when data types do not match - Insert aliases when column names do not match - Detect plans that are not compatible with the output table and throw AnalysisException

  102. object ResolvePivot extends Rule[LogicalPlan] with AliasHelper
  103. object ResolveRandomSeed extends Rule[LogicalPlan]

    Set the seed for random number generation.

  104. object ResolveReferences extends Rule[LogicalPlan]

    Replaces UnresolvedAttributes with concrete AttributeReferences from a logical plan node's children.

  105. object ResolveRelations extends Rule[LogicalPlan]

    Replaces UnresolvedRelations with concrete relations from the catalog.

  106. object ResolveSubquery extends Rule[LogicalPlan] with PredicateHelper

    This rule resolves and rewrites subqueries inside expressions.

    This rule resolves and rewrites subqueries inside expressions.

    Note: CTEs are handled in CTESubstitution.

  107. object ResolveSubqueryColumnAliases extends Rule[LogicalPlan]

    Replaces unresolved column aliases for a subquery with projections.

  108. object ResolveTables extends Rule[LogicalPlan]

    Resolve table relations with concrete relations from v2 catalog.

    Resolve table relations with concrete relations from v2 catalog.

    ResolveRelations still resolves v1 tables.

  109. object ResolveTempViews extends Rule[LogicalPlan]

    Resolve relations to temp views.

    Resolve relations to temp views. This is not an actual rule, and is called by ResolveTables and ResolveRelations.

  110. object ResolveUpCast extends Rule[LogicalPlan]

    Replace the UpCast expression by Cast, and throw exceptions if the cast may truncate.

  111. object ResolveUserSpecifiedColumns extends Rule[LogicalPlan]
  112. object ResolveWindowFrame extends Rule[LogicalPlan]

    Check and add proper window frames for all window functions.

  113. object ResolveWindowOrder extends Rule[LogicalPlan]

    Check and add order to AggregateWindowFunctions.

  114. object SessionCatalogAndIdentifier

    Extract session catalog and identifier from a multi-part identifier.

    Extract session catalog and identifier from a multi-part identifier.

    Definition Classes
    LookupCatalog
  115. object WindowsSubstitution extends Rule[LogicalPlan]

    Substitute child plan with WindowSpecDefinitions.

  116. object Once extends Strategy with Product with Serializable

    A strategy that is run once and idempotent.

    A strategy that is run once and idempotent.

    Definition Classes
    RuleExecutor

Inherited from SQLConfHelper

Inherited from CheckAnalysis

Inherited from LookupCatalog

Inherited from PredicateHelper

Inherited from AliasHelper

Inherited from RuleExecutor[LogicalPlan]

Inherited from Logging

Inherited from AnyRef

Inherited from Any

Ungrouped