SqlValidatorImpl (Calcite Core 1.2.0-incubating API)

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

All Implemented Interfaces:

SqlValidator, SqlValidatorWithHints

Direct Known Subclasses:

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.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`expandColumnReferences`
`protected boolean`	`expandIdentifiers`
`protected Stack<SqlValidatorImpl.FunctionParamInfo>`	`functionCallStack` Stack of objects that maintain information about function calls.
`protected Map<String,SqlValidatorImpl.IdInfo>`	`idPositions` Maps ParsePosition strings to the `SqlIdentifier` identifier objects at these positions
`protected Map<SqlNode,SqlValidatorNamespace>`	`namespaces` Maps a `node` to the `namespace` which describes what columns they contain.
`protected Map<SqlNode,SqlValidatorScope>`	`scopes` Maps `query node` objects to the `SqlValidatorScope` scope created from them}.
`static Logger`	`TRACER`
`protected RelDataTypeFactory`	`typeFactory`
`protected RelDataType`	`unknownType`
`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.

Fields inherited from interface org.apache.calcite.sql.validate.SqlValidator
STRICT

Constructor Summary

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

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addToSelectList(List<SqlNode> list, Set<String> aliases, List<Map.Entry<String,RelDataType>> fieldList, SqlNode exp, SqlValidatorScope 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(RelDataType sourceRowType, RelDataType targetRowType, SqlNode query)`
`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, SqlNodeList targetColumnList, boolean append)` Derives a row-type for INSERT and UPDATE operations.
`void`	`declareCursor(SqlSelect select, SqlValidatorScope parentScope)` Declares a SELECT expression as a cursor.
`String`	`deriveAlias(SqlNode node, int ordinal)` Derives an alias for an expression.
`RelDataType`	`deriveConstructorType(SqlValidatorScope scope, SqlCall call, SqlFunction unresolvedConstructor, 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`	`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.
`SqlNodeList`	`expandStar(SqlNodeList selectList, SqlSelect select, boolean includeSystemVars)` Returns a list of expressions, with every occurrence of "" or "TABLE." expanded.
`protected 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.
`boolean`	`getColumnReferenceExpansion()`
`SqlConformance`	`getConformance()` Returns the dialect of SQL (SQL:2003, etc.) this validator recognizes.
`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.
`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.
`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)`
`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.
`String`	`getParentCursor(String columnListParamName)` Retrieves the name of the parent cursor referenced by a column list parameter.
`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 SqlNode`	`getSelfJoinExprForUpdate(SqlNode table, String alias)` Allows a subclass to provide information about how to convert an UPDATE into a MERGE via self-join.
`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.
`RelDataType`	`getValidatedNodeTypeIfKnown(SqlNode node)` Returns the type assigned to a node by validation, or null if unknown.
`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)`
`SqlValidatorScope`	`getWithScope(SqlNode withItem)`
`CalciteException`	`handleUnresolvedFunction(SqlCall call, SqlFunction unresolvedFunction, List<RelDataType> argTypes)` Handles a call to a function which cannot be resolved.
`protected void`	`inferUnknownTypes(RelDataType inferredType, SqlValidatorScope scope, SqlNode node)`
`boolean`	`isAggregate(SqlNode selectNode)` Returns whether a select list expression is an aggregate function.
`boolean`	`isAggregate(SqlSelect select)` Returns whether a SELECT statement is an aggregation.
`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.
`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.
`CalciteContextException`	`newValidationError(SqlNode node, Resources.ExInst<SqlValidatorException> e)` Adds "line x, column y" context to a validator exception.
`protected SqlNode`	`performUnconditionalRewrites(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(SqlValidatorScope usingScope, 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, boolean populateBounds)` Converts a window specification or window name into a fully-resolved window specification.
`void`	`setCallRewrite(boolean rewriteCalls)` Enables or disables rewrite of "macro-like" calls such as COALESCE.
`void`	`setColumnReferenceExpansion(boolean expandColumnReferences)` Enables or disables expansion of column references.
`void`	`setIdentifierExpansion(boolean expandIdentifiers)` Enables or disables expansion of identifiers other than column references.
`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()`
`boolean`	`shouldExpandIdentifiers()` Returns expansion of identifiers.
`SqlNode`	`validate(SqlNode topNode)` Validates an expression tree.
`void`	`validateAggregateParams(SqlCall aggFunction, 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 subquery.
`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`	`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)` 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`	`validateQuery(SqlNode node, SqlValidatorScope scope)` 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`	`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 keyword)`
`void`	`validateWindow(SqlNode windowOrId, SqlValidatorScope scope, 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

- Field Detail
  - TRACER
```
public static final 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 ParsePosition strings to the SqlIdentifier identifier objects at these positions
  - scopes
```
protected final Map<SqlNode,SqlValidatorScope> scopes
```
    Maps query node objects to the SqlValidatorScope scope created from them}.
  - namespaces
```
protected final Map<SqlNode,SqlValidatorNamespace> namespaces
```
    Maps a node to the namespace which describes what columns they contain.
  - functionCallStack
```
protected final Stack<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
```
  - expandIdentifiers
```
protected boolean expandIdentifiers
```
  - expandColumnReferences
```
protected boolean expandColumnReferences
```
- Constructor Detail
  - SqlValidatorImpl
```
protected SqlValidatorImpl(SqlOperatorTable opTab,
                SqlValidatorCatalogReader catalogReader,
                RelDataTypeFactory typeFactory,
                SqlConformance conformance)
```
    Creates a validator.
    
    Parameters:
    opTab - Operator table
    catalogReader - Catalog reader
    typeFactory - Type factory
    conformance - Compatibility mode
- Method Detail
  - getEmptyScope
```
public SqlValidatorScope getEmptyScope()
```
  - getConformance
```
public SqlConformance getConformance()
```
    Description copied from interface: SqlValidator
    
    Returns the dialect of SQL (SQL:2003, etc.) this validator recognizes. Default is SqlConformance.DEFAULT.
    
    Specified by:
    
    getConformance in interface SqlValidator
    
    Returns:
    dialect of SQL this validator recognizes
  - getCatalogReader
```
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
```
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
```
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 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
  - 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 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 an empty string
  - 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,
                 SqlValidatorScope scope)
