org.h2.command.query

## Class Query

- java.lang.Object
- - org.h2.command.Prepared
  - - org.h2.command.query.Query

Direct Known Subclasses:
  Select, SelectUnion, TableValueConstructor

    public abstract class Query
    extends Prepared

Represents a SELECT statement (simple, or union).

### Field Summary

### Fields inherited from class org.h2.command.Prepared

`create, parameters, prepareAlways, session, sqlStatement, sqlTokens`

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`abstract void` `addGlobalCondition(Parameter param, int columnId, int comparisonType)` Add a condition to the query.
`abstract boolean` `allowGlobalConditions()` Check whether adding condition to the query is allowed.
`void` `collectDependencies(java.util.HashSet<DbObject> dependencies)` Find and collect all DbObjects, this Prepared depends on.
`void` `disableCache()` Disable caching of result sets.
`boolean` `exists()` Execute the EXISTS predicate over the query.
`abstract void` `fireBeforeSelectTriggers()` Call the before triggers on all tables.
`int` `getColumnCount()` Get the column count of this query.
`abstract double` `getCost()` Calculate the cost to execute this query.
`int` `getCostAsExpression()` Calculate the cost when used as a subquery.
`java.util.ArrayList<Expression>` `getExpressions()` The the list of select expressions.
`Expression` `getFetch()`
`Expression` `getIfSingleRow()` If this query is determined as a single-row query, returns a replacement expression.
`long` `getMaxDataModificationId()`
`Expression` `getOffset()`
`TypeInfo` `getRowDataType()` Returns data type of rows.
`abstract java.util.HashSet<Table>` `getTables()` Get all tables that are involved in this query.
`int` `getType()` Get the command type as defined in CommandInterface
`boolean` `hasOrder()` Whether the query has an order.
`abstract void` `init()` Initialize the query.
`boolean` `isAnyDistinct()`
`boolean` `isConstantQuery()` Check if this query will always return the same value and has no side effects.
`abstract boolean` `isEverything(ExpressionVisitor visitor)` Check if this expression and all sub-expressions can fulfill a criteria.
`boolean` `isFetchPercent()`
`boolean` `isNeverLazy()`
`boolean` `isQuery()` Check if this object is a query.
`boolean` `isRandomAccessResult()` Returns whether results support random access.
`boolean` `isReadOnly()` Check if this command is read only.
`boolean` `isStandardDistinct()`
`boolean` `isTransactional()` Check if this command is transactional.
`abstract boolean` `isUnion()` Check if this is a UNION query.
`boolean` `isWithTies()`
`abstract void` `mapColumns(ColumnResolver resolver, int level)` Map the columns to the given column resolver.
`void` `prepare()` Prepare this statement.
`abstract void` `prepareExpressions()`
`abstract void` `preparePlan()`
`ResultInterface` `query(long maxrows)` Execute the query.
`ResultInterface` `query(long limit, ResultTarget target)` Execute the query, writing the result to the target result.
`ResultInterface` `queryMeta()` Get an empty result set containing the meta data.
`protected abstract ResultInterface` `queryWithoutCache(long limit, ResultTarget target)` Execute the query without checking the cache.
`void` `setDistinctIfPossible()` Set the distinct flag only if it is possible, may be used as a possible optimization only.
`abstract void` `setEvaluatable(TableFilter tableFilter, boolean b)` Change the evaluatable flag.
`void` `setFetch(Expression fetch)`
`void` `setFetchPercent(boolean fetchPercent)`
`abstract void` `setForUpdate(boolean forUpdate)` Set the 'for update' flag.
`void` `setNeverLazy(boolean b)`
`void` `setOffset(Expression offset)`
`void` `setOrder(java.util.ArrayList<QueryOrderBy> order)` Set the order by list.
`void` `setRandomAccessResult(boolean b)` Whether results need to support random access.
`void` `setWithTies(boolean withTies)`
`Table` `toTable(java.lang.String alias, Column[] columnTemplates, java.util.ArrayList<Parameter> parameters, boolean forCreateView, Query topQuery)` Converts this query to a table or a view.
`abstract void` `updateAggregate(SessionLocal s, int stage)` Update all aggregate function values.

### Methods inherited from class org.h2.command.Prepared

`checkCanceled, checkParameters, getCteCleanups, getCurrentRowNumber, getObjectId, getParameters, getPersistedObjectId, getPlanSQL, getSession, getSimpleSQL, getSQL, getSQLTokens, isCacheable, isWithParamValues, needRecompile, setCommand, setCteCleanups, setCurrentRowNumber, setParameterList, setPersistedObjectId, setPrepareAlways, setRow, setSession, setSQL, setWithParamValues, toString, update`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Method Detail

#### setNeverLazy

    public void setNeverLazy(boolean b)

#### isNeverLazy

    public boolean isNeverLazy()

#### isUnion

    public abstract boolean isUnion()

Check if this is a UNION query.

Returns:
  `true` if this is a UNION query

#### 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 abstract ResultInterface queryWithoutCache(long limit,
                                                         ResultTarget target)

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.

Parameters:
  `limit` - the limit as specified in the JDBC method call
  `target` - the target to write results to
Returns:
  the result

#### init

    public abstract void init()

Initialize the query.

#### prepare

    public final void prepare()

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

Overrides:
  `prepare` in class `Prepared`

#### prepareExpressions

    public abstract void prepareExpressions()

#### preparePlan

    public abstract void preparePlan()

#### getExpressions

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

The the list of select expressions. This may include invisible expressions such as order by expressions.

Returns:
  the list of expressions

#### getCost

    public abstract double getCost()

Calculate the cost to execute this query.

Returns:
  the cost

#### getCostAsExpression

    public int getCostAsExpression()

