SqlValidatorImpl (Apache Calcite API)

java.lang.Object
- org.apache.calcite.sql.validate.SqlValidatorImpl

All Implemented Interfaces:

SqlValidator, SqlValidatorWithHints

Direct Known Subclasses:

ContextSqlValidator, SqlAdvisorValidator
```
public class SqlValidatorImpl
extends Object
implements SqlValidatorWithHints
```
Default implementation of SqlValidator.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`SqlValidatorImpl.DmlNamespace` Common base class for DML statement namespaces.
`protected static class`	`SqlValidatorImpl.FunctionParamInfo` Utility object used to maintain information about the parameters in a function call.
`protected static class`	`SqlValidatorImpl.IdInfo` Information about an identifier in a particular scope.
`static class`	`SqlValidatorImpl.Status` Validation status.

Nested classes/interfaces inherited from interface org.apache.calcite.sql.validate.SqlValidator
SqlValidator.Config

Field Summary

Fields
Modifier and Type	Field and Description
`IdentityHashMap<SqlCall,List<RelDataType>>`	`callToOperandTypesMap` Provides the data for `getValidatedOperandTypes(SqlCall)`.
`protected Deque<SqlValidatorImpl.FunctionParamInfo>`	`functionCallStack` Stack of objects that maintain information about function calls.
`protected Map<String,SqlValidatorImpl.IdInfo>`	`idPositions` Maps `SqlParserPos` strings to the `SqlIdentifier` identifier objects at these positions.
`protected IdentityHashMap<SqlNode,SqlValidatorNamespace>`	`namespaces` Maps a `node` to the `namespace` which describes what columns they contain.
`protected IdentityHashMap<SqlNode,SqlValidatorScope>`	`scopes` Maps `query node` objects to the `SqlValidatorScope` scope created from them.
`static org.slf4j.Logger`	`TRACER`
`protected RelDataTypeFactory`	`typeFactory`
`protected RelDataType`	`unknownType` The type of dynamic parameters until a type is imposed on them.
`static String`	`UPDATE_ANON_PREFIX` Alias prefix generated for source columns when rewriting UPDATE to MERGE.
`static String`	`UPDATE_SRC_ALIAS` Alias generated for the source table when rewriting UPDATE to MERGE.
`static String`	`UPDATE_TGT_ALIAS` Alias generated for the target table when rewriting UPDATE to MERGE if no alias was specified by the user.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`SqlValidatorImpl(SqlOperatorTable opTab, SqlValidatorCatalogReader catalogReader, RelDataTypeFactory typeFactory, SqlValidator.Config config)` Creates a validator.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`addToSelectList(List<SqlNode> list, Set<String> aliases, List<Map.Entry<String,RelDataType>> fieldList, SqlNode exp, SelectScope scope, boolean includeSystemVars)` Adds an expression to a select list, ensuring that its alias does not clash with any existing expressions on the list.
`protected void`	`checkTypeAssignment(@Nullable SqlValidatorScope sourceScope, SqlValidatorTable table, RelDataType sourceRowType, RelDataType targetRowType, SqlNode query)` Checks the type assignment of an INSERT or UPDATE query.
`SqlValidator.Config`	`config()` Returns the config of the validator.
`protected MatchRecognizeNamespace`	`createMatchRecognizeNameSpace(SqlMatchRecognize call, SqlNode enclosingNode)`
`protected PivotNamespace`	`createPivotNameSpace(SqlPivot call, SqlNode enclosingNode)`
`protected SelectNamespace`	`createSelectNamespace(SqlSelect select, SqlNode enclosingNode)` Creates a namespace for a `SELECT` node.
`protected SetopNamespace`	`createSetopNamespace(SqlCall call, SqlNode enclosingNode)` Creates a namespace for a set operation (`UNION`, `INTERSECT`, or `EXCEPT`).
`protected SqlSelect`	`createSourceSelectForDelete(SqlDelete call)` Creates the SELECT statement that putatively feeds rows into a DELETE statement to be deleted.
`protected SqlSelect`	`createSourceSelectForUpdate(SqlUpdate call)` Creates the SELECT statement that putatively feeds rows into an UPDATE statement to be updated.
`protected RelDataType`	`createTargetRowType(SqlValidatorTable table, @Nullable SqlNodeList targetColumnList, boolean append)` Derives a row-type for INSERT and UPDATE operations.
`protected UnpivotNamespace`	`createUnpivotNameSpace(SqlUnpivot call, SqlNode enclosingNode)`
`void`	`declareCursor(SqlSelect select, SqlValidatorScope parentScope)` Declares a SELECT expression as a cursor.
`@Nullable String`	`deriveAlias(SqlNode node, int ordinal)` Derives an alias for an expression.
`RelDataType`	`deriveConstructorType(SqlValidatorScope scope, SqlCall call, SqlFunction unresolvedConstructor, @Nullable SqlFunction resolvedConstructor, List<RelDataType> argTypes)` Derives the type of a constructor.
`RelDataType`	`deriveType(SqlValidatorScope scope, SqlNode expr)` Derives the type of a node in a given scope.
`SqlNode`	`expand(SqlNode expr, SqlValidatorScope scope)` Expands an expression.
`SqlNode`	`expandGroupByOrHavingExpr(SqlNode expr, SqlValidatorScope scope, SqlSelect select, boolean havingExpression)`
`SqlNode`	`expandOrderExpr(SqlSelect select, SqlNode orderExpr)` Expands an expression in the ORDER BY clause into an expression with the same semantics as expressions in the SELECT clause.
`SqlNode`	`expandSelectExpr(SqlNode expr, SelectScope scope, SqlSelect select)`
`SqlNodeList`	`expandStar(SqlNodeList selectList, SqlSelect select, boolean includeSystemVars)` Returns a list of expressions, with every occurrence of "" or "TABLE." expanded.
`protected @Nullable SqlNode`	`getAggregate(SqlSelect select)` Returns the parse tree node (GROUP BY, HAVING, or an aggregate function call) that causes `select` to be an aggregate query, or null if it is not an aggregate query.
`SqlValidatorCatalogReader`	`getCatalogReader()` Returns the catalog reader used by this validator.
`SqlConformance`	`getConformance()`
`SqlValidatorScope`	`getCursorScope(SqlSelect select)`
`SqlValidatorScope`	`getEmptyScope()`
`List<List<String>>`	`getFieldOrigins(SqlNode sqlQuery)` Returns a description of how each field in the row type maps to a catalog, schema, table and column in the schema.
`@Nullable SqlValidatorScope`	`getFromScope(SqlSelect select)` Returns a scope containing the objects visible from the FROM clause of a query.
`SqlValidatorScope`	`getGroupScope(SqlSelect select)` Returns a scope containing the objects visible from the GROUP BY clause of a query.
`SqlValidatorScope`	`getHavingScope(SqlSelect select)` Returns a scope containing the objects visible from the HAVING clause of a query.
`@Nullable SqlValidatorScope`	`getJoinScope(SqlNode node)` Returns a scope containing the objects visible from the ON and USING sections of a JOIN clause.
`protected RelDataType`	`getLogicalSourceRowType(RelDataType sourceRowType, SqlInsert insert)`
`protected RelDataType`	`getLogicalTargetRowType(RelDataType targetRowType, SqlInsert insert)`
`SqlValidatorScope`	`getMatchRecognizeScope(SqlMatchRecognize node)` Returns a scope match recognize clause.
`@Nullable SqlValidatorNamespace`	`getNamespace(SqlNode node)` Finds the namespace corresponding to a given node.
`SqlOperatorTable`	`getOperatorTable()` Returns the operator table used by this validator.
`SqlValidatorScope`	`getOrderScope(SqlSelect select)` Returns the scope that expressions in the SELECT and HAVING clause of this query should use.
`SqlNode`	`getOriginal(SqlNode expr)`
`SqlValidatorScope`	`getOverScope(SqlNode node)` Returns the scope of an OVER or VALUES node.
`RelDataType`	`getParameterRowType(SqlNode sqlQuery)` Returns a record type that contains the name and type of each parameter.
`@Nullable String`	`getParentCursor(String columnListParamName)` Retrieves the name of the parent cursor referenced by a column list parameter.
`@Nullable SelectScope`	`getRawSelectScope(SqlSelect select)` Returns the scope for resolving the SELECT, GROUP BY and HAVING clauses.
`SqlValidatorScope`	`getSelectScope(SqlSelect select)` Returns the appropriate scope for validating a particular clause of a SELECT statement.
`protected @Nullable SqlNode`	`getSelfJoinExprForUpdate(SqlNode table, String alias)` Allows a subclass to provide information about how to convert an UPDATE into a MERGE via self-join.
`TypeCoercion`	`getTypeCoercion()` Get the type coercion instance.
`RelDataTypeFactory`	`getTypeFactory()` Returns the type factory used by this validator.
`RelDataType`	`getUnknownType()` Returns an object representing the "unknown" type.
`RelDataType`	`getValidatedNodeType(SqlNode node)` Returns the type assigned to a node by validation.
`@Nullable RelDataType`	`getValidatedNodeTypeIfKnown(SqlNode node)` Returns the type assigned to a node by validation, or null if unknown.
`@Nullable List<RelDataType>`	`getValidatedOperandTypes(SqlCall call)` Returns the types of a call's operands.
`org.apache.calcite.sql.validate.SqlValidatorImpl.ValidationErrorFunction`	`getValidationErrorFunction()`
`SqlValidatorScope`	`getWhereScope(SqlSelect select)` Returns the scope that expressions in the WHERE and GROUP BY clause of this query should use.
`protected SqlWindow`	`getWindowByName(SqlIdentifier id, SqlValidatorScope scope)`
`@Nullable SqlValidatorScope`	`getWithScope(SqlNode withItem)`
`CalciteException`	`handleUnresolvedFunction(SqlCall call, SqlOperator unresolvedFunction, List<RelDataType> argTypes, @Nullable List<String> argNames)` Handles a call to a function which cannot be resolved.
`protected void`	`inferUnknownTypes(RelDataType inferredType, SqlValidatorScope scope, SqlNode node)`
`boolean`	`isAggregate(SqlNode selectNode)` Deprecated.
`boolean`	`isAggregate(SqlSelect select)` Returns whether a SELECT statement is an aggregation.
`protected boolean`	`isNestedAggregateWindow(SqlNode node)`
`protected boolean`	`isOverAggregateWindow(SqlNode node)`
`boolean`	`isSystemField(RelDataTypeField field)` Returns whether a field is a system field.
`List<SqlMoniker>`	`lookupHints(SqlNode topNode, SqlParserPos pos)` Looks up completion hints for a syntactically correct SQL statement that has been parsed into an expression tree.
`void`	`lookupNameCompletionHints(SqlValidatorScope scope, List<String> names, SqlParserPos pos, Collection<SqlMoniker> hintList)` Populates a list of all the valid alternatives for an identifier.
`@Nullable SqlMoniker`	`lookupQualifiedName(SqlNode topNode, SqlParserPos pos)` Looks up the fully qualified name for a `SqlIdentifier` at a given Parser Position in a parsed expression tree Note: call this only after `SqlValidator.validate(org.apache.calcite.sql.SqlNode)` has been called.
`@Nullable SqlCall`	`makeNullaryCall(SqlIdentifier id)` If an identifier is a legitimate call to a function that has no arguments and requires no parentheses (for example "CURRENT_USER"), returns a call to that function, otherwise returns null.
`CalciteContextException`	`newValidationError(SqlNode node, org.apache.calcite.runtime.Resources.ExInst<SqlValidatorException> e)` Adds "line x, column y" context to a validator exception.
`protected @PolyNull SqlNode`	`performUnconditionalRewrites(@PolyNull SqlNode node, boolean underFrom)` Performs expression rewrites which are always used unconditionally.
`void`	`popFunctionCall()` Removes the topmost entry from the function call stack.
`void`	`pushFunctionCall()` Pushes a new instance of a function call on to a function call stack.
`protected void`	`registerNamespace(@Nullable SqlValidatorScope usingScope, @Nullable String alias, SqlValidatorNamespace ns, boolean forceNullable)` Registers a new namespace, and adds it as a child of its parent scope.
`void`	`removeValidatedNodeType(SqlNode node)` Removes a node from the set of validated nodes.
`SqlWindow`	`resolveWindow(SqlNode windowOrRef, SqlValidatorScope scope)` Converts a window specification or window name into a fully-resolved window specification.
`void`	`setOriginal(SqlNode expr, SqlNode original)`
`void`	`setValidatedNodeType(SqlNode node, RelDataType type)` Saves the type of a `SqlNode`, now that it has been validated.
`protected boolean`	`shouldAllowIntermediateOrderBy()`
`protected boolean`	`shouldAllowOverRelation()`
`SqlValidator`	`transform(UnaryOperator<SqlValidator.Config> transform)` Returns this SqlValidator, with the same state, applying a transform to the config.
`@Nullable List<String>`	`usingNames(SqlJoin join)` Returns the set of field names in the join condition specified by USING or implicitly by NATURAL, de-duplicated and in order.
`SqlNode`	`validate(SqlNode topNode)` Validates an expression tree.
`void`	`validateAggregateParams(SqlCall aggCall, @Nullable SqlNode filter, @Nullable SqlNodeList distinctList, @Nullable SqlNodeList orderList, SqlValidatorScope scope)` Validates parameters for aggregate function.
`void`	`validateCall(SqlCall call, SqlValidatorScope scope)` Validates a call to an operator.
`void`	`validateColumnListParams(SqlFunction function, List<RelDataType> argTypes, List<SqlNode> operands)` Validates a COLUMN_LIST parameter.
`void`	`validateDataType(SqlDataTypeSpec dataType)` Validates a data type expression.
`void`	`validateDelete(SqlDelete call)` Validates a DELETE statement.
`void`	`validateDynamicParam(SqlDynamicParam dynamicParam)` Validates a dynamic parameter.
`protected void`	`validateFeature(Feature feature, SqlParserPos context)` Validates that a particular feature is enabled.
`protected void`	`validateFrom(SqlNode node, RelDataType targetRowType, SqlValidatorScope scope)` Validates the FROM clause of a query, or (recursively) a child node of the FROM clause: AS, OVER, JOIN, VALUES, or sub-query.
`protected void`	`validateGroupClause(SqlSelect select)` Validates the GROUP BY clause of a SELECT statement.
`protected void`	`validateHavingClause(SqlSelect select)`
`void`	`validateIdentifier(SqlIdentifier id, SqlValidatorScope scope)` Resolves an identifier to a fully-qualified name.
`void`	`validateInsert(SqlInsert insert)` Validates an INSERT statement.
`void`	`validateIntervalQualifier(SqlIntervalQualifier qualifier)` Validates a `SqlIntervalQualifier`.
`protected void`	`validateJoin(SqlJoin join, SqlValidatorScope scope)`
`void`	`validateLiteral(SqlLiteral literal)` Validates a literal.
`void`	`validateMatchRecognize(SqlCall call)` Validates a MATCH_RECOGNIZE clause.
`void`	`validateMerge(SqlMerge call)` Validates a MERGE statement.
`boolean`	`validateModality(SqlSelect select, SqlModality modality, boolean fail)` Validates that a query is capable of producing a return of given modality (relational or streaming).
`protected void`	`validateNamespace(SqlValidatorNamespace namespace, RelDataType targetRowType)` Validates a namespace.
`protected void`	`validateOrderList(SqlSelect select)` Validates the ORDER BY clause of a SELECT statement.
`protected void`	`validateOver(SqlCall call, SqlValidatorScope scope)`
`SqlNode`	`validateParameterizedExpression(SqlNode topNode, Map<String,RelDataType> nameToTypeMap)` Validates an expression tree.
`void`	`validatePivot(SqlPivot pivot)`
`void`	`validateQuery(SqlNode node, @Nullable SqlValidatorScope scope, RelDataType targetRowType)` Checks that a query is valid.
`protected void`	`validateSelect(SqlSelect select, RelDataType targetRowType)` Validates a SELECT statement.
`protected RelDataType`	`validateSelectList(SqlNodeList selectItems, SqlSelect select, RelDataType targetRowType)`
`void`	`validateSequenceValue(SqlValidatorScope scope, SqlIdentifier id)`
`protected void`	`validateTableFunction(SqlCall node, SqlValidatorScope scope, RelDataType targetRowType)`
`protected void`	`validateUnnest(SqlCall call, SqlValidatorScope scope, RelDataType targetRowType)`
`void`	`validateUnpivot(SqlUnpivot unpivot)`
`void`	`validateUpdate(SqlUpdate call)` Validates an UPDATE statement.
`protected void`	`validateValues(SqlCall node, RelDataType targetRowType, SqlValidatorScope scope)` Validates a VALUES clause.
`protected void`	`validateWhereClause(SqlSelect select)`
`protected void`	`validateWhereOrOn(SqlValidatorScope scope, SqlNode condition, String clause)`
`void`	`validateWindow(SqlNode windowOrId, SqlValidatorScope scope, @Nullable SqlCall call)` Validates the right-hand side of an OVER expression.
`protected void`	`validateWindowClause(SqlSelect select)`
`void`	`validateWith(SqlWith with, SqlValidatorScope scope)`
`void`	`validateWithItem(SqlWithItem withItem)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.calcite.sql.validate.SqlValidator
resolveWindow

- Field Detail
  - TRACER
```
public static final org.slf4j.Logger TRACER
```
  - UPDATE_SRC_ALIAS
```
public static final String UPDATE_SRC_ALIAS
```
    Alias generated for the source table when rewriting UPDATE to MERGE.
    
    See Also:
    
    Constant Field Values
  - UPDATE_TGT_ALIAS
```
public static final String UPDATE_TGT_ALIAS
```
    Alias generated for the target table when rewriting UPDATE to MERGE if no alias was specified by the user.
    
    See Also:
    
    Constant Field Values
  - UPDATE_ANON_PREFIX
```
public static final String UPDATE_ANON_PREFIX
```
    Alias prefix generated for source columns when rewriting UPDATE to MERGE.
    
    See Also:
    
    Constant Field Values
  - idPositions
```
protected final Map<String,SqlValidatorImpl.IdInfo> idPositions
```
    Maps SqlParserPos strings to the SqlIdentifier identifier objects at these positions.
  - scopes
```
protected final IdentityHashMap<SqlNode,SqlValidatorScope> scopes
```
    Maps query node objects to the SqlValidatorScope scope created from them.
  - namespaces
```
protected final IdentityHashMap<SqlNode,SqlValidatorNamespace> namespaces
```
    Maps a node to the namespace which describes what columns they contain.
  - functionCallStack
```
protected final Deque<SqlValidatorImpl.FunctionParamInfo> functionCallStack
```
    Stack of objects that maintain information about function calls. A stack is needed to handle nested function calls. The function call currently being validated is at the top of the stack.
  - typeFactory
```
protected final RelDataTypeFactory typeFactory
```
  - unknownType
```
protected final RelDataType unknownType
```
    The type of dynamic parameters until a type is imposed on them.
  - callToOperandTypesMap
```
public final IdentityHashMap<SqlCall,List<RelDataType>> callToOperandTypesMap
```
    Provides the data for getValidatedOperandTypes(SqlCall).
- Constructor Detail
  - SqlValidatorImpl
```
protected SqlValidatorImpl(SqlOperatorTable opTab,
                           SqlValidatorCatalogReader catalogReader,
                           RelDataTypeFactory typeFactory,
                           SqlValidator.Config config)
