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 Details

    • topTableFilter

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

      private final ArrayList<TableFilter> filters
    • topFilters

      private final 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 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 HashMap<String,Window> windows
  • Constructor Details

  • Method Details

    • 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 ArrayList<TableFilter> getTopFilters()
    • setExpressions

      public void setExpressions(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(ArrayList<Expression> group)
    • getGroupBy

      public 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(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(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
    • getCondition

      public Expression getCondition()
    • 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)
    • createLocalResult

      private LocalResult createLocalResult(LocalResult old)
    • expandColumnList

      private void expandColumnList()
    • expandColumnList

      private int expandColumnList(TableFilter filter, int index, boolean forAlias, HashMap<Column,ExpressionColumn> except)
    • addExpandedColumn

      private int addExpandedColumn(TableFilter filter, int index, HashMap<Column,ExpressionColumn> except, String schema, 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, ArrayList<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 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 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(StringBuilder builder, int sqlFlags, TableFilter f, boolean isJoin)
    • getFilterSQL

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

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

      private static boolean containsAggregate(Expression expression)
    • setHaving

      public void setHaving(Expression having)
    • getHaving

      public Expression getHaving()
    • setQualify

      public void setQualify(Expression qualify)
    • getQualify

      public Expression getQualify()
    • 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
    • addGlobalCondition

      private static Expression addGlobalCondition(Expression condition, Expression additional)
    • 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
    • isCacheable

      public boolean isCacheable()
      Overrides:
      isCacheable in class Prepared
    • 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()