Calculate the cost when used as a subquery. This method returns a value between 10 and 1000000, to ensure adding other values can't result in an integer overflow.

Returns:
  the estimated cost as an integer

#### getTables

    public abstract java.util.HashSet<Table> getTables()

Get all tables that are involved in this query.

Returns:
  the set of tables

#### setOrder

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

Set the order by list.

Parameters:
  `order` - the order by list

#### hasOrder

    public boolean hasOrder()

Whether the query has an order.

Returns:
  true if it has

#### setForUpdate

    public abstract void setForUpdate(boolean forUpdate)

Set the 'for update' flag.

Parameters:
  `forUpdate` - the new setting

#### getColumnCount

    public int getColumnCount()

Get the column count of this query.

Returns:
  the column count

#### getRowDataType

    public TypeInfo getRowDataType()

Returns data type of rows.

Returns:
  data type of rows

#### mapColumns

    public abstract void mapColumns(ColumnResolver resolver,
                                    int level)

Map the columns to the given column resolver.

Parameters:
  `resolver` - the resolver
  `level` - the subquery level (0 is the top level query, 1 is the first subquery level)

#### setEvaluatable

    public abstract void setEvaluatable(TableFilter tableFilter,
                                        boolean b)

Change the evaluatable flag. This is used when building the execution plan.

Parameters:
  `tableFilter` - the table filter
  `b` - the new value

#### addGlobalCondition

    public abstract void addGlobalCondition(Parameter param,
                                            int columnId,
                                            int comparisonType)

Add a condition to the query. This is used for views.

Parameters:
  `param` - the parameter
  `columnId` - the column index (0 meaning the first column)
  `comparisonType` - the comparison type

#### allowGlobalConditions

    public abstract boolean allowGlobalConditions()

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.

Returns:
  true if adding global conditions is allowed

#### isEverything

    public abstract boolean isEverything(ExpressionVisitor visitor)

Check if this expression and all sub-expressions can fulfill a criteria. If any part returns false, the result is false.

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

#### updateAggregate

    public abstract void updateAggregate(SessionLocal s,
                                         int stage)

Update all aggregate function values.

Parameters:
  `s` - the session
  `stage` - select stage

#### fireBeforeSelectTriggers

    public abstract void fireBeforeSelectTriggers()

Call the before triggers on all tables.

#### setDistinctIfPossible

    public void setDistinctIfPossible()

Set the distinct flag only if it is possible, may be used as a possible optimization only.

#### isStandardDistinct

    public boolean isStandardDistinct()

Returns:
  whether this query is a plain `DISTINCT` query

#### isAnyDistinct

    public boolean isAnyDistinct()

Returns:
  whether this query is a `DISTINCT` or `DISTINCT ON (...)` query

#### isRandomAccessResult

    public boolean isRandomAccessResult()

Returns whether results support random access.

Returns:
  whether results support random access

#### setRandomAccessResult

    public void setRandomAccessResult(boolean b)

Whether results need to support random access.

Parameters:
  `b` - the new value

#### isQuery

    public boolean isQuery()

Description copied from class: `Prepared`
Check if this object is a query.

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

#### isTransactional

    public boolean isTransactional()

Description copied from class: `Prepared`
Check if this command is transactional. If it is not, then it forces the current transaction to commit.

Specified by:
  `isTransactional` in class `Prepared`
Returns:
  true if it is

#### disableCache

    public void disableCache()

Disable caching of result sets.

#### query

    public final ResultInterface query(long maxrows)

Description copied from class: `Prepared`
Execute the query.

Overrides:
  `query` in class `Prepared`
Parameters:
  `maxrows` - the maximum number of rows to return
Returns:
  the result set

#### query

    public final ResultInterface query(long limit,
                                       ResultTarget target)

Execute the query, writing the result to the target result.

Parameters:
  `limit` - the maximum number of rows to return
  `target` - the target result (null will return the result)
Returns:
  the result set (if the target is not set).

#### exists

    public final boolean exists()

Execute the EXISTS predicate over the query.

Returns:
  EXISTS predicate result

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

#### setOffset

    public void setOffset(Expression offset)

#### getOffset

    public Expression getOffset()

#### setFetch

    public void setFetch(Expression fetch)

#### getFetch

    public Expression getFetch()

#### setFetchPercent

    public void setFetchPercent(boolean fetchPercent)

#### isFetchPercent

    public boolean isFetchPercent()

#### setWithTies

    public void setWithTies(boolean withTies)

#### isWithTies

    public boolean isWithTies()

#### getMaxDataModificationId

    public final long getMaxDataModificationId()

#### toTable

    public Table toTable(java.lang.String alias,
                         Column[] columnTemplates,
                         java.util.ArrayList<Parameter> parameters,
                         boolean forCreateView,
                         Query topQuery)

Converts this query to a table or a view.

Parameters:
  `alias` - alias name for the view
  `columnTemplates` - column templates, or `null`
  `parameters` - the parameters
  `forCreateView` - if true, a system session will be used for the view
  `topQuery` - the top level query
Returns:
  the table or the view

#### collectDependencies

    public void collectDependencies(java.util.HashSet<DbObject> dependencies)

Description copied from class: `Prepared`
Find and collect all DbObjects, this Prepared depends on.

Overrides:
  `collectDependencies` in class `Prepared`
Parameters:
  `dependencies` - collection of dependencies to populate

#### isConstantQuery

    public boolean isConstantQuery()

Check if this query will always return the same value and has no side effects.

Returns:
  if this query will always return the same value and has no side effects.

#### getIfSingleRow

    public Expression getIfSingleRow()

If this query is determined as a single-row query, returns a replacement expression.

Returns:
  the expression, or `null`