Class SqlValidatorImpl

    • Field Detail

      • TRACER

        public static final org.slf4j.Logger TRACER
      • UPDATE_SRC_ALIAS

        public static final java.lang.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 java.lang.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 java.lang.String UPDATE_ANON_PREFIX
        Alias prefix generated for source columns when rewriting UPDATE to MERGE.
        See Also:
        Constant Field Values
      • idPositions

        protected final java.util.Map<java.lang.String,​SqlValidatorImpl.IdInfo> idPositions
        Maps ParsePosition strings to the SqlIdentifier identifier objects at these positions
      • cursorScopes

        private final java.util.Map<SqlSelect,​SqlValidatorScope> cursorScopes
        Maps a SqlSelect node that is the argument to a CURSOR constructor to the scope of the result of that select node
      • tableScope

        private TableScope tableScope
        The name-resolution scope of a LATERAL TABLE clause.
      • cursorSet

        private final java.util.Set<SqlNode> cursorSet
        Set of select expressions used as cursor definitions. In standard SQL, only the top-level SELECT is a cursor; Calcite extends this with cursors as inputs to table functions.
      • functionCallStack

        protected final java.util.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.
      • nextGeneratedId

        private int nextGeneratedId
      • unknownType

        protected final RelDataType unknownType
        The type of dynamic parameters until a type is imposed on them.
      • nodeToTypeMap

        private final java.util.Map<SqlNode,​RelDataType> nodeToTypeMap
        Map of derived RelDataType for each node. This is an IdentityHashMap since in some cases (such as null literals) we need to discriminate by instance.
      • aggFinder

        private final AggFinder aggFinder
      • aggOrOverFinder

        private final AggFinder aggOrOverFinder
      • aggOrOverOrGroupFinder

        private final AggFinder aggOrOverOrGroupFinder
      • groupFinder

        private final AggFinder groupFinder
      • overFinder

        private final AggFinder overFinder
      • originalExprs

        private final java.util.Map<SqlNode,​SqlNode> originalExprs
      • expandIdentifiers

        protected boolean expandIdentifiers
      • expandColumnReferences

        protected boolean expandColumnReferences
      • rewriteCalls

        private boolean rewriteCalls
      • validatingSqlMerge

        private boolean validatingSqlMerge
      • inWindow

        private boolean inWindow
      • enableTypeCoercion

        private boolean enableTypeCoercion
    • Method Detail

      • 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 java.lang.String getParentCursor​(java.lang.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
      • expandSelectItem

        private boolean expandSelectItem​(SqlNode selectItem,
                                         SqlSelect select,
                                         RelDataType targetType,
                                         java.util.List<SqlNode> selectItems,
                                         java.util.Set<java.lang.String> aliases,
                                         java.util.List<java.util.Map.Entry<java.lang.String,​RelDataType>> fields,
                                         boolean includeSystemVars)
        If selectItem is "*" or "TABLE.*", expands it and returns true; otherwise writes the unexpanded item.
        Parameters:
        selectItem - Select-list item
        select - Containing select clause
        selectItems - List that expanded items are written to
        aliases - Set of aliases
        fields - List of field names and types, in alias order
        includeSystemVars - If true include system vars in lists
        Returns:
        Whether the node was expanded
      • expandStar

        private boolean expandStar​(java.util.List<SqlNode> selectItems,
                                   java.util.Set<java.lang.String> aliases,
                                   java.util.List<java.util.Map.Entry<java.lang.String,​RelDataType>> fields,
                                   boolean includeSystemVars,
                                   SelectScope scope,
                                   SqlNode node)
      • addOrExpandField

        private boolean addOrExpandField​(java.util.List<SqlNode> selectItems,
                                         java.util.Set<java.lang.String> aliases,
                                         java.util.List<java.util.Map.Entry<java.lang.String,​RelDataType>> fields,
                                         boolean includeSystemVars,
                                         SelectScope scope,
                                         SqlIdentifier id,
                                         RelDataTypeField field)
      • 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 java.util.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
      • lookupSelectHints

        void lookupSelectHints​(SqlSelect select,
                               SqlParserPos pos,
                               java.util.Collection<SqlMoniker> hintList)
        Looks up completion hints for a syntactically correct select SQL that has been parsed into an expression tree.
        Parameters:
        select - the Select node of the parsed expression tree
        pos - indicates the position in the sql statement we want to get completion hints for
        hintList - list of SqlMoniker (sql identifiers) that can fill in at the indicated position
      • lookupNameCompletionHints

        public final void lookupNameCompletionHints​(SqlValidatorScope scope,
                                                    java.util.List<java.lang.String> names,
                                                    SqlParserPos pos,
                                                    java.util.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
      • findAllValidUdfNames

        private static void findAllValidUdfNames​(java.util.List<java.lang.String> names,
                                                 SqlValidator validator,
                                                 java.util.Collection<SqlMoniker> result)
      • findAllValidFunctionNames

        private static void findAllValidFunctionNames​(java.util.List<java.lang.String> names,
                                                      SqlValidator validator,
                                                      java.util.Collection<SqlMoniker> result,
                                                      SqlParserPos pos)
      • validateParameterizedExpression

        public SqlNode validateParameterizedExpression​(SqlNode topNode,
                                                       java.util.Map<java.lang.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,
                                  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'.
      • 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
      • 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
      • 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
      • handleOffsetFetch

        private void handleOffsetFetch​(SqlNode offset,
                                       SqlNode fetch)
      • 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
      • rewriteMerge

        private void rewriteMerge​(SqlMerge call)
      • getSelfJoinExprForUpdate

        protected SqlNode getSelfJoinExprForUpdate​(SqlNode table,
                                                   java.lang.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
      • getTableConstructorRowType

        RelDataType getTableConstructorRowType​(SqlCall values,
                                               SqlValidatorScope scope)
        Returns null if there is no common type. E.g. if the rows have a different number of columns.
      • 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
      • 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

        @Nullable
        public 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
      • handleUnresolvedFunction

        public CalciteException handleUnresolvedFunction​(SqlCall call,
                                                         SqlFunction unresolvedFunction,
                                                         java.util.List<RelDataType> argTypes,
                                                         java.util.List<java.lang.String> argNames)
        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
        argNames - Names of arguments, or null if call by position
      • addToSelectList

        protected void addToSelectList​(java.util.List<SqlNode> list,
                                       java.util.Set<java.lang.String> aliases,
                                       java.util.List<java.util.Map.Entry<java.lang.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 java.lang.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
      • setDefaultNullCollation

        public void setDefaultNullCollation​(NullCollation nullCollation)
        Description copied from interface: SqlValidator
        Sets how NULL values should be collated if an ORDER BY item does not contain NULLS FIRST or NULLS LAST.
        Specified by:
        setDefaultNullCollation in interface SqlValidator
      • 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,
                                         java.lang.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
      • registerFrom

        private SqlNode registerFrom​(SqlValidatorScope parentScope,
                                     SqlValidatorScope usingScope,
                                     boolean register,
                                     SqlNode node,
                                     SqlNode enclosingNode,
                                     java.lang.String alias,
                                     SqlNodeList extendList,
                                     boolean forceNullable,
                                     boolean lateral)
        Registers scopes and namespaces implied a relational expression in the FROM clause.

        parentScope and usingScope are often the same. They differ when the namespace are not visible within the parent. (Example needed.)

        Likewise, enclosingNode and node are often the same. enclosingNode is the topmost node within the FROM clause, from which any decorations like an alias (AS alias) or a table sample clause are stripped away to get node. Both are recorded in the namespace.

        Parameters:
        parentScope - Parent scope which this scope turns to in order to resolve objects
        usingScope - Scope whose child list this scope should add itself to
        register - Whether to register this scope as a child of usingScope
        node - Node which namespace is based on
        enclosingNode - Outermost node for namespace, including decorations such as alias and sample clause
        alias - Alias
        extendList - Definitions of extended columns
        forceNullable - Whether to force the type of namespace to be nullable because it is in an outer join
        lateral - Whether LATERAL is specified, so that items to the left of this in the JOIN tree are visible in the scope
        Returns:
        registered node, usually the same as node
      • isLateral

        private static boolean isLateral​(SqlNode node)
      • 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
      • registerQuery

        private void registerQuery​(SqlValidatorScope parentScope,
                                   SqlValidatorScope usingScope,
                                   SqlNode node,
                                   SqlNode enclosingNode,
                                   java.lang.String alias,
                                   boolean forceNullable)
        Registers a query in a parent scope.
        Parameters:
        parentScope - Parent scope which this scope turns to in order to resolve objects
        usingScope - Scope whose child list this scope should add itself to
        node - Query node
        alias - Name of this query within its parent. Must be specified if usingScope != null
      • registerQuery

        private void registerQuery​(SqlValidatorScope parentScope,
                                   SqlValidatorScope usingScope,
                                   SqlNode node,
                                   SqlNode enclosingNode,
                                   java.lang.String alias,
                                   boolean forceNullable,
                                   boolean checkUpdate)
        Registers a query in a parent scope.
        Parameters:
        parentScope - Parent scope which this scope turns to in order to resolve objects
        usingScope - Scope whose child list this scope should add itself to
        node - Query node
        alias - Name of this query within its parent. Must be specified if usingScope != null
        checkUpdate - if true, validate that the update feature is supported if validating the update statement
      • 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 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.

      • getAgg

        private SqlNode getAgg​(SqlSelect select)
        If there is at least one call to an aggregate function, returns the first.
      • 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
      • validateNodeFeature

        private void validateNodeFeature​(SqlNode node)
      • registerOperandSubQueries

        private void registerOperandSubQueries​(SqlValidatorScope parentScope,
                                               SqlCall call,
                                               int operandOrdinal)
        Registers any sub-queries inside a given call operand, and converts the operand to a scalar sub-query if the operator requires it.
        Parameters:
        parentScope - Parent scope
        call - Call
        operandOrdinal - Ordinal of operand within call
        See Also:
        SqlOperator.argumentMustBeScalar(int)
      • validateLiteralAsDouble

        private void validateLiteralAsDouble​(SqlLiteral literal)
      • 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
      • validateNoAggs

        private void validateNoAggs​(AggFinder aggFinder,
                                    SqlNode node,
                                    java.lang.String clause)
        Throws an error if there is an aggregate or windowed aggregate in the given clause.
        Parameters:
        aggFinder - Finder for the particular kind(s) of aggregate function
        node - Parse tree
        clause - Name of clause: "WHERE", "GROUP BY", "ON"
      • 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'.
      • checkRollUpInSelectList

        private void checkRollUpInSelectList​(SqlSelect select)
      • checkRollUpInGroupBy

        private void checkRollUpInGroupBy​(SqlSelect select)
      • checkRollUpInOrderBy

        private void checkRollUpInOrderBy​(SqlSelect select)
      • checkRollUpInWindowDecl

        private void checkRollUpInWindowDecl​(SqlSelect select)
      • shouldCheckForRollUp

        private boolean shouldCheckForRollUp​(SqlNode from)
      • validateModality

        private void validateModality​(SqlNode query)
        Validates that a query can deliver the modality it promises. Only called on the top-most SELECT or set operator in the tree.
      • deduceModality

        private SqlModality deduceModality​(SqlNode query)
        Return the intended modality of a SELECT or set-op.
      • 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
      • hasSortedPrefix

        private boolean hasSortedPrefix​(SelectScope scope,
                                        SqlNodeList orderList)
        Returns whether the prefix is sorted.
      • isSortCompatible

        private boolean isSortCompatible​(SelectScope scope,
                                         SqlNode node,
                                         boolean descending)
      • validateWindowClause

        protected void validateWindowClause​(SqlSelect select)
      • isTypeCoercionEnabled

        public boolean isTypeCoercionEnabled()
        Description copied from interface: SqlValidator
        Get if this validator supports implicit type coercion.
        Specified by:
        isTypeCoercionEnabled in interface SqlValidator
      • validateOrderList

        protected void validateOrderList​(SqlSelect select)
        Validates the ORDER BY clause of a SELECT statement.
        Parameters:
        select - Select statement
      • validateGroupByItem

        private void validateGroupByItem​(SqlSelect select,
                                         SqlNode groupByItem)
        Validates an item in the GROUP BY clause of a SELECT statement.
        Parameters:
        select - Select statement
        groupByItem - GROUP BY clause item
      • validateOrderItem

        private void validateOrderItem​(SqlSelect select,
                                       SqlNode orderItem)
        Validates an item in the ORDER BY clause of a SELECT statement.
        Parameters:
        select - Select statement
        orderItem - ORDER BY clause item
      • 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,
                                         java.lang.String clause)
      • validateHavingClause

        protected void validateHavingClause​(SqlSelect select)
      • validateExpr

        private void validateExpr​(SqlNode expr,
                                  SqlValidatorScope scope)
        Validates an expression.
        Parameters:
        expr - Expression
        scope - Scope in which expression occurs
      • handleScalarSubQuery

        private void handleScalarSubQuery​(SqlSelect parentSelect,
                                          SqlSelect selectItem,
                                          java.util.List<SqlNode> expandedSelectItems,
                                          java.util.Set<java.lang.String> aliasList,
                                          java.util.List<java.util.Map.Entry<java.lang.String,​RelDataType>> fieldList)
        Processes SubQuery found in Select list. Checks that is actually Scalar sub-query and makes proper entries in each of the 3 lists used to create the final rowType entry.
        Parameters:
        parentSelect - base SqlSelect item
        selectItem - child SqlSelect from select list
        expandedSelectItems - Select items after processing
        aliasList - built from user or system values
        fieldList - Built up entries for each select list entry
      • 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
      • checkConstraint

        private void checkConstraint​(SqlValidatorTable validatorTable,
                                     SqlNode source,
                                     RelDataType targetRowType)
        Validates insert values against the constraint of a modifiable view.
        Parameters:
        validatorTable - Table that may wrap a ModifiableViewTable
        source - The values being inserted
        targetRowType - The target type for the view
      • checkConstraint

        private void checkConstraint​(SqlValidatorTable validatorTable,
                                     SqlUpdate update,
                                     RelDataType targetRowType)
        Validates updates against the constraint of a modifiable view.
        Parameters:
        validatorTable - A SqlValidatorTable that may wrap a ModifiableViewTable
        update - The UPDATE parse tree node
        targetRowType - The target type
      • checkFieldCount

        private void checkFieldCount​(SqlNode node,
                                     SqlValidatorTable table,
                                     java.util.List<ColumnStrategy> strategies,
                                     RelDataType targetRowTypeToValidate,
                                     RelDataType realTargetRowType,
                                     SqlNode source,
                                     RelDataType logicalSourceRowType,
                                     RelDataType logicalTargetRowType)
        Check the field count of sql insert source and target node row type.
        Parameters:
        node - target table sql identifier
        table - target table
        strategies - column strategies of target table
        targetRowTypeToValidate - row type to validate mainly for column strategies
        realTargetRowType - target table row type exclusive virtual columns
        source - source node
        logicalSourceRowType - source node row type
        logicalTargetRowType - logical target row type, contains only target columns if they are specified or if the sql dialect allows subset insert, make a subset of fields(start from the left first field) whose length is equals with the source row type fields number.
      • isValuesWithDefault

        private boolean isValuesWithDefault​(SqlNode source,
                                            int column)
        Returns whether a query uses DEFAULT to populate a given column.
      • isRowWithDefault

        private boolean isRowWithDefault​(SqlNode operand,
                                         int column)
      • getNthExpr

        private SqlNode getNthExpr​(SqlNode query,
                                   int ordinal,
                                   int sourceCount)
        Locates the n'th expression in an INSERT or UPDATE query.
        Parameters:
        query - Query
        ordinal - Ordinal of expression
        sourceCount - Number of expressions
        Returns:
        Ordinal'th expression, never null
      • 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
      • validateAccess

        private void validateAccess​(SqlNode node,
                                    SqlValidatorTable table,
                                    SqlAccessEnum requiredAccess)
        Validates access to a table.
        Parameters:
        table - Table
        requiredAccess - Access requested on table
      • 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
      • 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
      • 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
      • 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.
      • 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
      • navigationInMeasure

        private SqlNode navigationInMeasure​(SqlNode node,
                                            boolean allRows)
      • alias

        private static java.lang.String alias​(SqlNode item)
        Returns the alias of a "expr AS alias" expression.
      • navigationInDefine

        private SqlNode navigationInDefine​(SqlNode node,
                                           java.lang.String alpha)
        Checks that all pattern variables within a function are the same, and canonizes expressions such as PREV(B.price) to LAST(B.price, 0).
      • validateAggregateParams

        public void validateAggregateParams​(SqlCall aggCall,
                                            SqlNode filter,
                                            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
        orderList - Ordering specification (WITHING GROUP clause), or null
        scope - Syntactic 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
      • 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 java.util.List<java.util.List<java.lang.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
      • getFieldOrigin

        private java.util.List<java.lang.String> getFieldOrigin​(SqlNode sqlQuery,
                                                                int i)
      • 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,
                                             java.util.List<RelDataType> argTypes,
                                             java.util.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
      • isPhysicalNavigation

        private static boolean isPhysicalNavigation​(SqlKind kind)
      • isLogicalNavigation

        private static boolean isLogicalNavigation​(SqlKind kind)
      • isAggregation

        private static boolean isAggregation​(SqlKind kind)
      • isRunningOrFinal

        private static boolean isRunningOrFinal​(SqlKind kind)
      • isSingleVarRequired

        private static boolean isSingleVarRequired​(SqlKind kind)