java.lang.Object
- org.h2.command.Prepared
- - org.h2.command.query.Query
  - - org.h2.command.query.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().

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private class`	`Select.LazyResultGroupSorted`	Lazy execution for a group sorted query.
`private class`	`Select.LazyResultQueryFlat`	Lazy execution for a flat query.
`private class`	`Select.LazyResultSelect`	Lazy execution for this select.

Nested classes/interfaces inherited from class org.h2.command.query.Query
Query.OffsetFetch

Field Summary

Fields
Modifier and Type	Field	Description
`private Expression`	`condition`	WHERE condition.
`private double`	`cost`
`private Expression[]`	`distinctExpressions`	`DISTINCT ON(...)` expressions.
`private int[]`	`distinctIndexes`
`private java.util.ArrayList<TableFilter>`	`filters`
`private java.util.ArrayList<Expression>`	`group`
`private int[]`	`groupByCopies`
`(package private) boolean[]`	`groupByExpression`	Whether a column in the expression list is part of a group-by.
`(package private) SelectGroups`	`groupData`	Grouped data for aggregates.
`(package private) int[]`	`groupIndex`	The indexes of the group-by columns.
`private Expression`	`having`	HAVING condition.
`private int`	`havingIndex`
`private boolean`	`isDistinctQuery`
`private boolean`	`isExplicitTable`	Whether this SELECT is an explicit table (TABLE tableName).
`private boolean`	`isForUpdate`
`(package private) boolean`	`isGroupQuery`	This flag is set when SELECT statement contains (non-window) aggregate functions, GROUP BY clause or HAVING clause.
`private boolean`	`isGroupSortedQuery`
`private boolean`	`isGroupWindowStage2`
`private boolean`	`isQuickAggregateQuery`
`private boolean`	`isWindowQuery`
`private Select`	`parentSelect`	Parent select for selects in table filters.
`private Expression`	`qualify`	QUALIFY condition.
`private int`	`qualifyIndex`
`private boolean`	`sortUsingIndex`
`private java.util.ArrayList<TableFilter>`	`topFilters`
`(package private) TableFilter`	`topTableFilter`	The main (top) table filter.
`private java.util.HashMap<java.lang.String,Window>`	`windows`

Fields inherited from class org.h2.command.query.Query
checkInit, distinct, expressionArray, expressions, fetchExpr, fetchPercent, isPrepared, offsetExpr, orderList, randomAccessResult, resultColumnCount, sort, visibleColumnCount, withTies

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

Constructor Summary

Constructors
Constructor Description

Select(SessionLocal session, Select parentSelect)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addCondition(Expression cond)`	Add a condition to the list of conditions.
`private int`	`addExpandedColumn(TableFilter filter, int index, java.util.HashMap<Column,ExpressionColumn> except, java.lang.String schema, java.lang.String alias, Column c)`
`private static Expression`	`addGlobalCondition(Expression condition, Expression additional)`
`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`	`addWindow(java.lang.String name, Window window)`	Adds a named window definition.
`boolean`	`allowGlobalConditions()`	Check whether adding condition to the query is allowed.
`private Value[]`	`constructGroupResultRow(Value[] keyValues, int columnCount)`
`private static boolean`	`containsAggregate(Expression expression)`
`(package private) Value[]`	`createGroupSortedRow(Value[] keyValues, int columnCount)`	Create a row with the current values, for queries with group-sort.
`private LocalResult`	`createLocalResult(LocalResult old)`
`private void`	`disableLazyForJoinSubqueries(TableFilter top)`
`private void`	`expandColumnList()`
`private int`	`expandColumnList(TableFilter filter, int index, boolean forAlias, java.util.HashMap<Column,ExpressionColumn> except)`
`void`	`fireBeforeSelectTriggers()`	Call the before triggers on all tables.
`private void`	`gatherGroup(int columnCount, int stage)`
`Expression`	`getCondition()`
`double`	`getCost()`	Calculate the cost to execute this query.
`private static void`	`getFilterSQL(java.lang.StringBuilder builder, java.lang.String sql, Expression[] exprList, Expression condition, int conditionIndex, int sqlFlags)`
`private static void`	`getFilterSQL(java.lang.StringBuilder builder, java.lang.String sql, Expression condition, int sqlFlags)`
`java.util.ArrayList<Expression>`	`getGroupBy()`
`SelectGroups`	`getGroupDataIfCurrent(boolean window)`	Get the group data if there is currently a group-by active.
`private Index`	`getGroupSortedIndex()`
`Expression`	`getHaving()`
`Expression`	`getIfSingleRow()`	If this query is determined as a single-row query, returns a replacement expression.
`Select`	`getParentSelect()`	Returns parent select, or null.
`private static boolean`	`getPlanFromFilter(java.lang.StringBuilder builder, int sqlFlags, TableFilter f, boolean isJoin)`
`java.lang.String`	`getPlanSQL(int sqlFlags)`	Get the SQL statement with the execution plan.
`Expression`	`getQualify()`
`private Index`	`getSortIndex()`	Get the index that matches the ORDER BY list, if one exists.
`SortOrder`	`getSortOrder()`
`java.util.HashSet<Table>`	`getTables()`	Get all tables that are involved in this query.
`java.util.ArrayList<TableFilter>`	`getTopFilters()`
`TableFilter`	`getTopTableFilter()`
`Window`	`getWindow(java.lang.String name)`	Returns a window with specified name, or null.
`void`	`init()`	Initialize the query.
`private void`	`initGroupData(int columnCount)`
`boolean`	`isAnyDistinct()`
`boolean`	`isCacheable()`
`(package private) boolean`	`isConditionMet()`
`(package private) boolean`	`isConditionMetForUpdate()`
`boolean`	`isConstantQuery()`	Check if this query will always return the same value and has no side effects.
`boolean`	`isEverything(ExpressionVisitor visitor)`	Check if this expression and all sub-expressions can fulfill a criteria.
`boolean`	`isGroupQuery()`	Checks if this query is a group query.
`private boolean`	`isGroupSortedIndex(TableFilter tableFilter, Index index)`
`boolean`	`isGroupWindowStage2()`	Checks if window stage of group window query is performed.
`private boolean`	`isHavingNullOrFalse(Value[] row)`
`private boolean`	`isNoFromClause()`
`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`	`isUnion()`	Check if this is a UNION query.
`boolean`	`isWindowQuery()`	Checks if this query contains window functions.
`void`	`mapColumns(ColumnResolver resolver, int level)`	Map the columns to the given column resolver.
`private void`	`mapCondition(int index)`
`private int`	`mergeGroupByExpressions(Database db, int index, java.util.ArrayList<java.lang.String> expressionSQL, boolean scanPrevious)`
`private void`	`optimizeExpressionsAndPreserveAliases()`
`void`	`prepare()`	Prepare this statement.
`private double`	`preparePlan(boolean parse)`
`private void`	`processGroupResult(int columnCount, LocalResult result, long offset, boolean quickOffset, boolean withHaving)`
`private void`	`queryDistinct(ResultTarget result, long offset, long limitRows, boolean withTies, boolean quickOffset)`
`private LazyResult`	`queryFlat(int columnCount, ResultTarget result, long offset, long limitRows, boolean withTies, boolean quickOffset)`
`private void`	`queryGroup(int columnCount, LocalResult result, long offset, boolean quickOffset)`
`private LazyResult`	`queryGroupSorted(int columnCount, ResultTarget result, long offset, boolean quickOffset)`
`private void`	`queryGroupWindow(int columnCount, LocalResult result, long offset, boolean quickOffset)`
`private void`	`queryQuick(int columnCount, ResultTarget result, boolean skipResult)`
`private void`	`queryWindow(int columnCount, LocalResult result, long offset, boolean quickOffset)`
`protected ResultInterface`	`queryWithoutCache(long maxRows, ResultTarget target)`	Execute the query without checking the cache.
`private Value[]`	`rowForResult(Value[] row, int columnCount)`	Removes HAVING and QUALIFY columns from the row.
`void`	`setDistinct()`	Set the distinct flag.
`void`	`setDistinct(Expression[] distinctExpressions)`	Set the DISTINCT ON expressions.
`void`	`setEvaluatable(TableFilter tableFilter, boolean b)`	Change the evaluatable flag.
`private void`	`setEvaluatableRecursive(TableFilter f)`
`void`	`setExplicitTable()`	Convert this SELECT to an explicit table (TABLE tableName).
`void`	`setExpressions(java.util.ArrayList<Expression> expressions)`
`void`	`setForUpdate(boolean b)`	Set the 'for update' flag.
`void`	`setGroupBy(java.util.ArrayList<Expression> group)`
`(package private) void`	`setGroupData(SelectGroups groupData)`
`void`	`setGroupQuery()`	Set when SELECT statement contains (non-window) aggregate functions, GROUP BY clause or HAVING clause.
`void`	`setHaving(Expression having)`
`void`	`setQualify(Expression qualify)`
`void`	`setWildcard()`	Sets a wildcard expression as in "SELECT * FROM TEST".
`void`	`setWindowQuery()`	Called if this query contains window functions.
`private static void`	`skipOffset(Select.LazyResultSelect lazyResult, long offset, boolean quickOffset)`
`(package private) void`	`updateAgg(int columnCount, int stage)`	Update any aggregate expressions with the query stage.
`void`	`updateAggregate(SessionLocal s, int stage)`	Update all aggregate function values.