```
    Creates a validator.
    
    Parameters:
    
    opTab - Operator table
    
    catalogReader - Catalog reader
    
    typeFactory - Type factory
    
    config - Config
- Method Detail
  - getConformance
```
public SqlConformance getConformance()
```
  - getCatalogReader
```
@Pure
public SqlValidatorCatalogReader getCatalogReader()
```
    Description copied from interface: SqlValidator
    
    Returns the catalog reader used by this validator.
    
    Specified by:
    
    getCatalogReader in interface SqlValidator
    
    Returns:
    
    catalog reader
  - getOperatorTable
```
@Pure
public SqlOperatorTable getOperatorTable()
```
    Description copied from interface: SqlValidator
    
    Returns the operator table used by this validator.
    
    Specified by:
    
    getOperatorTable in interface SqlValidator
    
    Returns:
    
    operator table
  - getTypeFactory
```
@Pure
public RelDataTypeFactory getTypeFactory()
```
    Description copied from interface: SqlValidator
    
    Returns the type factory used by this validator.
    
    Specified by:
    
    getTypeFactory in interface SqlValidator
    
    Returns:
    
    type factory
  - getUnknownType
```
public RelDataType getUnknownType()
```
    Description copied from interface: SqlValidator
    
    Returns an object representing the "unknown" type.
    
    Specified by:
    
    getUnknownType in interface SqlValidator
    
    Returns:
    
    unknown type
  - expandStar
```
public SqlNodeList expandStar(SqlNodeList selectList,
                              SqlSelect select,
                              boolean includeSystemVars)