```
    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
  - validateNamespace
```
protected void validateNamespace(SqlValidatorNamespace namespace)
```
    Validates a namespace.
  - 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 (SqlValidator.getSelectScope(org.apache.calcite.sql.SqlSelect)), 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 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 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
  - getJoinScope
```
public 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 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 SqlNode performUnconditionalRewrites(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.
    
    Parameters:
    node - expression to be rewritten
    underFrom - whether node appears directly under a FROM clause
    
    Returns:
    rewritten expression
  - getSelfJoinExprForUpdate
```
protected 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 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
  - setValidatedNodeType
```
public void setValidatedNodeType(SqlNode node,
                        RelDataType type)
```
    Description copied from interface: SqlValidator
    
    Saves the type of a SqlNode, now that it has been validated.
    
    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
  - 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,
                                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,
                                        SqlFunction unresolvedFunction,
                                        List<RelDataType> argTypes)
```
    Description copied from interface: SqlValidator
    
    Handles a call to a function which cannot be resolved. Returns a 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
  - 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,
                   SqlValidatorScope 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 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
  - setIdentifierExpansion
```
public void setIdentifierExpansion(boolean expandIdentifiers)
```
    Description copied from interface: SqlValidator
    
    Enables or disables expansion of identifiers other than column references.
    
    Specified by:
    
    setIdentifierExpansion in interface SqlValidator
    
    Parameters:
    expandIdentifiers - new setting
  - setColumnReferenceExpansion
```
public void setColumnReferenceExpansion(boolean expandColumnReferences)
```
    Description copied from interface: SqlValidator
    
    Enables or disables expansion of column references. (Currently this does not apply to the ORDER BY clause; may be fixed in the future.)
    
    Specified by:
    
    setColumnReferenceExpansion in interface SqlValidator
    
    Parameters:
    expandColumnReferences - new setting
  - getColumnReferenceExpansion
```
public boolean getColumnReferenceExpansion()
```
    Specified by:
    
    getColumnReferenceExpansion in interface SqlValidator
    
    Returns:
    whether column reference expansion is enabled
  - setCallRewrite
```
public void setCallRewrite(boolean rewriteCalls)
```
    Description copied from interface: SqlValidator
    
    Enables or disables rewrite of "macro-like" calls such as COALESCE.
    
    Specified by:
    
    setCallRewrite in interface SqlValidator
    
    Parameters:
    rewriteCalls - new setting
  - shouldExpandIdentifiers
```
public boolean shouldExpandIdentifiers()
```
    Description copied from interface: SqlValidator
    
    Returns expansion of identifiers.
    
    Specified by:
    
    shouldExpandIdentifiers in interface SqlValidator
    
    Returns:
    whether this validator should expand identifiers
  - shouldAllowIntermediateOrderBy
```
protected boolean shouldAllowIntermediateOrderBy()
```
  - registerNamespace
```
protected void registerNamespace(SqlValidatorScope usingScope,
                     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
  - 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
  - getAggregate
```
protected 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.
  - isAggregate
```
public boolean isAggregate(SqlNode selectNode)
```
    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 subquery.
    
    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
  - validateOver
```
protected void validateOver(SqlCall call,
                SqlValidatorScope scope)
```
  - 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
  - getWithScope
```
public SqlValidatorScope getWithScope(SqlNode withItem)
```
    Specified by:
    
    getWithScope 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 keyword)
