## org.h2.command.dml
Class Select

    java.lang.Object
      org.h2.command.Prepared
          org.h2.command.dml.Query
              org.h2.command.dml.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 Summary

Fields inherited from class org.h2.command.dml.Query
`distinct, limitExpr, offsetExpr, randomAccessResult, sampleSize`

Fields inherited from class org.h2.command.Prepared
`create, parameters, prepareAlways, session, sqlStatement`

Constructor Summary
`Select(Session session)`

Method Summary
`void` `addCondition(Expression cond)` Add a condition to the list of conditions.
`void` `addGlobalCondition(Parameter param, int columnId, int comparisonType)` Add a condition to the query.
`void` `addTableFilter(TableFilter filter, boolean isTop)` Add a table to the query.
`boolean` `allowGlobalConditions()` Check whether adding condition to the query is allowed.
`void` `fireBeforeSelectTriggers()` Call the before triggers on all tables.
`int` `getColumnCount()` Get the column count of this query.
`double` `getCost()` Calculate the cost to execute this query.
`java.util.HashMap<Expression,java.lang.Object>` `getCurrentGroup()`
`int` `getCurrentGroupRowId()`
`java.util.ArrayList<Expression>` `getExpressions()` The the list of select expressions.
`java.util.ArrayList<Expression>` `getGroupBy()`
`Expression` `getHaving()`
`java.lang.String` `getPlanSQL()` Get the SQL statement with the execution plan.
`SortOrder` `getSortOrder()`
`java.util.HashSet<Table>` `getTables()` Get all tables that are involved in this query.
`java.util.ArrayList<TableFilter>` `getTopFilters()`
`TableFilter` `getTopTableFilter()`
`int` `getType()` Get the command type as defined in CommandInterface
`void` `init()` Initialize the query.
`boolean` `isCacheable()`
`boolean` `isEverything(ExpressionVisitor visitor)` Check if this expression and all sub-expressions can fulfill a criteria.
`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.
`boolean` `isReadOnly()` Check if this command is read only.
`void` `mapColumns(ColumnResolver resolver, int level)` Map the columns to the given column resolver.
`void` `prepare()` Prepare this statement.
`ResultInterface` `queryMeta()` Get an empty result set containing the meta data.
`protected LocalResult` `queryWithoutCache(int maxRows, ResultTarget target)` Execute the query without checking the cache.
`void` `setEvaluatable(TableFilter tableFilter, boolean b)` Change the evaluatable flag.
`void` `setExpressions(java.util.ArrayList<Expression> expressions)`
`void` `setForUpdate(boolean b)` Set the 'for update' flag.
`void` `setGroupBy(java.util.ArrayList<Expression> group)`
`void` `setGroupQuery()` Called if this query contains aggregate functions.
`void` `setHaving(Expression having)`
`void` `setOrder(java.util.ArrayList<SelectOrderBy> order)` Set the order by list.
`void` `updateAggregate(Session s)` Update all aggregate function values.

Methods inherited from class org.h2.command.dml.Query
`disableCache, getCostAsExpression, getLimit, getMaxDataModificationId, getOffset, getParameterValues, isDistinct, isQuery, isTransactional, prepareOrder, query, setDistinct, setLimit, setOffset, setRandomAccessResult, setSampleSize`

Methods inherited from class org.h2.command.Prepared
`checkCanceled, checkParameters, getCurrentObjectId, getCurrentRowNumber, getObjectId, getParameters, getSQL, getSQL, getSQL, needRecompile, setCommand, setCurrentRowNumber, setObjectId, setParameterList, setPrepareAlways, setRow, setSession, setSQL, toString, update`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### Select

    public Select(Session session)

Method Detail

### 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)

### setGroupQuery

    public void setGroupQuery()

  Called if this query contains aggregate functions.

### setGroupBy

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

### getGroupBy

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

### getCurrentGroup

    public java.util.HashMap<Expression,java.lang.Object> getCurrentGroup()

### getCurrentGroupRowId

    public int getCurrentGroupRowId()

### setOrder

    public void setOrder(java.util.ArrayList<SelectOrderBy> order)

  Description copied from class: `Query`
  Set the order by list.

  Specified by:
    `setOrder` in class `Query`
  Parameters:
    `order` - the order by list

### addCondition

    public void addCondition(Expression cond)

  Add a condition to the list of conditions.

  Parameters:
    `cond` - the condition to add

### queryMeta

    public ResultInterface queryMeta()

  Description copied from class: `Prepared`
  Get an empty result set containing the meta data.

  Specified by:
    `queryMeta` in class `Prepared`
  Returns:
    the result set

### queryWithoutCache

    protected LocalResult queryWithoutCache(int 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

### init

    public void init()

  Description copied from class: `Query`
  Initialize the query.

  Specified by:
    `init` in class `Query`

### prepare

    public void prepare()

  Description copied from class: `Prepared`
  Prepare this statement.

  Overrides:
    `prepare` in class `Prepared`

### 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`

### getPlanSQL

    public java.lang.String getPlanSQL()

  Description copied from class: `Prepared`
  Get the SQL statement with the execution plan.

  Overrides:
    `getPlanSQL` in class `Prepared`
  Returns:
    the execution plan

### setHaving

    public void setHaving(Expression having)

### getHaving

    public Expression getHaving()

### getColumnCount

    public int getColumnCount()

  Description copied from class: `Query`
  Get the column count of this query.

  Specified by:
    `getColumnCount` in class `Query`
  Returns:
    the column count

### getTopTableFilter

    public TableFilter getTopTableFilter()

### getExpressions

    public java.util.ArrayList<Expression> getExpressions()

  Description copied from class: `Query`
  The the list of select expressions. This may include invisible expressions such as order by expressions.

  Specified by:
    `getExpressions` in class `Query`
  Returns:
    the list of expressions

### 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

### 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(Session s)

  Description copied from class: `Query`
  Update all aggregate function values.

  Specified by:
    `updateAggregate` in class `Query`
  Parameters:
    `s` - the session

### 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

### isReadOnly

    public boolean isReadOnly()

  Description copied from class: `Prepared`
  Check if this command is read only.

  Overrides:
    `isReadOnly` in class `Prepared`
  Returns:
    true if it is

### isCacheable

    public boolean isCacheable()

  Overrides:
    `isCacheable` in class `Prepared`

### getType

    public int getType()

  Description copied from class: `Prepared`
  Get the command type as defined in CommandInterface

  Specified by:
    `getType` in class `Prepared`
  Returns:
    the statement type

### 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()