```
    Description copied from interface: SqlValidator
    
    Returns a list of expressions, with every occurrence of "*" or "TABLE.*" expanded.
    
    Specified by:
    
    expandStar in interface SqlValidator
    
    Parameters:
    
    selectList - Select clause to be expanded
    
    select - Query
    
    includeSystemVars - Whether to include system variables
    
    Returns:
    
    expanded select clause
  - declareCursor
```
public void declareCursor(SqlSelect select,
                          SqlValidatorScope parentScope)
```
    Description copied from interface: SqlValidator
    
    Declares a SELECT expression as a cursor.
    
    Specified by:
    
    declareCursor in interface SqlValidator
    
    Parameters:
    
    select - select expression associated with the cursor
    
    parentScope - scope of the parent query associated with the cursor
  - pushFunctionCall
```
public void pushFunctionCall()
```
    Description copied from interface: SqlValidator
    
    Pushes a new instance of a function call on to a function call stack.
    
    Specified by:
    
    pushFunctionCall in interface SqlValidator
  - popFunctionCall
```
public void popFunctionCall()
```
    Description copied from interface: SqlValidator
    
    Removes the topmost entry from the function call stack.
    
    Specified by:
    
    popFunctionCall in interface SqlValidator
  - getParentCursor
```
public @Nullable String getParentCursor(String columnListParamName)
```
    Description copied from interface: SqlValidator
    
    Retrieves the name of the parent cursor referenced by a column list parameter.
    
    Specified by:
    
    getParentCursor in interface SqlValidator
    
    Parameters:
    
    columnListParamName - name of the column list parameter
    
    Returns:
    
    name of the parent cursor
  - usingNames
```
public @Nullable List<String> usingNames(SqlJoin join)
```
    Returns the set of field names in the join condition specified by USING or implicitly by NATURAL, de-duplicated and in order.
  - validate
```
public SqlNode validate(SqlNode topNode)
```
    Description copied from interface: SqlValidator
    
    Validates an expression tree. You can call this method multiple times, but not reentrantly.
    
    Specified by:
    
    validate in interface SqlValidator
    
    Parameters:
    
    topNode - top of expression tree to be validated
    
    Returns:
    
    validated tree (possibly rewritten)
  - lookupHints
```
public List<SqlMoniker> lookupHints(SqlNode topNode,
                                    SqlParserPos pos)
