Package org.apache.calcite.sql.validate

Interface SqlValidator

    • Field Detail

      • STRICT

        static final boolean STRICT
        Whether to follow the SQL standard strictly.

    • Method Detail

      • getConformance

        SqlConformance getConformance()
        Returns the dialect of SQL (SQL:2003, etc.) this validator recognizes. Default is SqlConformanceEnum.DEFAULT.
        Returns:
        dialect of SQL this validator recognizes

      • getCatalogReader

        SqlValidatorCatalogReader getCatalogReader()
        Returns the catalog reader used by this validator.
        Returns:
        catalog reader

      • getOperatorTable

        SqlOperatorTable getOperatorTable()
        Returns the operator table used by this validator.
        Returns:
        operator table

      • validate

        SqlNode validate​(SqlNode topNode)
        Validates an expression tree. You can call this method multiple times, but not reentrantly.
        Parameters:
        topNode - top of expression tree to be validated
        Returns:
        validated tree (possibly rewritten)

      • validateParameterizedExpression

        SqlNode validateParameterizedExpression​(SqlNode topNode,
                                        java.util.Map<java.lang.String,​RelDataType> nameToTypeMap)
        Validates an expression tree. You can call this method multiple times, but not reentrantly.
        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

        void validateQuery​(SqlNode node,
                   SqlValidatorScope scope,
                   RelDataType targetRowType)
        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
        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'.
        Throws:
        java.lang.RuntimeException - if the query is not valid

      • getValidatedNodeType

        RelDataType getValidatedNodeType​(SqlNode node)
        Returns the type assigned to a node by validation.
        Parameters:
        node - the node of interest
        Returns:
        validated type, never null

      • getValidatedNodeTypeIfKnown

        RelDataType getValidatedNodeTypeIfKnown​(SqlNode node)
        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 getValidatedNodeType(org.apache.calcite.sql.SqlNode) instead.
        Parameters:
        node - the node of interest
        Returns:
        validated type, or null if unknown or not applicable

      • validateIdentifier

        void validateIdentifier​(SqlIdentifier id,
                        SqlValidatorScope scope)
        Resolves an identifier to a fully-qualified name.
        Parameters:
        id - Identifier
        scope - Naming scope

      • validateLiteral

        void validateLiteral​(SqlLiteral literal)
        Validates a literal.
        Parameters:
        literal - Literal

      • validateInsert

        void validateInsert​(SqlInsert insert)
        Validates an INSERT statement.
        Parameters:
        insert - INSERT statement

      • validateUpdate

        void validateUpdate​(SqlUpdate update)
        Validates an UPDATE statement.
        Parameters:
        update - UPDATE statement

      • validateDelete

        void validateDelete​(SqlDelete delete)
        Validates a DELETE statement.
        Parameters:
        delete - DELETE statement

      • validateMerge

        void validateMerge​(SqlMerge merge)
        Validates a MERGE statement.
        Parameters:
        merge - MERGE statement

      • validateDataType

        void validateDataType​(SqlDataTypeSpec dataType)
        Validates a data type expression.
        Parameters:
        dataType - Data type

      • validateDynamicParam

        void validateDynamicParam​(SqlDynamicParam dynamicParam)
        Validates a dynamic parameter.
        Parameters:
        dynamicParam - Dynamic parameter

      • validateWindow

        void validateWindow​(SqlNode windowOrId,
                    SqlValidatorScope scope,
                    SqlCall call)
        Validates the right-hand side of an OVER expression. It might be either an identifier referencing a window, or an inline window specification.
        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

        void validateMatchRecognize​(SqlCall pattern)
        Validates a MATCH_RECOGNIZE clause.
        Parameters:
        pattern - MATCH_RECOGNIZE clause

      • validateCall

        void validateCall​(SqlCall call,
                  SqlValidatorScope scope)
        Validates a call to an operator.
        Parameters:
        call - Operator call
        scope - Naming scope

      • validateAggregateParams

        void validateAggregateParams​(SqlCall aggCall,
                             SqlNode filter,
                             SqlNodeList orderList,
                             SqlValidatorScope scope)
        Validates parameters for aggregate function.
        Parameters:
        aggCall - Call to aggregate function
        filter - Filter (FILTER (WHERE) clause), or null
        orderList - Ordering specification (WITHING GROUP clause), or null
        scope - Syntactic scope

      • validateColumnListParams

        void validateColumnListParams​(SqlFunction function,
                              java.util.List<RelDataType> argTypes,
                              java.util.List<SqlNode> operands)
        Validates a COLUMN_LIST parameter
        Parameters:
        function - function containing COLUMN_LIST parameter
        argTypes - function arguments
        operands - operands passed into the function call

      • deriveType

        RelDataType deriveType​(SqlValidatorScope scope,
                       SqlNode operand)
        Derives the type of a node in a given scope. If the type has already been inferred, returns the previous type.
        Parameters:
        scope - Syntactic scope
        operand - Parse tree node
        Returns:
        Type of the SqlNode. Should never return NULL

      • newValidationError

        CalciteContextException newValidationError​(SqlNode node,
                                           Resources.ExInst<SqlValidatorException> e)
        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.

        Parameters:
        node - The place where the exception occurred, not null
        e - The validation error
        Returns:
        Exception containing positional information, never null

      • isAggregate

        boolean isAggregate​(SqlSelect select)
        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.)
        Parameters:
        select - SELECT statement
        Returns:
        whether SELECT statement is an aggregation

      • isAggregate

        @Deprecated