Methods inherited from class org.h2.command.query.Query
addParameter, appendEndOfQueryToSQL, cleanupOrder, collectDependencies, convertToDistinct, disableCache, exists, finishResult, getColumnCount, getCostAsExpression, getExpressions, getFetch, getMaxDataModificationId, getOffset, getOffsetFetch, getRowDataType, getType, hasOrder, initExpression, initOrder, isFetchPercent, isNeverLazy, isQuery, isRandomAccessResult, isReadOnly, isStandardDistinct, isTransactional, isWithTies, prepareOrder, query, query, queryMeta, setDistinctIfPossible, setFetch, setFetchPercent, setNeverLazy, setOffset, setOrder, setRandomAccessResult, setWithTies, toTable

Methods inherited from class org.h2.command.Prepared
checkCanceled, checkParameters, getCteCleanups, getCurrentRowNumber, getObjectId, getParameters, getPersistedObjectId, getSession, getSimpleSQL, getSQL, getSQLTokens, needRecompile, setCommand, setCteCleanups, setCurrentRowNumber, setParameterList, setPersistedObjectId, setPrepareAlways, setRow, setSession, setSQL, toString, update

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

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

Constructor Detail

Select

public Select(SessionLocal session,
              Select parentSelect)

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

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,
                             java.util.HashMap<Column,ExpressionColumn> except)

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)

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