```
    Description copied from interface: SqlValidatorWithHints
    
    Looks up completion hints for a syntactically correct SQL statement that has been parsed into an expression tree. (Note this should be called after SqlValidator.validate(org.apache.calcite.sql.SqlNode).
    
    Specified by:
    
    lookupHints in interface SqlValidatorWithHints
    
    Parameters:
    
    topNode - top of expression tree in which to lookup completion hints
    
    pos - indicates the position in the sql statement we want to get completion hints for. For example, "select a.ename, b.deptno from sales.emp a join sales.dept b "on a.deptno=b.deptno where empno=1"; setting pos to 'Line 1, Column 17' returns all the possible column names that can be selected from sales.dept table setting pos to 'Line 1, Column 31' returns all the possible table names in 'sales' schema
    
    Returns:
    
    an array of SqlMoniker (sql identifiers) that can fill in at the indicated position
  - lookupQualifiedName
```
public @Nullable SqlMoniker lookupQualifiedName(SqlNode topNode,
                                                SqlParserPos pos)
```
    Description copied from interface: SqlValidatorWithHints
    
    Looks up the fully qualified name for a SqlIdentifier at a given Parser Position in a parsed expression tree Note: call this only after SqlValidator.validate(org.apache.calcite.sql.SqlNode) has been called.
    
    Specified by:
    
    lookupQualifiedName in interface SqlValidatorWithHints
    
    Parameters:
    
    topNode - top of expression tree in which to lookup the qualified name for the SqlIdentifier
    
    pos - indicates the position of the SqlIdentifier in the SQL statement we want to get the qualified name for
    
    Returns:
    
    a string of the fully qualified name of the SqlIdentifier if the Parser position represents a valid SqlIdentifier. Else return null
  - lookupNameCompletionHints
```
public final void lookupNameCompletionHints(SqlValidatorScope scope,
                                            List<String> names,
                                            SqlParserPos pos,
                                            Collection<SqlMoniker> hintList)
```
    Populates a list of all the valid alternatives for an identifier.
    
    Parameters:
    
    scope - Validation scope
    
    names - Components of the identifier
    
    pos - position
    
    hintList - a list of valid options
  - validateParameterizedExpression
```
public SqlNode validateParameterizedExpression(SqlNode topNode,
                                               Map<String,RelDataType> nameToTypeMap)
```
    Description copied from interface: SqlValidator
    
    Validates an expression tree. You can call this method multiple times, but not reentrantly.
    
    Specified by:
    
    validateParameterizedExpression in interface SqlValidator
    
    Parameters:
    
    topNode - top of expression tree to be validated
    
    nameToTypeMap - map of simple name to RelDataType; used to resolve SqlIdentifier references
    
    Returns:
    
    validated tree (possibly rewritten)
  - validateQuery
```
public void validateQuery(SqlNode node,
                          @Nullable SqlValidatorScope scope,
                          RelDataType targetRowType)
```
    Description copied from interface: SqlValidator
    Checks that a query is valid.
    Valid queries include:
    - SELECT statement,
    - set operation (UNION, INTERSECT, EXCEPT)
    - identifier (e.g. representing use of a table in a FROM clause)
    - query aliased with the AS operator
    Specified by:
    
    validateQuery in interface SqlValidator
    
    Parameters:
    
    node - Query node
    
    scope - Scope in which the query occurs
    
    targetRowType - Desired row type, must not be null, may be the data type 'unknown'.
  - validateNamespace
```
protected void validateNamespace(SqlValidatorNamespace namespace,
                                 RelDataType targetRowType)
```
    Validates a namespace.
    
    Parameters:
    
    namespace - Namespace
    
    targetRowType - Desired row type, must not be null, may be the data type 'unknown'.
  - getEmptyScope
```
public SqlValidatorScope getEmptyScope()
```
  - getCursorScope
```
public SqlValidatorScope getCursorScope(SqlSelect select)
```
  - getWhereScope
```
public SqlValidatorScope getWhereScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns the scope that expressions in the WHERE and GROUP BY clause of this query should use. This scope consists of the tables in the FROM clause, and the enclosing scope.
    
    Specified by:
    
    getWhereScope in interface SqlValidator
    
    Parameters:
    
    select - Query
    
    Returns:
    
    naming scope of WHERE clause
  - getSelectScope
```
public SqlValidatorScope getSelectScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    Returns the appropriate scope for validating a particular clause of a SELECT statement.
    Consider
    SELECT * FROM foo WHERE EXISTS ( SELECT deptno AS x FROM emp JOIN dept ON emp.deptno = dept.deptno WHERE emp.deptno = 5 GROUP BY deptno ORDER BY x)
    What objects can be seen in each part of the sub-query?
    - In FROM (SqlValidator.getFromScope(org.apache.calcite.sql.SqlSelect) , you can only see 'foo'.
    - In WHERE (SqlValidator.getWhereScope(org.apache.calcite.sql.SqlSelect)), GROUP BY (SqlValidator.getGroupScope(org.apache.calcite.sql.SqlSelect)), SELECT (getSelectScope), and the ON clause of the JOIN (SqlValidator.getJoinScope(org.apache.calcite.sql.SqlNode)) you can see 'emp', 'dept', and 'foo'.
    - In ORDER BY (SqlValidator.getOrderScope(org.apache.calcite.sql.SqlSelect)), you can see the column alias 'x'; and tables 'emp', 'dept', and 'foo'.
    Specified by:
    
    getSelectScope in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    naming scope for SELECT statement
  - getRawSelectScope
```
public @Nullable SelectScope getRawSelectScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns the scope for resolving the SELECT, GROUP BY and HAVING clauses. Always a SelectScope; if this is an aggregation query, the AggregatingScope is stripped away.
    
    Specified by:
    
    getRawSelectScope in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    naming scope for SELECT statement, sans any aggregating scope
  - getHavingScope
```
public SqlValidatorScope getHavingScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns a scope containing the objects visible from the HAVING clause of a query.
    
    Specified by:
    
    getHavingScope in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    naming scope for HAVING clause
  - getGroupScope
```
public SqlValidatorScope getGroupScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns a scope containing the objects visible from the GROUP BY clause of a query.
    
    Specified by:
    
    getGroupScope in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    naming scope for GROUP BY clause
  - getFromScope