boolean isAggregate​(SqlNode selectNode)
        Deprecated.
        Returns whether a select list expression is an aggregate function.
        Parameters:
        selectNode - Expression in SELECT clause
        Returns:
        whether expression is an aggregate function

      • resolveWindow

        SqlWindow resolveWindow​(SqlNode windowOrRef,
                        SqlValidatorScope scope,
                        boolean populateBounds)
        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).
        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
        Throws:
        java.lang.RuntimeException - Validation exception if window does not exist

      • getNamespace

        SqlValidatorNamespace getNamespace​(SqlNode node)
        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.

        Parameters:
        node - Parse tree node
        Returns:
        namespace of node

      • deriveAlias

        java.lang.String deriveAlias​(SqlNode node,
                             int ordinal)
        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.
        Parameters:
        node - Expression
        ordinal - Ordinal of expression
        Returns:
        derived alias, or null if no alias can be derived and ordinal is less than zero

      • expandStar

        SqlNodeList expandStar​(SqlNodeList selectList,
                       SqlSelect query,
                       boolean includeSystemVars)
        Returns a list of expressions, with every occurrence of "*" or "TABLE.*" expanded.
        Parameters:
        selectList - Select clause to be expanded
        query - Query
        includeSystemVars - Whether to include system variables
        Returns:
        expanded select clause

      • getWhereScope

        SqlValidatorScope getWhereScope​(SqlSelect select)
        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.
        Parameters:
        select - Query
        Returns:
        naming scope of WHERE clause

      • getTypeFactory

        RelDataTypeFactory getTypeFactory()
        Returns the type factory used by this validator.
        Returns:
        type factory

      • setValidatedNodeType

        void setValidatedNodeType​(SqlNode node,
                          RelDataType type)
        Deprecated.
        This method should not be in the SqlValidator interface. The validator should drive the type-derivation process, and store nodes' types when they have been derived.
        Saves the type of a SqlNode, now that it has been validated.
        Parameters:
        node - A SQL parse tree node, never null
        type - Its type; must not be null

      • removeValidatedNodeType

        void removeValidatedNodeType​(SqlNode node)
        Removes a node from the set of validated nodes
        Parameters:
        node - node to be removed

      • getUnknownType

        RelDataType getUnknownType()
        Returns an object representing the "unknown" type.
        Returns:
        unknown type

      • getRawSelectScope

        SelectScope getRawSelectScope​(SqlSelect select)
        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.
        Parameters:
        select - SELECT statement
        Returns:
        naming scope for SELECT statement, sans any aggregating scope

      • getFromScope

        SqlValidatorScope getFromScope​(SqlSelect select)
        Returns a scope containing the objects visible from the FROM clause of a query.
        Parameters:
        select - SELECT statement
        Returns:
        naming scope for FROM clause

      • getGroupScope

        SqlValidatorScope getGroupScope​(SqlSelect select)
        Returns a scope containing the objects visible from the GROUP BY clause of a query.
        Parameters:
        select - SELECT statement
        Returns:
        naming scope for GROUP BY clause

      • getHavingScope

        SqlValidatorScope getHavingScope​(SqlSelect select)
        Returns a scope containing the objects visible from the HAVING clause of a query.
        Parameters:
        select - SELECT statement
        Returns:
        naming scope for HAVING clause

      • getOrderScope

        SqlValidatorScope getOrderScope​(SqlSelect select)
        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.
        Parameters:
        select - SELECT statement
        Returns:
        naming scope for ORDER BY clause

      • getMatchRecognizeScope

        SqlValidatorScope getMatchRecognizeScope​(SqlMatchRecognize node)
        Returns a scope match recognize clause.
        Parameters:
        node - Match recognize
        Returns:
        naming scope for Match recognize clause

      • declareCursor

        void declareCursor​(SqlSelect select,
                   SqlValidatorScope scope)
        Declares a SELECT expression as a cursor.
        Parameters:
        select - select expression associated with the cursor
        scope - scope of the parent query associated with the cursor

      • pushFunctionCall

        void pushFunctionCall()
        Pushes a new instance of a function call on to a function call stack.

      • popFunctionCall

        void popFunctionCall()
        Removes the topmost entry from the function call stack.

      • getParentCursor

        java.lang.String getParentCursor​(java.lang.String columnListParamName)
        Retrieves the name of the parent cursor referenced by a column list parameter.
        Parameters:
        columnListParamName - name of the column list parameter
        Returns:
        name of the parent cursor

      • setIdentifierExpansion

        void setIdentifierExpansion​(boolean expandIdentifiers)
        Enables or disables expansion of identifiers other than column references.
        Parameters:
        expandIdentifiers - new setting

      • setColumnReferenceExpansion

        void setColumnReferenceExpansion​(boolean expandColumnReferences)
        Enables or disables expansion of column references. (Currently this does not apply to the ORDER BY clause; may be fixed in the future.)
        Parameters:
        expandColumnReferences - new setting

      • getColumnReferenceExpansion

        boolean getColumnReferenceExpansion()
        Returns:
        whether column reference expansion is enabled

      • setDefaultNullCollation

        void setDefaultNullCollation​(NullCollation nullCollation)
        Sets how NULL values should be collated if an ORDER BY item does not contain NULLS FIRST or NULLS LAST.

      • getDefaultNullCollation

        NullCollation getDefaultNullCollation()
        Returns how NULL values should be collated if an ORDER BY item does not contain NULLS FIRST or NULLS LAST.

      • shouldExpandIdentifiers

        boolean shouldExpandIdentifiers()
        Returns expansion of identifiers.
        Returns:
        whether this validator should expand identifiers

      • setCallRewrite

        void setCallRewrite​(boolean rewriteCalls)
        Enables or disables rewrite of "macro-like" calls such as COALESCE.
        Parameters:
        rewriteCalls - new setting

      • deriveConstructorType

        RelDataType deriveConstructorType​(SqlValidatorScope scope,
                                  SqlCall call,
                                  SqlFunction unresolvedConstructor,
                                  SqlFunction resolvedConstructor,
                                  java.util.List<RelDataType> argTypes)
        Derives the type of a constructor.
        Parameters:
        scope - Scope
        call - Call
        unresolvedConstructor - TODO
        resolvedConstructor - TODO
        argTypes - Types of arguments
        Returns:
        Resolved type of constructor

      • handleUnresolvedFunction

        CalciteException handleUnresolvedFunction​(SqlCall call,
                                          SqlFunction unresolvedFunction,
                                          java.util.List<RelDataType> argTypes,
                                          java.util.List<java.lang.String> argNames)
        Handles a call to a function which cannot be resolved. Returns a an appropriately descriptive error, which caller must throw.
        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

      • expandOrderExpr

        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.

        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"
        Parameters:
        select - Select statement which contains ORDER BY
        orderExpr - Expression in the ORDER BY clause.
        Returns:
        Expression translated into SELECT clause semantics

      • expand

        SqlNode expand​(SqlNode expr,
               SqlValidatorScope scope)
        Expands an expression.
        Parameters:
        expr - Expression
        scope - Scope
        Returns:
        Expanded expression

      • isSystemField

        boolean isSystemField​(RelDataTypeField field)
        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.

        Parameters:
        field - Field
        Returns:
        whether field is a system field

      • getFieldOrigins

        java.util.List<java.util.List<java.lang.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.

        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.

        Parameters:
        sqlQuery - Query
        Returns:
        Description of how each field in the row type maps to a schema object

      • getParameterRowType

        RelDataType getParameterRowType​(SqlNode sqlQuery)
        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.
        Parameters:
        sqlQuery - Query
        Returns:
        Record type

      • getOverScope

        SqlValidatorScope getOverScope​(SqlNode node)
        Returns the scope of an OVER or VALUES node.
        Parameters:
        node - Node
        Returns:
        Scope

      • validateModality

        boolean validateModality​(SqlSelect select,
                         SqlModality modality,
                         boolean fail)
        Validates that a query is capable of producing a return of given modality (relational or streaming).
        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

      • validateWithItem

        void validateWithItem​(SqlWithItem withItem)