Class Select

Nested Class Summary

Nested classes/interfaces inherited from class org.h2.command.query.Query

Field Summary

Fields inherited from class org.h2.command.query.Query

Fields inherited from class org.h2.command.Prepared

Constructor Summary

Method Summary

Methods inherited from class org.h2.command.query.Query

Methods inherited from class org.h2.command.Prepared

Methods inherited from class java.lang.Object

Field Detail

topTableFilter

filters

topFilters

parentSelect

condition

having

qualify

distinctExpressions

distinctIndexes

group

groupIndex

groupByExpression

groupData

havingIndex

qualifyIndex

groupByCopies

isExplicitTable

isGroupQuery

isGroupSortedQuery

isWindowQuery

isForUpdate

cost

isQuickAggregateQuery

isDistinctQuery

sortUsingIndex

isGroupWindowStage2

windows

Constructor Detail

Select

Method Detail

isUnion

addTableFilter

getTopFilters

setExpressions

setExplicitTable

setWildcard

setGroupQuery

setWindowQuery

setGroupBy

getGroupBy

getGroupDataIfCurrent

setDistinct

setDistinct

isAnyDistinct

addWindow

getWindow

addCondition

getCondition

queryGroupSorted

createGroupSortedRow

rowForResult

isHavingNullOrFalse

getGroupSortedIndex

isGroupSortedIndex

isConditionMetForUpdate

isConditionMet

queryWindow

queryGroupWindow

queryGroup

initGroupData

setGroupData

gatherGroup

updateAgg

processGroupResult

constructGroupResultRow

getSortIndex

queryDistinct

queryFlat