```
  - validateHavingClause
```
protected void validateHavingClause(SqlSelect select)
```
  - validateSelectList
```
protected RelDataType validateSelectList(SqlNodeList selectItems,
                             SqlSelect select,
                             RelDataType targetRowType)
```
  - createTargetRowType
```
protected RelDataType createTargetRowType(SqlValidatorTable table,
                              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(RelDataType sourceRowType,
                       RelDataType targetRowType,
                       SqlNode 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
  - newValidationError
```
public CalciteContextException newValidationError(SqlNode node,
                                         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,
                      boolean populateBounds)
```
    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
    populateBounds - Whether to populate bounds. Doing so may alter the definition of the window. It is recommended that populate bounds when translating to physical algebra, but not when validating.
    
    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,
                  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.
  - validateAggregateParams
```
public void validateAggregateParams(SqlCall aggFunction,
                           SqlValidatorScope scope)
```
    Description copied from interface: SqlValidator
    
    Validates parameters for aggregate function.
    
    Specified by:
    
    validateAggregateParams in interface SqlValidator
    
    Parameters:
    aggFunction - function containing COLUMN_LIST parameter
    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
  - 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
  - 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

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TRACER

UPDATE_SRC_ALIAS

UPDATE_TGT_ALIAS

UPDATE_ANON_PREFIX

idPositions

scopes

namespaces

functionCallStack

typeFactory

unknownType

expandIdentifiers

expandColumnReferences

Constructor Detail

SqlValidatorImpl

Method Detail

getEmptyScope

getConformance

getCatalogReader

getOperatorTable

getTypeFactory

getUnknownType

expandStar

declareCursor

pushFunctionCall

popFunctionCall

getParentCursor

validate

lookupHints

lookupQualifiedName

lookupNameCompletionHints

validateParameterizedExpression

validateQuery

validateNamespace

getCursorScope

getWhereScope

getSelectScope

getRawSelectScope

getHavingScope

getGroupScope

getFromScope

getOrderScope

getJoinScope

getOverScope

getNamespace

performUnconditionalRewrites

getSelfJoinExprForUpdate

createSourceSelectForUpdate

createSourceSelectForDelete

getValidatedNodeType

getValidatedNodeTypeIfKnown

setValidatedNodeType

removeValidatedNodeType

deriveType

deriveConstructorType

handleUnresolvedFunction

inferUnknownTypes

addToSelectList

deriveAlias

setIdentifierExpansion

setColumnReferenceExpansion

getColumnReferenceExpansion

setCallRewrite

shouldExpandIdentifiers

shouldAllowIntermediateOrderBy

registerNamespace

shouldAllowOverRelation

createSelectNamespace

createSetopNamespace

isAggregate

getAggregate

isAggregate

validateIdentifier