Class Select


  • public class Select
    extends Query
    This class represents a simple SELECT statement. For each select statement, visibleColumnCount <= distinctColumnCount <= expressionCount. The expression list count could include ORDER BY and GROUP BY expressions that are not in the select list. The call sequence is init(), mapColumns() if it's a subquery, prepare().
    • Field Detail

      • topTableFilter

        TableFilter topTableFilter
        The main (top) table filter.
      • filters

        private final java.util.ArrayList<TableFilter> filters
      • topFilters

        private final java.util.ArrayList<TableFilter> topFilters
      • parentSelect

        private Select parentSelect
        Parent select for selects in table filters.
      • condition

        private Expression condition
        WHERE condition.
      • having

        private Expression having
        HAVING condition.
      • qualify

        private Expression qualify
        QUALIFY condition.
      • distinctExpressions

        private Expression[] distinctExpressions
        DISTINCT ON(...) expressions.
      • distinctIndexes

        private int[] distinctIndexes
      • group

        private java.util.ArrayList<Expression> group
      • groupIndex

        int[] groupIndex
        The indexes of the group-by columns.
      • groupByExpression

        boolean[] groupByExpression
        Whether a column in the expression list is part of a group-by.
      • groupData

        SelectGroups groupData
        Grouped data for aggregates.
      • havingIndex

        private int havingIndex
      • qualifyIndex

        private int qualifyIndex
      • groupByCopies

        private int[] groupByCopies
      • isExplicitTable

        private boolean isExplicitTable
        Whether this SELECT is an explicit table (TABLE tableName). It is used in getPlanSQL(int) to generate SQL similar to original query.
      • isGroupQuery

        boolean isGroupQuery
        This flag is set when SELECT statement contains (non-window) aggregate functions, GROUP BY clause or HAVING clause.
      • isGroupSortedQuery

        private boolean isGroupSortedQuery
      • isWindowQuery

        private boolean isWindowQuery
      • isForUpdate

        private boolean isForUpdate
      • cost

        private double cost
      • isQuickAggregateQuery

        private boolean isQuickAggregateQuery
      • isDistinctQuery

        private boolean isDistinctQuery
      • sortUsingIndex

        private boolean sortUsingIndex
      • isGroupWindowStage2

        private boolean isGroupWindowStage2
      • windows

        private java.util.HashMap<java.lang.String,​Window> windows
    • Method Detail

      • isUnion

        public boolean isUnion()
        Description copied from class: Query
        Check if this is a UNION query.
        Specified by:
        isUnion in class Query
        Returns:
        true if this is a UNION query
      • addTableFilter

        public void addTableFilter​(TableFilter filter,
                                   boolean isTop)
        Add a table to the query.
        Parameters:
        filter - the table to add
        isTop - if the table can be the first table in the query plan
      • getTopFilters

        public java.util.ArrayList<TableFilter> getTopFilters()
      • setExpressions

        public void setExpressions​(java.util.ArrayList<Expression> expressions)
      • setExplicitTable

        public void setExplicitTable()
        Convert this SELECT to an explicit table (TABLE tableName).
      • setWildcard

        public void setWildcard()
        Sets a wildcard expression as in "SELECT * FROM TEST".
      • setGroupQuery

        public void setGroupQuery()
        Set when SELECT statement contains (non-window) aggregate functions, GROUP BY clause or HAVING clause.
      • setWindowQuery

        public void setWindowQuery()
        Called if this query contains window functions.
      • setGroupBy

        public void setGroupBy​(java.util.ArrayList<Expression> group)
      • getGroupBy

        public java.util.ArrayList<Expression> getGroupBy()
      • getGroupDataIfCurrent

        public SelectGroups getGroupDataIfCurrent​(boolean window)
        Get the group data if there is currently a group-by active.
        Parameters:
        window - is this a window function
        Returns:
        the grouped data
      • setDistinct

        public void setDistinct()
        Set the distinct flag.
      • setDistinct

        public void setDistinct​(Expression[] distinctExpressions)
        Set the DISTINCT ON expressions.
        Parameters:
        distinctExpressions - array of expressions
      • isAnyDistinct

        public boolean isAnyDistinct()
        Overrides:
        isAnyDistinct in class Query
        Returns:
        whether this query is a DISTINCT or DISTINCT ON (...) query
      • addWindow

        public boolean addWindow​(java.lang.String name,
                                 Window window)
        Adds a named window definition.
        Parameters:
        name - name
        window - window definition
        Returns:
        true if a new definition was added, false if old definition was replaced
      • getWindow

        public Window getWindow​(java.lang.String name)
        Returns a window with specified name, or null.
        Parameters:
        name - name of the window
        Returns:
        the window with specified name, or null
      • addCondition

        public void addCondition​(Expression cond)
        Add a condition to the list of conditions.
        Parameters:
        cond - the condition to add
      • queryGroupSorted

        private LazyResult queryGroupSorted​(int columnCount,
                                            ResultTarget result,
                                            long offset,
                                            boolean quickOffset)
      • createGroupSortedRow

        Value[] createGroupSortedRow​(Value[] keyValues,
                                     int columnCount)
        Create a row with the current values, for queries with group-sort.
        Parameters:
        keyValues - the key values
        columnCount - the number of columns
        Returns:
        the row
      • rowForResult

        private Value[] rowForResult​(Value[] row,
                                     int columnCount)
        Removes HAVING and QUALIFY columns from the row.
        Parameters:
        row - the complete row
        columnCount - the number of columns to keep
        Returns:
        the same or the truncated row
      • isHavingNullOrFalse

        private boolean isHavingNullOrFalse​(Value[] row)
      • getGroupSortedIndex

        private Index getGroupSortedIndex()
      • isGroupSortedIndex

        private boolean isGroupSortedIndex​(TableFilter tableFilter,
                                           Index index)
      • isConditionMetForUpdate

        boolean isConditionMetForUpdate()
      • isConditionMet

        boolean isConditionMet()
      • queryWindow

        private void queryWindow​(int columnCount,
                                 LocalResult result,
                                 long offset,
                                 boolean quickOffset)
      • queryGroupWindow

        private void queryGroupWindow​(int columnCount,
                                      LocalResult result,
                                      long offset,
                                      boolean quickOffset)
      • queryGroup

        private void queryGroup​(int columnCount,
                                LocalResult result,
                                long offset,
                                boolean quickOffset)
      • initGroupData

        private void initGroupData​(int columnCount)
      • setGroupData

        void setGroupData​(SelectGroups groupData)
      • gatherGroup

        private void gatherGroup​(int columnCount,
                                 int stage)
      • updateAgg

        void updateAgg​(int columnCount,
                       int stage)
        Update any aggregate expressions with the query stage.
        Parameters:
        columnCount - number of columns
        stage - see STAGE_RESET/STAGE_GROUP/STAGE_WINDOW in DataAnalysisOperation
      • processGroupResult

        private void processGroupResult​(int columnCount,
                                        LocalResult result,
                                        long offset,
                                        boolean quickOffset,
                                        boolean withHaving)
      • constructGroupResultRow

        private Value[] constructGroupResultRow​(Value[] keyValues,
                                                int columnCount)
      • getSortIndex

        private Index getSortIndex()
        Get the index that matches the ORDER BY list, if one exists. This is to avoid running a separate ORDER BY if an index can be used. This is specially important for large result sets, if only the first few rows are important (LIMIT is used)
        Returns:
        the index if one is found
      • queryDistinct

        private void queryDistinct​(ResultTarget result,
                                   long offset,
                                   long limitRows,
                                   boolean withTies,
                                   boolean quickOffset)
      • queryFlat

        private LazyResult queryFlat​(int columnCount,
                                     ResultTarget result,
                                     long offset,
                                     long limitRows,
                                     boolean withTies,
                                     boolean quickOffset)
      • skipOffset

        private static void skipOffset​(Select.LazyResultSelect lazyResult,
                                       long offset,
                                       boolean quickOffset)
      • queryQuick

        private void queryQuick​(int columnCount,
                                ResultTarget result,
                                boolean skipResult)
      • queryWithoutCache

        protected ResultInterface queryWithoutCache​(long maxRows,
                                                    ResultTarget target)
        Description copied from class: Query
        Execute the query without checking the cache. If a target is specified, the results are written to it, and the method returns null. If no target is specified, a new LocalResult is created and returned.
        Specified by:
        queryWithoutCache in class Query
        Parameters:
        maxRows - the limit as specified in the JDBC method call
        target - the target to write results to
        Returns:
        the result
      • disableLazyForJoinSubqueries

        private void disableLazyForJoinSubqueries​(TableFilter top)
      • expandColumnList

        private void expandColumnList()
      • addExpandedColumn

        private int addExpandedColumn​(TableFilter filter,
                                      int index,
                                      java.util.HashMap<Column,​ExpressionColumn> except,
                                      java.lang.String schema,
                                      java.lang.String alias,
                                      Column c)
      • init

        public void init()
        Description copied from class: Query
        Initialize the query.
        Specified by:
        init in class Query
      • mapCondition

        private void mapCondition​(int index)
      • mergeGroupByExpressions

        private int mergeGroupByExpressions​(Database db,
                                            int index,
                                            java.util.ArrayList<java.lang.String> expressionSQL,
                                            boolean scanPrevious)
      • prepare

        public void prepare()
        Description copied from class: Prepared
        Prepare this statement.
        Overrides:
        prepare in class Prepared
      • optimizeExpressionsAndPreserveAliases

        private void optimizeExpressionsAndPreserveAliases()
      • getCost

        public double getCost()
        Description copied from class: Query
        Calculate the cost to execute this query.
        Specified by:
        getCost in class Query
        Returns:
        the cost
      • getTables

        public java.util.HashSet<Table> getTables()
        Description copied from class: Query
        Get all tables that are involved in this query.
        Specified by:
        getTables in class Query
        Returns:
        the set of tables
      • fireBeforeSelectTriggers

        public void fireBeforeSelectTriggers()
        Description copied from class: Query
        Call the before triggers on all tables.
        Specified by:
        fireBeforeSelectTriggers in class Query
      • preparePlan

        private double preparePlan​(boolean parse)
      • setEvaluatableRecursive

        private void setEvaluatableRecursive​(TableFilter f)
      • getPlanSQL

        public java.lang.String getPlanSQL​(int sqlFlags)
        Description copied from class: Prepared
        Get the SQL statement with the execution plan.
        Overrides:
        getPlanSQL in class Prepared
        Parameters:
        sqlFlags - formatting flags
        Returns:
        the execution plan
      • getPlanFromFilter

        private static boolean getPlanFromFilter​(java.lang.StringBuilder builder,
                                                 int sqlFlags,
                                                 TableFilter f,
                                                 boolean isJoin)
      • getFilterSQL

        private static void getFilterSQL​(java.lang.StringBuilder builder,
                                         java.lang.String sql,
                                         Expression[] exprList,
                                         Expression condition,
                                         int conditionIndex,
                                         int sqlFlags)
      • getFilterSQL

        private static void getFilterSQL​(java.lang.StringBuilder builder,
                                         java.lang.String sql,
                                         Expression condition,
                                         int sqlFlags)
      • containsAggregate

        private static boolean containsAggregate​(Expression expression)
      • setHaving

        public void setHaving​(Expression having)
      • setQualify

        public void setQualify​(Expression qualify)
      • getTopTableFilter

        public TableFilter getTopTableFilter()
      • setForUpdate

        public void setForUpdate​(boolean b)
        Description copied from class: Query
        Set the 'for update' flag.
        Specified by:
        setForUpdate in class Query
        Parameters:
        b - the new setting
      • mapColumns

        public void mapColumns​(ColumnResolver resolver,
                               int level)
        Description copied from class: Query
        Map the columns to the given column resolver.
        Specified by:
        mapColumns in class Query
        Parameters:
        resolver - the resolver
        level - the subquery level (0 is the top level query, 1 is the first subquery level)
      • setEvaluatable

        public void setEvaluatable​(TableFilter tableFilter,
                                   boolean b)
        Description copied from class: Query
        Change the evaluatable flag. This is used when building the execution plan.
        Specified by:
        setEvaluatable in class Query
        Parameters:
        tableFilter - the table filter
        b - the new value
      • isQuickAggregateQuery

        public boolean isQuickAggregateQuery()
        Check if this is an aggregate query with direct lookup, for example a query of the type SELECT COUNT(*) FROM TEST or SELECT MAX(ID) FROM TEST.
        Returns:
        true if a direct lookup is possible
      • isGroupQuery

        public boolean isGroupQuery()
        Checks if this query is a group query.
        Returns:
        whether this query is a group query.
      • isWindowQuery

        public boolean isWindowQuery()
        Checks if this query contains window functions.
        Returns:
        whether this query contains window functions
      • isGroupWindowStage2

        public boolean isGroupWindowStage2()
        Checks if window stage of group window query is performed. If true, column resolver may not be used.
        Returns:
        true if window stage of group window query is performed
      • addGlobalCondition

        public void addGlobalCondition​(Parameter param,
                                       int columnId,
                                       int comparisonType)
        Description copied from class: Query
        Add a condition to the query. This is used for views.
        Specified by:
        addGlobalCondition in class Query
        Parameters:
        param - the parameter
        columnId - the column index (0 meaning the first column)
        comparisonType - the comparison type
      • updateAggregate

        public void updateAggregate​(SessionLocal s,
                                    int stage)
        Description copied from class: Query
        Update all aggregate function values.
        Specified by:
        updateAggregate in class Query
        Parameters:
        s - the session
        stage - select stage
      • isEverything

        public boolean isEverything​(ExpressionVisitor visitor)
        Description copied from class: Query
        Check if this expression and all sub-expressions can fulfill a criteria. If any part returns false, the result is false.
        Specified by:
        isEverything in class Query
        Parameters:
        visitor - the visitor
        Returns:
        if the criteria can be fulfilled
      • allowGlobalConditions

        public boolean allowGlobalConditions()
        Description copied from class: Query
        Check whether adding condition to the query is allowed. This is not allowed for views that have an order by and a limit, as it would affect the returned results.
        Specified by:
        allowGlobalConditions in class Query
        Returns:
        true if adding global conditions is allowed
      • getSortOrder

        public SortOrder getSortOrder()
      • getParentSelect

        public Select getParentSelect()
        Returns parent select, or null.
        Returns:
        parent select, or null
      • isConstantQuery

        public boolean isConstantQuery()
        Description copied from class: Query
        Check if this query will always return the same value and has no side effects.
        Overrides:
        isConstantQuery in class Query
        Returns:
        if this query will always return the same value and has no side effects.
      • getIfSingleRow

        public Expression getIfSingleRow()
        Description copied from class: Query
        If this query is determined as a single-row query, returns a replacement expression.
        Overrides:
        getIfSingleRow in class Query
        Returns:
        the expression, or null
      • isNoFromClause

        private boolean isNoFromClause()