Class SqlToRelConverter

    • Method Detail

      • getCluster

        public RelOptCluster getCluster()
        Returns the RelOptCluster in use.
      • getRexBuilder

        public RexBuilder getRexBuilder()
        Returns the row-expression builder.
      • getDynamicParamType

        public RelDataType getDynamicParamType​(int index)
        Returns the type inferred for a dynamic parameter.
        index - 0-based index of dynamic parameter
        inferred type, never null
      • getDynamicParamCountInExplain

        public int getDynamicParamCountInExplain​(boolean increment)
        Returns the current count of the number of dynamic parameters in an EXPLAIN PLAN statement.
        increment - if true, increment the count
        the current count before the optional increment
      • getMapConvertedNonCorrSubqs

        public Map<SqlNode,​RexNode> getMapConvertedNonCorrSubqs()
        Returns the mapping of non-correlated sub-queries that have been converted to the constants that they evaluate to.
      • addConvertedNonCorrSubqs

        public void addConvertedNonCorrSubqs​(Map<SqlNode,​RexNode> alreadyConvertedNonCorrSubqs)
        Adds to the current map of non-correlated converted sub-queries the elements from another map that contains non-correlated sub-queries that have been converted by another SqlToRelConverter.
        alreadyConvertedNonCorrSubqs - the other map
      • setSubQueryConverter

        public void setSubQueryConverter​(SubQueryConverter converter)
        Sets a new SubQueryConverter. To have any effect, this must be called before any convert method.
        converter - new SubQueryConverter
      • setDynamicParamCountInExplain

        public void setDynamicParamCountInExplain​(int explainParamCount)
        Sets the number of dynamic parameters in the current EXPLAIN PLAN statement.
        explainParamCount - number of dynamic parameters in the statement
      • flattenTypes

        public RelNode flattenTypes​(RelNode rootRel,
                                    boolean restructure)
      • decorrelate

        public RelNode decorrelate​(SqlNode query,
                                   RelNode rootRel)
        If sub-query is correlated and decorrelation is enabled, performs decorrelation.
        query - Query
        rootRel - Root relational expression
        New root relational expression after decorrelation
      • trimUnusedFields

        public RelNode trimUnusedFields​(boolean ordered,
                                        RelNode rootRel)
        Walks over a tree of relational expressions, replacing each RelNode with a 'slimmed down' relational expression that projects only the fields required by its consumer.

        This may make things easier for the optimizer, by removing crud that would expand the search space, but is difficult for the optimizer itself to do it, because optimizer rules must preserve the number and type of fields. Hence, this transform that operates on the entire tree, similar to the type-flattening transform.

        Currently this functionality is disabled in farrago/luciddb; the default implementation of this method does nothing.

        ordered - Whether the relational expression must produce results in a particular order (typically because it has an ORDER BY at top level)
        rootRel - Relational expression that is at the root of the tree
        Trimmed relational expression
      • newFieldTrimmer

        protected RelFieldTrimmer newFieldTrimmer()
        Creates a RelFieldTrimmer.
        Field trimmer
      • convertQuery

        public RelRoot convertQuery​(SqlNode query,
                                    boolean needsValidation,
                                    boolean top)
        Converts an unvalidated query's parse tree into a relational expression.
        query - Query to convert
        needsValidation - Whether to validate the query before converting; false if the query has already been validated.
        top - Whether the query is top-level, say if its result will become a JDBC result set; false if the query will be part of a view.
      • isOrdered

        public static boolean isOrdered​(SqlNode query)
      • convertSelect

        public RelNode convertSelect​(SqlSelect select,
                                     boolean top)
        Converts a SELECT statement's parse tree into a relational expression.
      • convertOrder

        protected void convertOrder​(SqlSelect select,
                                    SqlToRelConverter.Blackboard bb,
                                    RelCollation collation,
                                    List<SqlNode> orderExprList,
                                    SqlNode offset,
                                    SqlNode fetch)
        Converts a query's ORDER BY clause, if any.

        Ignores the ORDER BY clause if the query is not top-level and FETCH or OFFSET are not present.

        select - Query
        bb - Blackboard
        collation - Collation list
        orderExprList - Method populates this list with orderBy expressions not present in selectList
        offset - Expression for number of rows to discard before returning first row
        fetch - Expression for number of rows to fetch
      • convertToSingleValueSubq

        public RelNode convertToSingleValueSubq​(SqlNode query,
                                                RelNode plan)
        Converts the RelNode tree for a select statement to a select that produces a single value.
        query - the query
        plan - the original RelNode tree corresponding to the statement
        the converted RelNode tree
      • convertExpression

        public RexNode convertExpression​(SqlNode node)
        Converts an expression from SqlNode to RexNode format.
        node - Expression to translate
        Converted expression
      • convertExpression

        public RexNode convertExpression​(SqlNode node,
                                         Map<String,​RexNode> nameToNodeMap)
        Converts an expression from SqlNode to RexNode format, mapping identifier references to predefined expressions.
        node - Expression to translate
        nameToNodeMap - map from String to RexNode; when an SqlIdentifier is encountered, it is used as a key and translated to the corresponding value from this map
        Converted expression
      • convertExtendedExpression

        protected RexNode convertExtendedExpression​(SqlNode node,
                                                    SqlToRelConverter.Blackboard bb)
        Converts a non-standard expression.

        This method is an extension-point that derived classes can override. If this method returns a null result, the normal expression translation process will proceed. The default implementation always returns null.

        node - Expression
        bb - Blackboard
        null to proceed with the usual expression translation process
      • convertFrom

        protected void convertFrom​(SqlToRelConverter.Blackboard bb,
                                   SqlNode from,
                                   List<String> fieldNames)
        Converts a FROM clause into a relational expression.
        bb - Scope within which to resolve identifiers
        from - FROM clause of a query. Examples include:
        • a single table ("SALES.EMP"),
        • an aliased table ("EMP AS E"),
        • a list of tables ("EMP, DEPT"),
        • an ANSI Join expression ("EMP JOIN DEPT ON EMP.DEPTNO = DEPT.DEPTNO"),
        • a VALUES clause ("VALUES ('Fred', 20)"),
        • a query ("(SELECT * FROM EMP WHERE GENDER = 'F')"),
        • or any combination of the above.
        fieldNames - Field aliases, usually come from AS clause
      • getSystemFields

        protected List<RelDataTypeField> getSystemFields()
        Returns a list of fields to be prefixed to each relational expression.
        List of system fields
      • createAggregate

        protected RelNode createAggregate​(SqlToRelConverter.Blackboard bb,
                                          ImmutableBitSet groupSet,
                                <ImmutableBitSet> groupSets,
                                          List<AggregateCall> aggCalls)
        Creates an Aggregate.

        In case the aggregate rel changes the order in which it projects fields, the groupExprProjection parameter is provided, and the implementation of this method may modify it.

        The sortedCount parameter is the number of expressions known to be monotonic. These expressions must be on the leading edge of the grouping keys. The default implementation of this method ignores this parameter.

        bb - Blackboard
        groupSet - Bit set of ordinals of grouping columns
        groupSets - Grouping sets
        aggCalls - Array of calls to aggregate functions
      • gatherOrderExprs

        protected void gatherOrderExprs​(SqlToRelConverter.Blackboard bb,
                                        SqlSelect select,
                                        SqlNodeList orderList,
                                        List<SqlNode> extraOrderExprs,
                                        List<RelFieldCollation> collationList)
        Creates a list of collations required to implement the ORDER BY clause, if there is one. Populates extraOrderExprs with any sort expressions which are not in the select clause.
        bb - Scope within which to resolve identifiers
        select - Select clause. Never null, because we invent a dummy SELECT if ORDER BY is applied to a set operation (UNION etc.)
        orderList - Order by clause, may be null
        extraOrderExprs - Sort expressions which are not in the select clause (output)
        collationList - List of collations (output)
      • enableDecorrelation

        protected boolean enableDecorrelation()
      • decorrelateQuery

        protected RelNode decorrelateQuery​(RelNode rootRel)
      • isTrimUnusedFields

        public boolean isTrimUnusedFields()
        Returns whether to trim unused fields as part of the conversion process.
        Whether to trim unused fields
      • convertQueryRecursive

        protected RelRoot convertQueryRecursive​(SqlNode query,
                                                boolean top,
                                                RelDataType targetRowType)
        Recursively converts a query to a relational expression.
        query - Query
        top - Whether this query is the top-level query of the statement
        targetRowType - Target row type, or null
        Relational expression
      • convertSetOp

        protected RelNode convertSetOp​(SqlCall call)
        Converts a set operation (UNION, INTERSECT, MINUS) into relational expressions.
        call - Call to set operator
        Relational expression
      • convertColumnList

        protected RelNode convertColumnList​(SqlInsert call,
                                            RelNode source)
        Creates a source for an INSERT statement.

        If the column list is not specified, source expressions match target columns in order.

        If the column list is specified, Source expressions are mapped to target columns by name via targetColumnList, and may not cover the entire target table. So, we'll make up a full row, using a combination of default values and the source expressions provided.

        call - Insert expression
        source - Source relational expression
        Converted INSERT statement
      • collectInsertTargets

        protected void collectInsertTargets​(SqlInsert call,
                                            RexNode sourceRef,
                                            List<String> targetColumnNames,
                                            List<RexNode> columnExprs)
        Given an INSERT statement, collects the list of names to be populated and the expressions to put in them.
        call - Insert statement
        sourceRef - Expression representing a row from the source relational expression
        targetColumnNames - List of target column names, to be populated
        columnExprs - List of expressions, to be populated
      • adjustInputRef

        protected RexNode adjustInputRef​(SqlToRelConverter.Blackboard bb,
                                         RexInputRef inputRef)
        Adjusts the type of a reference to an input field to account for nulls introduced by outer joins; and adjusts the offset to match the physical implementation.
        bb - Blackboard
        inputRef - Input ref
        Adjusted input ref
      • extraSelectItems

        protected void extraSelectItems​(SqlToRelConverter.Blackboard bb,
                                        SqlSelect select,
                                        List<RexNode> exprList,
                                        List<String> nameList,
                                        Collection<String> aliasList,
                                        List<SqlMonotonicity> columnMonotonicityList)
        Adds extra select items. The default implementation adds nothing; derived classes may add columns to exprList, nameList, aliasList and columnMonotonicityList.
        bb - Blackboard
        select - Select statement being translated
        exprList - List of expressions in select clause
        nameList - List of names, one per column
        aliasList - Collection of aliases that have been used already
        columnMonotonicityList - List of monotonicity, one per column
      • convertWith

        public RelRoot convertWith​(SqlWith with,
                                   boolean top)
        Converts a WITH sub-query into a relational expression.
      • convertValues

        public RelNode convertValues​(SqlCall values,
                                     RelDataType targetRowType)
        Converts a SELECT statement's parse tree into a relational expression.