```
public @Nullable SqlValidatorScope getFromScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns a scope containing the objects visible from the FROM clause of a query.
    
    Specified by:
    
    getFromScope in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    naming scope for FROM clause
  - getOrderScope
```
public SqlValidatorScope getOrderScope(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns the scope that expressions in the SELECT and HAVING clause of this query should use. This scope consists of the FROM clause and the enclosing scope. If the query is aggregating, only columns in the GROUP BY clause may be used.
    
    Specified by:
    
    getOrderScope in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    naming scope for ORDER BY clause
  - getMatchRecognizeScope
```
public SqlValidatorScope getMatchRecognizeScope(SqlMatchRecognize node)
```
    Description copied from interface: SqlValidator
    
    Returns a scope match recognize clause.
    
    Specified by:
    
    getMatchRecognizeScope in interface SqlValidator
    
    Parameters:
    
    node - Match recognize
    
    Returns:
    
    naming scope for Match recognize clause
  - getJoinScope
```
public @Nullable SqlValidatorScope getJoinScope(SqlNode node)
```
    Description copied from interface: SqlValidator
    
    Returns a scope containing the objects visible from the ON and USING sections of a JOIN clause.
    
    Specified by:
    
    getJoinScope in interface SqlValidator
    
    Parameters:
    
    node - The item in the FROM clause which contains the ON or USING expression
    
    Returns:
    
    naming scope for JOIN clause
    
    See Also:
    
    SqlValidator.getFromScope(org.apache.calcite.sql.SqlSelect)
  - getOverScope
```
public SqlValidatorScope getOverScope(SqlNode node)
```
    Description copied from interface: SqlValidator
    
    Returns the scope of an OVER or VALUES node.
    
    Specified by:
    
    getOverScope in interface SqlValidator
    
    Parameters:
    
    node - Node
    
    Returns:
    
    Scope
  - getNamespace
```
public @Nullable SqlValidatorNamespace getNamespace(SqlNode node)
```
    Description copied from interface: SqlValidator
    
    Finds the namespace corresponding to a given node.
    For example, in the query SELECT * FROM (SELECT * FROM t), t1 AS alias, the both items in the FROM clause have a corresponding namespace.
    
    Specified by:
    
    getNamespace in interface SqlValidator
    
    Parameters:
    
    node - Parse tree node
    
    Returns:
    
    namespace of node
  - performUnconditionalRewrites
```
protected @PolyNull SqlNode performUnconditionalRewrites(@PolyNull SqlNode node,
                                                         boolean underFrom)
```
    Performs expression rewrites which are always used unconditionally. These rewrites massage the expression tree into a standard form so that the rest of the validation logic can be simpler.
    Returns null if and only if the original expression is null.
    
    Parameters:
    
    node - expression to be rewritten
    
    underFrom - whether node appears directly under a FROM clause
    
    Returns:
    
    rewritten expression, or null if the original expression is null
  - getSelfJoinExprForUpdate
```
protected @Nullable SqlNode getSelfJoinExprForUpdate(SqlNode table,
                                                     String alias)
```
    Allows a subclass to provide information about how to convert an UPDATE into a MERGE via self-join. If this method returns null, then no such conversion takes place. Otherwise, this method should return a suitable unique identifier expression for the given table.
    
    Parameters:
    
    table - identifier for table being updated
    
    alias - alias to use for qualifying columns in expression, or null for unqualified references; if this is equal to "SYS$SRC", then column references have been anonymized to "SYS$ANONx", where x is the 1-based column number.
    
    Returns:
    
    expression for unique identifier, or null to prevent conversion
  - createSourceSelectForUpdate
```
protected SqlSelect createSourceSelectForUpdate(SqlUpdate call)
```
    Creates the SELECT statement that putatively feeds rows into an UPDATE statement to be updated.
    
    Parameters:
    
    call - Call to the UPDATE operator
    
    Returns:
    
    select statement
  - createSourceSelectForDelete
```
protected SqlSelect createSourceSelectForDelete(SqlDelete call)
```
    Creates the SELECT statement that putatively feeds rows into a DELETE statement to be deleted.
    
    Parameters:
    
    call - Call to the DELETE operator
    
    Returns:
    
    select statement
  - getValidatedNodeType
```
public RelDataType getValidatedNodeType(SqlNode node)
```
    Description copied from interface: SqlValidator
    
    Returns the type assigned to a node by validation.
    
    Specified by:
    
    getValidatedNodeType in interface SqlValidator
    
    Parameters:
    
    node - the node of interest
    
    Returns:
    
    validated type, never null
  - getValidatedNodeTypeIfKnown
```
public @Nullable RelDataType getValidatedNodeTypeIfKnown(SqlNode node)
```
    Description copied from interface: SqlValidator
    
    Returns the type assigned to a node by validation, or null if unknown. This allows for queries against nodes such as aliases, which have no type of their own. If you want to assert that the node of interest must have a type, use SqlValidator.getValidatedNodeType(org.apache.calcite.sql.SqlNode) instead.
    
    Specified by:
    
    getValidatedNodeTypeIfKnown in interface SqlValidator
    
    Parameters:
    
    node - the node of interest
    
    Returns:
    
    validated type, or null if unknown or not applicable
  - getValidatedOperandTypes
```
public @Nullable List<RelDataType> getValidatedOperandTypes(SqlCall call)
```
    Description copied from interface: SqlValidator
    
    Returns the types of a call's operands.
    Returns null if the call has not been validated, or if the operands' types do not differ from their types as expressions.
    This method is most useful when some of the operands are of type ANY, or if they need to be coerced to be consistent with other operands, or with the needs of the function.
    
    Specified by:
    
    getValidatedOperandTypes in interface SqlValidator
    
    Parameters:
    
    call - Call
    
    Returns:
    
    List of operands' types, or null if not known or 'obvious'
  - setValidatedNodeType
```
public final void setValidatedNodeType(SqlNode node,
                                       RelDataType type)
```
    Saves the type of a SqlNode, now that it has been validated.
    Unlike the base class method, this method is not deprecated. It is available from within Calcite, but is not part of the public API.
    
    Specified by:
    
    setValidatedNodeType in interface SqlValidator
    
    Parameters:
    
    node - A SQL parse tree node, never null
    
    type - Its type; must not be null
  - removeValidatedNodeType
```
public void removeValidatedNodeType(SqlNode node)
```
    Description copied from interface: SqlValidator
    
    Removes a node from the set of validated nodes.
    
    Specified by:
    
    removeValidatedNodeType in interface SqlValidator
    
    Parameters:
    
    node - node to be removed
  - makeNullaryCall
```
public @Nullable SqlCall makeNullaryCall(SqlIdentifier id)
```
    Description copied from interface: SqlValidator
    
    If an identifier is a legitimate call to a function that has no arguments and requires no parentheses (for example "CURRENT_USER"), returns a call to that function, otherwise returns null.
    
    Specified by:
    
    makeNullaryCall in interface SqlValidator
  - deriveType
```
public RelDataType deriveType(SqlValidatorScope scope,
                              SqlNode expr)
```
    Description copied from interface: SqlValidator
    
    Derives the type of a node in a given scope. If the type has already been inferred, returns the previous type.
    
    Specified by:
    
    deriveType in interface SqlValidator
    
    Parameters:
    
    scope - Syntactic scope
    
    expr - Parse tree node
    
    Returns:
    
    Type of the SqlNode. Should never return NULL
  - deriveConstructorType
```
public RelDataType deriveConstructorType(SqlValidatorScope scope,
                                         SqlCall call,
                                         SqlFunction unresolvedConstructor,
                                         @Nullable SqlFunction resolvedConstructor,
                                         List<RelDataType> argTypes)
```
    Description copied from interface: SqlValidator
    
    Derives the type of a constructor.
    
    Specified by:
    
    deriveConstructorType in interface SqlValidator
    
    Parameters:
    
    scope - Scope
    
    call - Call
    
    unresolvedConstructor - TODO
    
    resolvedConstructor - TODO
    
    argTypes - Types of arguments
    
    Returns:
    
    Resolved type of constructor
  - handleUnresolvedFunction
```
public CalciteException handleUnresolvedFunction(SqlCall call,
                                                 SqlOperator unresolvedFunction,
                                                 List<RelDataType> argTypes,
                                                 @Nullable List<String> argNames)
```
    Description copied from interface: SqlValidator
    
    Handles a call to a function which cannot be resolved. Returns an appropriately descriptive error, which caller must throw.
    
    Specified by:
    
    handleUnresolvedFunction in interface SqlValidator
    
    Parameters:
    
    call - Call
    
    unresolvedFunction - Overloaded function which is the target of the call
    
    argTypes - Types of arguments
    
    argNames - Names of arguments, or null if call by position
  - inferUnknownTypes
```
protected void inferUnknownTypes(RelDataType inferredType,
                                 SqlValidatorScope scope,
                                 SqlNode node)
```
  - addToSelectList
```
protected void addToSelectList(List<SqlNode> list,
                               Set<String> aliases,
                               List<Map.Entry<String,RelDataType>> fieldList,
                               SqlNode exp,
                               SelectScope scope,
                               boolean includeSystemVars)
```
    Adds an expression to a select list, ensuring that its alias does not clash with any existing expressions on the list.
  - deriveAlias
```
public @Nullable String deriveAlias(SqlNode node,
                                    int ordinal)
```
    Description copied from interface: SqlValidator
    
    Derives an alias for an expression. If no alias can be derived, returns null if ordinal is less than zero, otherwise generates an alias EXPR$ordinal.
    
    Specified by:
    
    deriveAlias in interface SqlValidator
    
    Parameters:
    
    node - Expression
    
    ordinal - Ordinal of expression
    
    Returns:
    
    derived alias, or null if no alias can be derived and ordinal is less than zero
  - shouldAllowIntermediateOrderBy
```
protected boolean shouldAllowIntermediateOrderBy()
```
  - createMatchRecognizeNameSpace
```
protected MatchRecognizeNamespace createMatchRecognizeNameSpace(SqlMatchRecognize call,
                                                                SqlNode enclosingNode)
```
  - createPivotNameSpace
```
protected PivotNamespace createPivotNameSpace(SqlPivot call,
                                              SqlNode enclosingNode)
```
  - createUnpivotNameSpace
```
protected UnpivotNamespace createUnpivotNameSpace(SqlUnpivot call,
                                                  SqlNode enclosingNode)
```
  - registerNamespace
```
protected void registerNamespace(@Nullable SqlValidatorScope usingScope,
                                 @Nullable String alias,
                                 SqlValidatorNamespace ns,
                                 boolean forceNullable)
```
    Registers a new namespace, and adds it as a child of its parent scope. Derived class can override this method to tinker with namespaces as they are created.
    
    Parameters:
    
    usingScope - Parent scope (which will want to look for things in this namespace)
    
    alias - Alias by which parent will refer to this namespace
    
    ns - Namespace
    
    forceNullable - Whether to force the type of namespace to be nullable
  - shouldAllowOverRelation
```
protected boolean shouldAllowOverRelation()
```
  - createSelectNamespace
```
protected SelectNamespace createSelectNamespace(SqlSelect select,
                                                SqlNode enclosingNode)
```
    Creates a namespace for a SELECT node. Derived class may override this factory method.
    
    Parameters:
    
    select - Select node
    
    enclosingNode - Enclosing node
    
    Returns:
    
    Select namespace
  - createSetopNamespace
```
protected SetopNamespace createSetopNamespace(SqlCall call,
                                              SqlNode enclosingNode)
```
    Creates a namespace for a set operation (UNION, INTERSECT, or EXCEPT). Derived class may override this factory method.
    
    Parameters:
    
    call - Call to set operation
    
    enclosingNode - Enclosing node
    
    Returns:
    
    Set operation namespace
  - isAggregate
```
public boolean isAggregate(SqlSelect select)
```
    Description copied from interface: SqlValidator
    
    Returns whether a SELECT statement is an aggregation. Criteria are: (1) contains GROUP BY, or (2) contains HAVING, or (3) SELECT or ORDER BY clause contains aggregate functions. (Windowed aggregate functions, such as SUM(x) OVER w, don't count.)
    
    Specified by:
    
    isAggregate in interface SqlValidator
    
    Parameters:
    
    select - SELECT statement
    
    Returns:
    
    whether SELECT statement is an aggregation
  - isNestedAggregateWindow
```
protected boolean isNestedAggregateWindow(SqlNode node)
```
  - isOverAggregateWindow
```
protected boolean isOverAggregateWindow(SqlNode node)
```
  - getAggregate
```
protected @Nullable SqlNode getAggregate(SqlSelect select)
```
    Returns the parse tree node (GROUP BY, HAVING, or an aggregate function call) that causes select to be an aggregate query, or null if it is not an aggregate query.
    The node is useful context for error messages, but you cannot assume that the node is the only aggregate function.
  - isAggregate
```
@Deprecated
public boolean isAggregate(SqlNode selectNode)
```
    Deprecated.
    
    Description copied from interface: SqlValidator
    
    Returns whether a select list expression is an aggregate function.
    
    Specified by:
    
    isAggregate in interface SqlValidator
    
    Parameters:
    
    selectNode - Expression in SELECT clause
    
    Returns:
    
    whether expression is an aggregate function
  - validateIdentifier
```
public void validateIdentifier(SqlIdentifier id,
                               SqlValidatorScope scope)
```
    Description copied from interface: SqlValidator
    
    Resolves an identifier to a fully-qualified name.
    
    Specified by:
    
    validateIdentifier in interface SqlValidator
    
    Parameters:
    
    id - Identifier
    
    scope - Naming scope
  - validateLiteral
```
public void validateLiteral(SqlLiteral literal)
```
    Description copied from interface: SqlValidator
    
    Validates a literal.
    
    Specified by:
    
    validateLiteral in interface SqlValidator
    
    Parameters:
    
    literal - Literal
  - validateIntervalQualifier
```
public void validateIntervalQualifier(SqlIntervalQualifier qualifier)
```
    Description copied from interface: SqlValidator
    
    Validates a SqlIntervalQualifier.
    
    Specified by:
    
    validateIntervalQualifier in interface SqlValidator
    
    Parameters:
    
    qualifier - Interval qualifier
  - validateFrom
```
protected void validateFrom(SqlNode node,
                            RelDataType targetRowType,
                            SqlValidatorScope scope)
```
    Validates the FROM clause of a query, or (recursively) a child node of the FROM clause: AS, OVER, JOIN, VALUES, or sub-query.
    
    Parameters:
    
    node - Node in FROM clause, typically a table or derived table
    
    targetRowType - Desired row type of this expression, or unknownType if not fussy. Must not be null.
    
    scope - Scope
  - validateTableFunction
```
protected void validateTableFunction(SqlCall node,
                                     SqlValidatorScope scope,
                                     RelDataType targetRowType)
```
  - validateOver
```
protected void validateOver(SqlCall call,
                            SqlValidatorScope scope)
```
  - validateUnnest
```
protected void validateUnnest(SqlCall call,
                              SqlValidatorScope scope,
                              RelDataType targetRowType)
```
  - validateJoin
```
protected void validateJoin(SqlJoin join,
                            SqlValidatorScope scope)
```
  - validateSelect
```
protected void validateSelect(SqlSelect select,
                              RelDataType targetRowType)
```
    Validates a SELECT statement.
    
    Parameters:
    
    select - Select statement
    
    targetRowType - Desired row type, must not be null, may be the data type 'unknown'.
  - validateModality
```
public boolean validateModality(SqlSelect select,
                                SqlModality modality,
                                boolean fail)
```
    Description copied from interface: SqlValidator
    
    Validates that a query is capable of producing a return of given modality (relational or streaming).
    
    Specified by:
    
    validateModality in interface SqlValidator
    
    Parameters:
    
    select - Query
    
    modality - Modality (streaming or relational)
    
    fail - Whether to throw a user error if does not support required modality
    
    Returns:
    
    whether query supports the given modality
  - validateWindowClause
```
protected void validateWindowClause(SqlSelect select)
```
  - validateWith
```
public void validateWith(SqlWith with,
                         SqlValidatorScope scope)
```
    Specified by:
    
    validateWith in interface SqlValidator
  - validateWithItem
```
public void validateWithItem(SqlWithItem withItem)
```
    Specified by:
    
    validateWithItem in interface SqlValidator
  - validateSequenceValue
```
public void validateSequenceValue(SqlValidatorScope scope,
                                  SqlIdentifier id)
```
    Specified by:
    
    validateSequenceValue in interface SqlValidator
  - getWithScope
```
public @Nullable SqlValidatorScope getWithScope(SqlNode withItem)
```
    Specified by:
    
    getWithScope in interface SqlValidator
  - getTypeCoercion
```
public TypeCoercion getTypeCoercion()
```
    Description copied from interface: SqlValidator
    
    Get the type coercion instance.
    
    Specified by:
    
    getTypeCoercion in interface SqlValidator
  - config
```
public SqlValidator.Config config()
```
    Description copied from interface: SqlValidator
    
    Returns the config of the validator.
    
    Specified by:
    
    config in interface SqlValidator
  - transform
```
public SqlValidator transform(UnaryOperator<SqlValidator.Config> transform)
```
    Description copied from interface: SqlValidator
    
    Returns this SqlValidator, with the same state, applying a transform to the config.
    This is mainly used for tests, otherwise constructs a SqlValidator.Config directly through the constructor.
    
    Specified by:
    
    transform in interface SqlValidator
  - validateOrderList
```
protected void validateOrderList(SqlSelect select)
```
    Validates the ORDER BY clause of a SELECT statement.
    
    Parameters:
    
    select - Select statement
  - expandOrderExpr
```
public SqlNode expandOrderExpr(SqlSelect select,
                               SqlNode orderExpr)
```
    Description copied from interface: SqlValidator
    Expands an expression in the ORDER BY clause into an expression with the same semantics as expressions in the SELECT clause.
    This is made necessary by a couple of dialect 'features':
    - ordinal expressions: In "SELECT x, y FROM t ORDER BY 2", the expression "2" is shorthand for the 2nd item in the select clause, namely "y".
    - alias references: In "SELECT x AS a, y FROM t ORDER BY a", the expression "a" is shorthand for the item in the select clause whose alias is "a"
    Specified by:
    
    expandOrderExpr in interface SqlValidator
    
    Parameters:
    
    select - Select statement which contains ORDER BY
    
    orderExpr - Expression in the ORDER BY clause.
    
    Returns:
    
    Expression translated into SELECT clause semantics
  - validateGroupClause
```
protected void validateGroupClause(SqlSelect select)
```
    Validates the GROUP BY clause of a SELECT statement. This method is called even if no GROUP BY clause is present.
  - validateWhereClause
```
protected void validateWhereClause(SqlSelect select)
```
  - validateWhereOrOn
```
protected void validateWhereOrOn(SqlValidatorScope scope,
                                 SqlNode condition,
                                 String clause)
```
  - validateHavingClause
```
protected void validateHavingClause(SqlSelect select)
```
  - validateSelectList
```
protected RelDataType validateSelectList(SqlNodeList selectItems,
                                         SqlSelect select,
                                         RelDataType targetRowType)
```
  - createTargetRowType
```
protected RelDataType createTargetRowType(SqlValidatorTable table,
                                          @Nullable SqlNodeList targetColumnList,
                                          boolean append)
```
    Derives a row-type for INSERT and UPDATE operations.
    
    Parameters:
    
    table - Target table for INSERT/UPDATE
    
    targetColumnList - List of target columns, or null if not specified
    
    append - Whether to append fields to those in baseRowType
    
    Returns:
    
    Rowtype
  - validateInsert
```
public void validateInsert(SqlInsert insert)
```
    Description copied from interface: SqlValidator
    
    Validates an INSERT statement.
    
    Specified by:
    
    validateInsert in interface SqlValidator
    
    Parameters:
    
    insert - INSERT statement
  - getLogicalTargetRowType
```
protected RelDataType getLogicalTargetRowType(RelDataType targetRowType,
                                              SqlInsert insert)
```
  - getLogicalSourceRowType
```
protected RelDataType getLogicalSourceRowType(RelDataType sourceRowType,
                                              SqlInsert insert)
```
  - checkTypeAssignment
```
protected void checkTypeAssignment(@Nullable SqlValidatorScope sourceScope,
                                   SqlValidatorTable table,
                                   RelDataType sourceRowType,
                                   RelDataType targetRowType,
                                   SqlNode query)
```
    Checks the type assignment of an INSERT or UPDATE query.
    Skip the virtual columns(can not insert into) type assignment check if the source fields count equals with the real target table fields count, see how #checkFieldCount was used.
    
    Parameters:
    
    sourceScope - Scope of query source which is used to infer node type
    
    table - Target table
    
    sourceRowType - Source row type
    
    targetRowType - Target row type, it should either contain all the virtual columns (can not insert into) or exclude all the virtual columns
    
    query - The query
  - validateDelete
```
public void validateDelete(SqlDelete call)
```
    Description copied from interface: SqlValidator
    
    Validates a DELETE statement.
    
    Specified by:
    
    validateDelete in interface SqlValidator
    
    Parameters:
    
    call - DELETE statement
  - validateUpdate
```
public void validateUpdate(SqlUpdate call)
```
    Description copied from interface: SqlValidator
    
    Validates an UPDATE statement.
    
    Specified by:
    
    validateUpdate in interface SqlValidator
    
    Parameters:
    
    call - UPDATE statement
  - validateMerge
```
public void validateMerge(SqlMerge call)
```
    Description copied from interface: SqlValidator
    
    Validates a MERGE statement.
    
    Specified by:
    
    validateMerge in interface SqlValidator
    
    Parameters:
    
    call - MERGE statement
  - validateValues
```
protected void validateValues(SqlCall node,
                              RelDataType targetRowType,
                              SqlValidatorScope scope)
```
    Validates a VALUES clause.
    
    Parameters:
    
    node - Values clause
    
    targetRowType - Row type which expression must conform to
    
    scope - Scope within which clause occurs
  - validateDataType
```
public void validateDataType(SqlDataTypeSpec dataType)
```
    Description copied from interface: SqlValidator
    
    Validates a data type expression.
    
    Specified by:
    
    validateDataType in interface SqlValidator
    
    Parameters:
    
    dataType - Data type
  - validateDynamicParam
```
public void validateDynamicParam(SqlDynamicParam dynamicParam)
```
    Description copied from interface: SqlValidator
    
    Validates a dynamic parameter.
    
    Specified by:
    
    validateDynamicParam in interface SqlValidator
    
    Parameters:
    
    dynamicParam - Dynamic parameter
  - getValidationErrorFunction
```
public org.apache.calcite.sql.validate.SqlValidatorImpl.ValidationErrorFunction getValidationErrorFunction()
```
  - newValidationError
```
public CalciteContextException newValidationError(SqlNode node,
                                                  org.apache.calcite.runtime.Resources.ExInst<SqlValidatorException> e)
```
    Description copied from interface: SqlValidator
    
    Adds "line x, column y" context to a validator exception.
    Note that the input exception is checked (it derives from Exception) and the output exception is unchecked (it derives from RuntimeException). This is intentional -- it should remind code authors to provide context for their validation errors.
    
    Specified by:
    
    newValidationError in interface SqlValidator
    
    Parameters:
    
    node - The place where the exception occurred, not null
    
    e - The validation error
    
    Returns:
    
    Exception containing positional information, never null
  - getWindowByName
```
protected SqlWindow getWindowByName(SqlIdentifier id,
                                    SqlValidatorScope scope)
```
  - resolveWindow
```
public SqlWindow resolveWindow(SqlNode windowOrRef,
                               SqlValidatorScope scope)
```
    Description copied from interface: SqlValidator
    
    Converts a window specification or window name into a fully-resolved window specification. For example, in SELECT sum(x) OVER (PARTITION BY x ORDER BY y), sum(y) OVER w1, sum(z) OVER (w ORDER BY y) FROM t WINDOW w AS (PARTITION BY x) all aggregations have the same resolved window specification (PARTITION BY x ORDER BY y).
    
    Specified by:
    
    resolveWindow in interface SqlValidator
    
    Parameters:
    
    windowOrRef - Either the name of a window (a SqlIdentifier) or a window specification (a SqlWindow).
    
    scope - Scope in which to resolve window names
    
    Returns:
    
    A window
  - getOriginal
```
public SqlNode getOriginal(SqlNode expr)
```
  - setOriginal
```
public void setOriginal(SqlNode expr,
                        SqlNode original)
```
  - validateWindow
```
public void validateWindow(SqlNode windowOrId,
                           SqlValidatorScope scope,
                           @Nullable SqlCall call)
```
    Description copied from interface: SqlValidator
    
    Validates the right-hand side of an OVER expression. It might be either an identifier referencing a window, or an inline window specification.
    
    Specified by:
    
    validateWindow in interface SqlValidator
    
    Parameters:
    
    windowOrId - SqlNode that can be either SqlWindow with all the components of a window spec or a SqlIdentifier with the name of a window spec.
    
    scope - Naming scope
    
    call - the SqlNode if a function call if the window is attached to one.
  - validateMatchRecognize
```
public void validateMatchRecognize(SqlCall call)
```
    Description copied from interface: SqlValidator
    
    Validates a MATCH_RECOGNIZE clause.
    
    Specified by:
    
    validateMatchRecognize in interface SqlValidator
    
    Parameters:
    
    call - MATCH_RECOGNIZE clause
  - validatePivot
```
public void validatePivot(SqlPivot pivot)
```
  - validateUnpivot
```
public void validateUnpivot(SqlUnpivot unpivot)
```
  - validateAggregateParams
```
public void validateAggregateParams(SqlCall aggCall,
                                    @Nullable SqlNode filter,
                                    @Nullable SqlNodeList distinctList,
                                    @Nullable SqlNodeList orderList,
                                    SqlValidatorScope scope)
```
    Description copied from interface: SqlValidator
    
    Validates parameters for aggregate function.
    
    Specified by:
    
    validateAggregateParams in interface SqlValidator
    
    Parameters:
    
    aggCall - Call to aggregate function
    
    filter - Filter (FILTER (WHERE) clause), or null
    
    distinctList - Distinct specification (WITHIN DISTINCT clause), or null
    
    orderList - Ordering specification (WITHIN GROUP clause), or null
    
    scope - Syntactic scope
  - validateCall
```
public void validateCall(SqlCall call,
                         SqlValidatorScope scope)
```
    Description copied from interface: SqlValidator
    
    Validates a call to an operator.
    
    Specified by:
    
    validateCall in interface SqlValidator
    
    Parameters:
    
    call - Operator call
    
    scope - Naming scope
  - validateFeature
```
protected void validateFeature(Feature feature,
                               SqlParserPos context)
```
    Validates that a particular feature is enabled. By default, all features are enabled; subclasses may override this method to be more discriminating.
    
    Parameters:
    
    feature - feature being used, represented as a resource instance
    
    context - parser position context for error reporting, or null if
  - expandSelectExpr
```
public SqlNode expandSelectExpr(SqlNode expr,
                                SelectScope scope,
                                SqlSelect select)
```
  - expand
```
public SqlNode expand(SqlNode expr,
                      SqlValidatorScope scope)
```
    Description copied from interface: SqlValidator
    
    Expands an expression.
    
    Specified by:
    
    expand in interface SqlValidator
    
    Parameters:
    
    expr - Expression
    
    scope - Scope
    
    Returns:
    
    Expanded expression
  - expandGroupByOrHavingExpr
```
public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
                                         SqlValidatorScope scope,
                                         SqlSelect select,
                                         boolean havingExpression)
```
  - isSystemField
```
public boolean isSystemField(RelDataTypeField field)
```
    Description copied from interface: SqlValidator
    
    Returns whether a field is a system field. Such fields may have particular properties such as sortedness and nullability.
    In the default implementation, always returns false.
    
    Specified by:
    
    isSystemField in interface SqlValidator
    
    Parameters:
    
    field - Field
    
    Returns:
    
    whether field is a system field
  - getFieldOrigins
```
public List<List<String>> getFieldOrigins(SqlNode sqlQuery)
```
    Description copied from interface: SqlValidator
    
    Returns a description of how each field in the row type maps to a catalog, schema, table and column in the schema.
    The returned list is never null, and has one element for each field in the row type. Each element is a list of four elements (catalog, schema, table, column), or may be null if the column is an expression.
    
    Specified by:
    
    getFieldOrigins in interface SqlValidator
    
    Parameters:
    
    sqlQuery - Query
    
    Returns:
    
    Description of how each field in the row type maps to a schema object
  - getParameterRowType
```
public RelDataType getParameterRowType(SqlNode sqlQuery)
```
    Description copied from interface: SqlValidator
    
    Returns a record type that contains the name and type of each parameter. Returns a record type with no fields if there are no parameters.
    
    Specified by:
    
    getParameterRowType in interface SqlValidator
    
    Parameters:
    
    sqlQuery - Query
    
    Returns:
    
    Record type
  - validateColumnListParams
```
public void validateColumnListParams(SqlFunction function,
                                     List<RelDataType> argTypes,
                                     List<SqlNode> operands)
```
    Description copied from interface: SqlValidator
    
    Validates a COLUMN_LIST parameter.
    
    Specified by:
    
    validateColumnListParams in interface SqlValidator
    
    Parameters:
    
    function - function containing COLUMN_LIST parameter
    
    argTypes - function arguments
    
    operands - operands passed into the function call

Class SqlValidatorImpl

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.calcite.sql.validate.SqlValidator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.calcite.sql.validate.SqlValidator

Field Detail

TRACER

UPDATE_SRC_ALIAS

UPDATE_TGT_ALIAS

UPDATE_ANON_PREFIX

idPositions

scopes

namespaces

functionCallStack

typeFactory

unknownType

callToOperandTypesMap

Constructor Detail

SqlValidatorImpl

Method Detail

getConformance

getCatalogReader

getOperatorTable

getTypeFactory

getUnknownType

expandStar

declareCursor

pushFunctionCall

popFunctionCall

getParentCursor

usingNames

validate

lookupHints

lookupQualifiedName

lookupNameCompletionHints

validateParameterizedExpression

validateQuery

validateNamespace

getEmptyScope

getCursorScope

getWhereScope

getSelectScope

getRawSelectScope

getHavingScope

getGroupScope

getFromScope

getOrderScope

getMatchRecognizeScope

getJoinScope

getOverScope

getNamespace

performUnconditionalRewrites

getSelfJoinExprForUpdate

createSourceSelectForUpdate

createSourceSelectForDelete

getValidatedNodeType

getValidatedNodeTypeIfKnown

getValidatedOperandTypes

setValidatedNodeType

removeValidatedNodeType

makeNullaryCall

deriveType

deriveConstructorType

handleUnresolvedFunction

inferUnknownTypes

addToSelectList

deriveAlias

shouldAllowIntermediateOrderBy

createMatchRecognizeNameSpace

createPivotNameSpace

createUnpivotNameSpace

registerNamespace

shouldAllowOverRelation

createSelectNamespace

createSetopNamespace

isAggregate

isNestedAggregateWindow