DefaultOrmQuery (avaje-ebeanorm 3.3.1 API)

java.lang.Object
- com.avaje.ebeaninternal.server.querydefn.DefaultOrmQuery<T>

All Implemented Interfaces:

Query<T>, SpiQuery<T>, Serializable
```
public class DefaultOrmQuery<T>
extends Object
implements SpiQuery<T>
```
Default implementation of an Object Relational query.

See Also:
Serialized Form

Property Summary

Properties
Type Property and Description

boolean selectAllForLazyLoad
Return true if select all properties was used to ensure the property invoking a lazy load was included in the query.

Properties
Type	Property and Description
`boolean`	`selectAllForLazyLoad` Return true if select all properties was used to ensure the property invoking a lazy load was included in the query.

Nested Class Summary
- Nested classes/interfaces inherited from interface com.avaje.ebeaninternal.api.SpiQuery
  SpiQuery.Mode, SpiQuery.Type

Constructor Summary

Constructors
Constructor and Description
`DefaultOrmQuery(Class<T> beanType, EbeanServer server, ExpressionFactory expressionFactory, DeployNamedQuery namedQuery)` Additional supply a query which is parsed.
`DefaultOrmQuery(Class<T> beanType, EbeanServer server, ExpressionFactory expressionFactory, String query)`

Method Summary

Methods
Modifier and Type	Method and Description
`ExpressionList<T>`	`addHaving()`
`DefaultOrmQuery<T>`	`addHaving(Expression expression)`
`DefaultOrmQuery<T>`	`addHaving(String addToHavingClause)`
`ExpressionList<T>`	`addWhere()`
`DefaultOrmQuery<T>`	`addWhere(Expression expression)`
`DefaultOrmQuery<T>`	`addWhere(String addToWhereClause)`
`void`	`cancel()` Cancel the query execution if supported by the underlying database and driver.
`void`	`contextAdd(EntityBean bean)` Add a bean to the context additions.
`void`	`convertManyFetchJoinsToQueryJoins(boolean allowOne, int queryBatch)` Convert any many joins fetch joins to query joins.
`void`	`convertWhereNaturalKeyToId(Object idValue)` Convert this natural key query into a find by id query.
`DefaultOrmQuery<T>`	`copy()` Return a copy of the query.
`boolean`	`createOwnTransaction()` Return true if using background fetching or a queryListener.
`DefaultOrmQuery<T>`	`fetch(String property)` Specify a path to load including all its properties.
`DefaultOrmQuery<T>`	`fetch(String property, FetchConfig joinConfig)` Additionally specify a JoinConfig to specify a "query join" and or define the lazy loading query.
`DefaultOrmQuery<T>`	`fetch(String property, String columns)` Specify a path to fetch with its specific properties to include (aka partial object).
`DefaultOrmQuery<T>`	`fetch(String property, String columns, FetchConfig config)` Additionally specify a FetchConfig to use a separate query or lazy loading to load this path.
`ExpressionList<T>`	`filterMany(String prop)` This applies a filter on the 'many' property list rather than the root level objects.
`FutureIds<T>`	`findFutureIds()` Execute find Id's query in a background thread.
`FutureList<T>`	`findFutureList()` Execute find list query in a background thread.
`FutureRowCount<T>`	`findFutureRowCount()` Execute find row count query in a background thread.
`List<Object>`	`findIds()` Execute the query returning the list of Id's.
`QueryIterator<T>`	`findIterate()` Execute the query iterating over the results.
`List<T>`	`findList()` Execute the query returning the list of objects.
`Map<?,T>`	`findMap()` Execute the query returning a map of the objects.
`<K> Map<K,T>`	`findMap(String keyProperty, Class<K> keyType)` Return a typed map specifying the key property and type.
`PagingList<T>`	`findPagingList(int pageSize)` Return a PagingList for this query.
`int`	`findRowCount()` Return the count of entities this query should return.
`Set<T>`	`findSet()` Execute the query returning the set of objects.
`T`	`findUnique()` Execute the query returning either a single bean or null (if no matching bean is found).
`void`	`findVisit(QueryResultVisitor<T> visitor)` Execute the query using callbacks to a visitor to process the resulting beans one at a time.
`String`	`getAdditionalHaving()` Return any additional having clauses.
`String`	`getAdditionalWhere()` Return any additional where clauses.
`AutoFetchManager`	`getAutoFetchManager()` If return null then no autoFetch profiling for this query.
`int`	`getBackgroundFetchAfter()` Return the number of rows after which fetching should occur in a background thread.
`BeanCollectionTouched`	`getBeanCollectionTouched()` Return a listener that wants to be notified when the bean collection is first used.
`Class<T>`	`getBeanType()` Return the type of beans queries.
`BindParams`	`getBindParams()` Return the bind parameters.
`int`	`getBufferFetchSizeHint()` Return the hint for Statement.setFetchSize().
`ArrayList<EntityBean>`	`getContextAdditions()` Return any beans that should be added to the persistence context prior to executing the query.
`OrmQueryDetail`	`getDetail()` Return the query detail.
`ExpressionFactory`	`getExpressionFactory()` Return the ExpressionFactory used by this query.
`int`	`getFirstRow()` Return the index of the first row to return in the query.
`String`	`getGeneratedSql()` Return the sql that was generated for executing this query.
`SpiExpressionList<T>`	`getHavingExpressions()` Can return null if no expressions where added to the having clause.
`Object`	`getId()` Return the Id value.
`List<Object>`	`getIdList()` Return the list of Id's that is currently being fetched by a background thread.
`TableJoin`	`getIncludeTableJoin()`
`List<Object>`	`getLazyLoadForParentIds()` Return the list of parent Id's for lazy loading.
`BeanPropertyAssocMany<?>`	`getLazyLoadForParentsProperty()` Return the lazy loading 'many' property.
`String`	`getLazyLoadManyPath()` Return the lazy load path.
`String`	`getLazyLoadProperty()` Return the property that invoked lazy load.
`QueryListener<T>`	`getListener()` Return the findListener is one has been set.
`String`	`getLoadDescription()` Return a more detailed description of the lazy or query load.
`String`	`getLoadMode()` Return the load mode (+lazy or +query).
`ManyWhereJoins`	`getManyWhereJoins()` Return the joins required to support predicates on the many properties.
`String`	`getMapKey()` Return the property used to specify keys for a map.
`int`	`getMaxRows()` Return the maximum number of rows to return in the query.
`SpiQuery.Mode`	`getMode()` Return the query mode.
`String`	`getName()` Return the query name.
`NaturalKeyBindParam`	`getNaturalKeyBindParam()` Return a Natural Key bind parameter if supported by this query.
`OrderBy<T>`	`getOrderBy()` Return the Order By clause or null if there is none defined.
`ObjectGraphNode`	`getParentNode()` Used to hook back a lazy loading query to the original query (query point).
`PersistenceContext`	`getPersistenceContext()` Return the TransactionContext.
`String`	`getQuery()` Get the orm query as a String.
`RawSql`	`getRawSql()` Return the RawSql that was set to use for this query.
`String`	`getRawWhereClause()` Return the order by clause.
`int`	`getTimeout()` Return the timeout.
`int`	`getTotalHits()`
`SpiQuery.Type`	`getType()` Return the type of query (List, Set, Map, Bean, rowCount etc).
`SpiExpressionList<T>`	`getWhereExpressions()` Can return null if no expressions where added to the where clause.
`boolean`	`hasMaxRowsOrFirstRow()` Returns true if either firstRow or maxRows has been set.
`ExpressionList<T>`	`having()` Add Expressions to the Having clause return the ExpressionList.
`DefaultOrmQuery<T>`	`having(Expression expression)` Add an expression to the having clause returning the query.
`DefaultOrmQuery<T>`	`having(String addToHavingClause)` Add additional clause(s) to the having clause.
`boolean`	`initManyWhereJoins()` Return true if the where expressions contains a many property.
`Boolean`	`isAutofetch()` Return explicit autoFetch setting or null.
`boolean`	`isAutofetchTuned()` Returns true if this query was tuned by autoFetch.
`boolean`	`isCancelled()` Return true if this query has been cancelled.
`boolean`	`isDetailEmpty()` Return true if the query detail has neither select or joins specified.
`boolean`	`isDistinct()` return true if this query uses DISTINCT.
`boolean`	`isForUpdate()` Return true if this query has forUpdate set.
`boolean`	`isFutureFetch()` Return true if this is a query executing in the background.
`boolean`	`isLoadBeanCache()` Return true if the beans from this query should be loaded into the bean cache.
`boolean`	`isRawSql()` Return true if this is a RawSql query.
`Boolean`	`isReadOnly()` Return true if the beans returned by this query should be read only.
`boolean`	`isSqlSelect()` Return true if this is a query based on a SqlSelect rather than generated.
`boolean`	`isUsageProfiling()` Return false when this is a lazy load or refresh query for a bean.
`Boolean`	`isUseBeanCache()` Return true if this query should use/check the bean cache.
`boolean`	`isUseQueryCache()` Return true if this query should use/check the query cache.
`OrderBy<T>`	`order()` Return the OrderBy so that you can append an ascending or descending property to the order by clause.
`DefaultOrmQuery<T>`	`order(String orderByClause)` Set the order by clause replacing the existing order by clause if there is one.
`OrderBy<T>`	`orderBy()` Return the OrderBy so that you can append an ascending or descending property to the order by clause.
`DefaultOrmQuery<T>`	`orderBy(String orderByClause)` Set the order by clause replacing the existing order by clause if there is one.
`HashQueryPlan`	`queryAutofetchHash(HashQueryPlanBuilder builder)` Calculate a hash used by AutoFetch to identify when a query has changed (and hence potentially needs a new tuned query plan to be developed).
`int`	`queryBindHash()` Calculate a hash based on the bind values used in the query.
`HashQuery`	`queryHash()` Return a hash that includes the query plan and bind values.
`HashQueryPlan`	`queryPlanHash(BeanQueryRequest<?> request)` Calculate a hash that should be unique for the generated SQL across a given bean type.
`List<OrmQueryProperties>`	`removeLazyJoins()` Remove the lazy joins from query detail.
`List<OrmQueryProperties>`	`removeQueryJoins()` Remove the query joins from query detail.
`DefaultOrmQuery<T>`	`select(String columns)` Explicitly set a comma delimited list of the properties to fetch on the 'main' entity bean (aka partial object).
`boolean`	`selectAllForLazyLoadProperty()` Return true if select all properties was used to ensure the property invoking a lazy load was included in the query.
`DefaultOrmQuery<T>`	`setAutofetch(boolean autoFetch)` Explicitly specify whether to use Autofetch for this query.
`DefaultOrmQuery<T>`	`setAutoFetch(boolean autoFetch)`
`void`	`setAutoFetchManager(AutoFetchManager autoFetchManager)` This has the effect of turning on autoFetch profiling for this query.
`void`	`setAutoFetchTuned(boolean autoFetchTuned)` Set to true if this query has been tuned by autoFetch.
`DefaultOrmQuery<T>`	`setBackgroundFetchAfter(int backgroundFetchAfter)` Set the rows after which fetching should continue in a background thread.
`void`	`setBeanCollectionTouched(BeanCollectionTouched notify)` Set a listener to be notified when the bean collection has been touched (when the list/set/map is first used).
`void`	`setBeanDescriptor(BeanDescriptor<?> beanDescriptor)` Set the BeanDescriptor for the root type of this query.
`Query<T>`	`setBufferFetchSizeHint(int bufferFetchSizeHint)` A hint which for JDBC translates to the Statement.fetchSize().
`void`	`setCancelableQuery(CancelableQuery cancelableQuery)` Set the underlying cancelable query (with the PreparedStatement).
`void`	`setDefaultSelectClause()` Set default select clauses where none have been explicitly defined.
`void`	`setDetail(OrmQueryDetail detail)` Replace the query detail.
`DefaultOrmQuery<T>`	`setDistinct(boolean isDistinct)` Set whether this query uses DISTINCT.
`void`	`setFilterMany(String prop, ExpressionList<?> filterMany)` Set a filter to a join path.
`DefaultOrmQuery<T>`	`setFirstRow(int firstRow)` Set the first row to return for this query.
`DefaultOrmQuery<T>`	`setForUpdate(boolean forUpdate)` executed the select with "for update" which should lock the record "on read"
`void`	`setFutureFetch(boolean backgroundFetch)` Set to true to indicate the query is executing in a background thread asynchronously.
`void`	`setGeneratedSql(String generatedSql)` Set the generated sql for debug purposes.
`DefaultOrmQuery<T>`	`setId(Object id)` Set the Id value to query.
`void`	`setIdList(List<Object> partialIds)` Set the list of Id's that is being populated.
`void`	`setIncludeTableJoin(TableJoin includeTableJoin)`
`void`	`setLazyLoadForParents(List<Object> parentIds, BeanPropertyAssocMany<?> many)` This becomes a lazy loading query for a many relationship.
`void`	`setLazyLoadManyPath(String lazyLoadManyPath)` Set the path of the many when +query/+lazy loading query is executed.
`void`	`setLazyLoadProperty(String lazyLoadProperty)` Set the property that invoked the lazy load and MUST be included in the lazy loading query.
`DefaultOrmQuery<T>`	`setListener(QueryListener<T> queryListener)` Set a FindListener.
`DefaultOrmQuery<T>`	`setLoadBeanCache(boolean loadBeanCache)` When set to true all the beans from this query are loaded into the bean cache.
`void`	`setLoadDescription(String loadMode, String loadDescription)` Set the load mode (+lazy or +query) and the load description.
`DefaultOrmQuery<T>`	`setMapKey(String mapKey)` Set the property to use as keys for a map.
`DefaultOrmQuery<T>`	`setMaxRows(int maxRows)` Set the maximum number of rows to return in the query.
`void`	`setMode(SpiQuery.Mode mode)` Set the query mode.
`DefaultOrmQuery<T>`	`setOrder(OrderBy<T> orderBy)` Set an OrderBy object to replace any existing OrderBy clause.
`DefaultOrmQuery<T>`	`setOrderBy(OrderBy<T> orderBy)` Set an OrderBy object to replace any existing OrderBy clause.
`DefaultOrmQuery<T>`	`setOrderBy(String orderByClause)`
`ObjectGraphNode`	`setOrigin(CallStack callStack)` Return the origin point for the query.
`protected void`	`setOrmQueryDetail(OrmQueryDetail detail)`
`DefaultOrmQuery<T>`	`setParameter(int position, Object value)` Set an ordered bind parameter according to its position.
`DefaultOrmQuery<T>`	`setParameter(String name, Object value)` Set a named bind parameter.
`void`	`setParentNode(ObjectGraphNode parentNode)` Set the profile point of the bean or collection that is lazy loading.
`void`	`setPersistenceContext(PersistenceContext persistenceContext)` Set an explicit TransactionContext (typically for a refresh query).
`DefaultOrmQuery<T>`	`setProperties(String columns)`
`DefaultOrmQuery<T>`	`setQuery(String queryString)`
`DefaultOrmQuery<T>`	`setRawSql(RawSql rawSql)` Set RawSql to use for this query.
`protected void`	`setRawWhereClause(String rawWhereClause)`
`DefaultOrmQuery<T>`	`setReadOnly(boolean readOnly)` When set to true when you want the returned beans to be read only.
`void`	`setSelectId()` Set the select clause to select the Id property.
`DefaultOrmQuery<T>`	`setTimeout(int secs)` Set a timeout on this query.
`void`	`setTotalHits(int totalHits)`
`void`	`setType(SpiQuery.Type type)` Set the query type (List, Set etc).
`void`	`setUsageProfiling(boolean usageProfiling)` Set to false if this query should not be included in the autoFetch usage profiling information.
`DefaultOrmQuery<T>`	`setUseCache(boolean useBeanCache)` Set this to true to use the bean cache.
`DefaultOrmQuery<T>`	`setUseQueryCache(boolean useQueryCache)` Set this to true to use the query cache.
`String`	`toString()`
`boolean`	`tuneFetchProperties(OrmQueryDetail tunedDetail)` Autofetch tune the detail specifying properties to select on already defined joins and adding extra joins where they are missing.
`ExpressionList<T>`	`where()` Add Expressions to the where clause with the ability to chain on the ExpressionList.
`DefaultOrmQuery<T>`	`where(Expression expression)` Add a single Expression to the where clause returning the query.
`DefaultOrmQuery<T>`	`where(String addToWhereClause)` Add additional clause(s) to the where clause.

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

- Property Detail
  - selectAllForLazyLoad
    
    Return true if select all properties was used to ensure the property invoking a lazy load was included in the query.
    
    Specified by:
    
    selectAllForLazyLoadProperty in interface SpiQuery<T>
- Constructor Detail
  - DefaultOrmQuery
```
public DefaultOrmQuery(Class<T> beanType,
               EbeanServer server,
               ExpressionFactory expressionFactory,
               String query)
```
  - DefaultOrmQuery
```
public DefaultOrmQuery(Class<T> beanType,
               EbeanServer server,
               ExpressionFactory expressionFactory,
               DeployNamedQuery namedQuery)
                throws javax.persistence.PersistenceException
```
    Additional supply a query which is parsed.
    
    Throws:
    
    javax.persistence.PersistenceException
- Method Detail
  - getTotalHits
```
public int getTotalHits()
```
  - setTotalHits
```
public void setTotalHits(int totalHits)
```
  - setBeanDescriptor
```
public void setBeanDescriptor(BeanDescriptor<?> beanDescriptor)
```
    Set the BeanDescriptor for the root type of this query.
    
    Specified by:
    
    setBeanDescriptor in interface SpiQuery<T>
  - selectAllForLazyLoadProperty
```
public boolean selectAllForLazyLoadProperty()
```
    Return true if select all properties was used to ensure the property invoking a lazy load was included in the query.
    
    Specified by:
    
    selectAllForLazyLoadProperty in interface SpiQuery<T>
  - getRawSql
```
public RawSql getRawSql()
```
    Description copied from interface: Query
    
    Return the RawSql that was set to use for this query.
    
    Specified by:
    
    getRawSql in interface Query<T>
  - setRawSql
```
public DefaultOrmQuery<T> setRawSql(RawSql rawSql)
```
    Description copied from interface: Query
    
    Set RawSql to use for this query.
    
    Specified by:
    
    setRawSql in interface Query<T>
  - getLazyLoadProperty
```
public String getLazyLoadProperty()
```
    Description copied from interface: SpiQuery
    
    Return the property that invoked lazy load.
    
    Specified by:
    
    getLazyLoadProperty in interface SpiQuery<T>
  - setLazyLoadProperty
```
public void setLazyLoadProperty(String lazyLoadProperty)
```
    Description copied from interface: SpiQuery
    
    Set the property that invoked the lazy load and MUST be included in the lazy loading query.
    
    Specified by:
    
    setLazyLoadProperty in interface SpiQuery<T>
  - getLazyLoadManyPath
```
public String getLazyLoadManyPath()
```
    Description copied from interface: SpiQuery
    
    Return the lazy load path.
    
    Specified by:
    
    getLazyLoadManyPath in interface SpiQuery<T>
  - getExpressionFactory
```
public ExpressionFactory getExpressionFactory()
```
    Description copied from interface: Query
    
    Return the ExpressionFactory used by this query.
    
    Specified by:
    
    getExpressionFactory in interface Query<T>
  - initManyWhereJoins
```
public boolean initManyWhereJoins()
```
    Return true if the where expressions contains a many property.
    
    Specified by:
    
    initManyWhereJoins in interface SpiQuery<T>
  - getManyWhereJoins
```
public ManyWhereJoins getManyWhereJoins()
```
    Description copied from interface: SpiQuery
    
    Return the joins required to support predicates on the many properties.
    
    Specified by:
    
    getManyWhereJoins in interface SpiQuery<T>
  - removeQueryJoins
```
public List<OrmQueryProperties> removeQueryJoins()
```
    Description copied from interface: SpiQuery
    
    Remove the query joins from query detail.
    These are registered with the Load Context.
    
    Specified by:
    
    removeQueryJoins in interface SpiQuery<T>
  - removeLazyJoins
```
public List<OrmQueryProperties> removeLazyJoins()
```
    Description copied from interface: SpiQuery
    
    Remove the lazy joins from query detail.
    These are registered with the Load Context.
    
    Specified by:
    
    removeLazyJoins in interface SpiQuery<T>
  - setLazyLoadManyPath
```
public void setLazyLoadManyPath(String lazyLoadManyPath)
```
    Description copied from interface: SpiQuery
    
    Set the path of the many when +query/+lazy loading query is executed.
    
    Specified by:
    
    setLazyLoadManyPath in interface SpiQuery<T>
  - convertManyFetchJoinsToQueryJoins
```
public void convertManyFetchJoinsToQueryJoins(boolean allowOne,
                                     int queryBatch)
```
    Convert any many joins fetch joins to query joins.
    
    Specified by:
    
    convertManyFetchJoinsToQueryJoins in interface SpiQuery<T>
  - setSelectId
```
public void setSelectId()
```
    Set the select clause to select the Id property.
    
    Specified by:
    
    setSelectId in interface SpiQuery<T>
  - convertWhereNaturalKeyToId
```
public void convertWhereNaturalKeyToId(Object idValue)
```
    Description copied from interface: SpiQuery
    
    Convert this natural key query into a find by id query.
    
    Specified by:
    
    convertWhereNaturalKeyToId in interface SpiQuery<T>
  - getNaturalKeyBindParam
```
public NaturalKeyBindParam getNaturalKeyBindParam()
```
    Description copied from interface: SpiQuery
    
    Return a Natural Key bind parameter if supported by this query.
    
    Specified by:
    
    getNaturalKeyBindParam in interface SpiQuery<T>
  - copy
```
public DefaultOrmQuery<T> copy()
```
    Description copied from interface: SpiQuery
    
    Return a copy of the query.
    
    Specified by:
    
    copy in interface Query<T>
    
    Specified by:
    
    copy in interface SpiQuery<T>
  - getType
```
public SpiQuery.Type getType()
```
    Description copied from interface: SpiQuery
    
    Return the type of query (List, Set, Map, Bean, rowCount etc).
    
    Specified by:
    
    getType in interface SpiQuery<T>
  - setType
```
public void setType(SpiQuery.Type type)
```
    Description copied from interface: SpiQuery
    
    Set the query type (List, Set etc).
    
    Specified by:
    
    setType in interface SpiQuery<T>
  - getLoadDescription
```
public String getLoadDescription()
```
    Description copied from interface: SpiQuery
    
    Return a more detailed description of the lazy or query load.
    
    Specified by:
    
    getLoadDescription in interface SpiQuery<T>
  - getLoadMode
```
public String getLoadMode()
```
    Description copied from interface: SpiQuery
    
    Return the load mode (+lazy or +query).
    
    Specified by:
    
    getLoadMode in interface SpiQuery<T>
  - setLoadDescription
```
public void setLoadDescription(String loadMode,
                      String loadDescription)
```
    Description copied from interface: SpiQuery
    
    Set the load mode (+lazy or +query) and the load description.
    
    Specified by:
    
    setLoadDescription in interface SpiQuery<T>
  - getPersistenceContext
```
public PersistenceContext getPersistenceContext()
```
    Return the TransactionContext.
    If no TransactionContext is present on the query then the TransactionContext from the Transaction is used (transaction scoped persistence context).
    
    Specified by:
    
    getPersistenceContext in interface SpiQuery<T>
  - setPersistenceContext
```
public void setPersistenceContext(PersistenceContext persistenceContext)
```
    Set an explicit TransactionContext (typically for a refresh query).
    If no TransactionContext is present on the query then the TransactionContext from the Transaction is used (transaction scoped persistence context).
    
    Specified by:
    
    setPersistenceContext in interface SpiQuery<T>
  - setLazyLoadForParents
```
public void setLazyLoadForParents(List<Object> parentIds,
                         BeanPropertyAssocMany<?> many)
```
    Description copied from interface: SpiQuery
    
    This becomes a lazy loading query for a many relationship.
    
    Specified by:
    
    setLazyLoadForParents in interface SpiQuery<T>
  - getLazyLoadForParentIds
```
public List<Object> getLazyLoadForParentIds()
```
    Description copied from interface: SpiQuery
    
    Return the list of parent Id's for lazy loading.
    
    Specified by:
    
    getLazyLoadForParentIds in interface SpiQuery<T>
  - getLazyLoadForParentsProperty
```
public BeanPropertyAssocMany<?> getLazyLoadForParentsProperty()
```
    Description copied from interface: SpiQuery
    
    Return the lazy loading 'many' property.
    
    Specified by:
    
    getLazyLoadForParentsProperty in interface SpiQuery<T>
  - isDetailEmpty
```
public boolean isDetailEmpty()
```
    Return true if the query detail has neither select or joins specified.
    
    Specified by:
    
    isDetailEmpty in interface SpiQuery<T>
  - isAutofetchTuned
```
public boolean isAutofetchTuned()
```
    Description copied from interface: Query
    
    Returns true if this query was tuned by autoFetch.
    
    Specified by:
    
    isAutofetchTuned in interface Query<T>
  - setAutoFetchTuned
```
public void setAutoFetchTuned(boolean autoFetchTuned)
```
    Description copied from interface: SpiQuery
    
    Set to true if this query has been tuned by autoFetch.
    
    Specified by:
    
    setAutoFetchTuned in interface SpiQuery<T>
  - isAutofetch
```
public Boolean isAutofetch()
```
    Description copied from interface: SpiQuery
    
    Return explicit autoFetch setting or null. If null then not explicitly set so we use the default behaviour.
    
    Specified by:
    
    isAutofetch in interface SpiQuery<T>
  - isForUpdate
```
public boolean isForUpdate()
```
    Description copied from interface: Query
    
    Return true if this query has forUpdate set.
    
    Specified by:
    
    isForUpdate in interface Query<T>
  - setAutoFetch
```
public DefaultOrmQuery<T> setAutoFetch(boolean autoFetch)
```
  - setAutofetch
```
public DefaultOrmQuery<T> setAutofetch(boolean autoFetch)
```
    Description copied from interface: Query
    
    Explicitly specify whether to use Autofetch for this query.
    If you do not call this method on a query the "Implicit Autofetch mode" is used to determine if Autofetch should be used for a given query.
    
    Autofetch can add additional fetch paths to the query and specify which properties are included for each path. If you have explicitly defined some fetch paths Autofetch will not remove.
    
    Specified by:
    
    setAutofetch in interface Query<T>
  - setForUpdate
```
public DefaultOrmQuery<T> setForUpdate(boolean forUpdate)
```
    Description copied from interface: Query
    
    executed the select with "for update" which should lock the record "on read"
    
    Specified by:
    
    setForUpdate in interface Query<T>
  - getAutoFetchManager
```
public AutoFetchManager getAutoFetchManager()
```
    Description copied from interface: SpiQuery
    
    If return null then no autoFetch profiling for this query. If a AutoFetchManager is returned this implies that profiling is turned on for this query (and all the objects this query creates).
    
    Specified by:
    
    getAutoFetchManager in interface SpiQuery<T>
  - setAutoFetchManager
```
public void setAutoFetchManager(AutoFetchManager autoFetchManager)
```
    Description copied from interface: SpiQuery
    
    This has the effect of turning on autoFetch profiling for this query.
    
    Specified by:
    
    setAutoFetchManager in interface SpiQuery<T>
  - getMode
```
public SpiQuery.Mode getMode()
```
    Description copied from interface: SpiQuery
    
    Return the query mode.
    
    Specified by:
    
    getMode in interface SpiQuery<T>
  - setMode
```
public void setMode(SpiQuery.Mode mode)
```
    Description copied from interface: SpiQuery
    
    Set the query mode.
    
    Specified by:
    
    setMode in interface SpiQuery<T>
  - isUsageProfiling
```
public boolean isUsageProfiling()
```
    Description copied from interface: SpiQuery
    
    Return false when this is a lazy load or refresh query for a bean.
    We just take/copy the data from those beans and don't collect autoFetch usage profiling on those lazy load or refresh beans.
    
    Specified by:
    
    isUsageProfiling in interface SpiQuery<T>
  - setUsageProfiling
```
public void setUsageProfiling(boolean usageProfiling)
```
    Description copied from interface: SpiQuery
    
    Set to false if this query should not be included in the autoFetch usage profiling information.
    
    Specified by:
    
    setUsageProfiling in interface SpiQuery<T>
  - setParentNode
```
public void setParentNode(ObjectGraphNode parentNode)
```
    Description copied from interface: SpiQuery
    
    Set the profile point of the bean or collection that is lazy loading.
    This enables use to hook this back to the original 'root' query by the queryPlanHash and stackPoint.
    
    Specified by:
    
    setParentNode in interface SpiQuery<T>
  - getParentNode
```
public ObjectGraphNode getParentNode()
```
    Description copied from interface: SpiQuery
    
    Used to hook back a lazy loading query to the original query (query point).
    This will return null or an "original" query.
    
    Specified by:
    
    getParentNode in interface SpiQuery<T>
  - setOrigin
```
public ObjectGraphNode setOrigin(CallStack callStack)
```
    Description copied from interface: SpiQuery
    
    Return the origin point for the query.
    This MUST be call prior to a query being changed via tuning. This is because the queryPlanHash is used to identify the query point.
    
    Specified by:
    
    setOrigin in interface SpiQuery<T>
  - queryAutofetchHash
```
public HashQueryPlan queryAutofetchHash(HashQueryPlanBuilder builder)
```
    Calculate a hash used by AutoFetch to identify when a query has changed (and hence potentially needs a new tuned query plan to be developed).
    
    Specified by:
    
    queryAutofetchHash in interface SpiQuery<T>
  - queryPlanHash
```
public HashQueryPlan queryPlanHash(BeanQueryRequest<?> request)
```
    Calculate a hash that should be unique for the generated SQL across a given bean type.
    This can used to enable the caching and reuse of a 'query plan'.
    
    This is calculated AFTER AutoFetch query tuning has occurred.
    
    Specified by:
    
    queryPlanHash in interface SpiQuery<T>
  - queryBindHash
```
public int queryBindHash()
```
    Calculate a hash based on the bind values used in the query.
    Used with queryPlanHash() to get a unique hash for a query.
    
    Specified by:
    
    queryBindHash in interface SpiQuery<T>
  - queryHash
```
public HashQuery queryHash()
```
    Return a hash that includes the query plan and bind values.
    This hash can be used to identify if we have executed the exact same query (including bind values) before.
    
    Specified by:
    
    queryHash in interface SpiQuery<T>
  - getName
```
public String getName()
```
    Return the query name.
    
    Specified by:
    
    getName in interface SpiQuery<T>
  - isSqlSelect
```
public boolean isSqlSelect()
```
    Description copied from interface: SpiQuery
    
    Return true if this is a query based on a SqlSelect rather than generated.
    
    Specified by:
    
    isSqlSelect in interface SpiQuery<T>
  - isRawSql
```
public boolean isRawSql()
```
    Description copied from interface: SpiQuery
    
    Return true if this is a RawSql query.
    
    Specified by:
    
    isRawSql in interface SpiQuery<T>
  - getAdditionalWhere
```
public String getAdditionalWhere()
```
    Return any additional where clauses.
    
    Specified by:
    
    getAdditionalWhere in interface SpiQuery<T>
  - getTimeout
```
public int getTimeout()
```
    Return the timeout.
    
    Specified by:
    
    getTimeout in interface SpiQuery<T>
  - getAdditionalHaving
```
public String getAdditionalHaving()
```
    Return any additional having clauses.
    
    Specified by:
    
    getAdditionalHaving in interface SpiQuery<T>
  - hasMaxRowsOrFirstRow
```
public boolean hasMaxRowsOrFirstRow()
```
    Description copied from interface: SpiQuery
    
    Returns true if either firstRow or maxRows has been set.
    
    Specified by:
    
    hasMaxRowsOrFirstRow in interface SpiQuery<T>
  - isReadOnly
```
public Boolean isReadOnly()
```
    Description copied from interface: SpiQuery
    
    Return true if the beans returned by this query should be read only.
    
    Specified by:
    
    isReadOnly in interface SpiQuery<T>
  - setReadOnly
```
public DefaultOrmQuery<T> setReadOnly(boolean readOnly)
```
    Description copied from interface: Query
    
    When set to true when you want the returned beans to be read only.
    
    Specified by:
    
    setReadOnly in interface Query<T>
  - isUseBeanCache
```
public Boolean isUseBeanCache()
```
    Description copied from interface: SpiQuery
    
    Return true if this query should use/check the bean cache.
    
    Specified by:
    
    isUseBeanCache in interface SpiQuery<T>
  - isUseQueryCache
```
public boolean isUseQueryCache()
```
    Description copied from interface: SpiQuery
    
    Return true if this query should use/check the query cache.
    
    Specified by:
    
    isUseQueryCache in interface SpiQuery<T>
  - setUseCache
```
public DefaultOrmQuery<T> setUseCache(boolean useBeanCache)
```
    Description copied from interface: Query
    
    Set this to true to use the bean cache.
    If the query result is in cache then by default this same instance is returned. In this sense it should be treated as a read only object graph.
    
    Specified by:
    
    setUseCache in interface Query<T>
  - setUseQueryCache
```
public DefaultOrmQuery<T> setUseQueryCache(boolean useQueryCache)
```
    Description copied from interface: Query
    
    Set this to true to use the query cache.
    
    Specified by:
    
    setUseQueryCache in interface Query<T>
  - isLoadBeanCache
```
public boolean isLoadBeanCache()
```
    Description copied from interface: SpiQuery
    
    Return true if the beans from this query should be loaded into the bean cache.
    
    Specified by:
    
    isLoadBeanCache in interface SpiQuery<T>
  - setLoadBeanCache
```
public DefaultOrmQuery<T> setLoadBeanCache(boolean loadBeanCache)
```
    Description copied from interface: Query
    
    When set to true all the beans from this query are loaded into the bean cache.
    
    Specified by:
    
    setLoadBeanCache in interface Query<T>
  - setTimeout
```
public DefaultOrmQuery<T> setTimeout(int secs)
```
    Description copied from interface: Query
    
    Set a timeout on this query.
    This will typically result in a call to setQueryTimeout() on a preparedStatement. If the timeout occurs an exception will be thrown - this will be a SQLException wrapped up in a PersistenceException.
    
    Specified by:
    
    setTimeout in interface Query<T>
    
    Parameters:
    secs - the query timeout limit in seconds. Zero means there is no limit.
  - setQuery
```
public DefaultOrmQuery<T> setQuery(String queryString)
                            throws javax.persistence.PersistenceException
```
    Throws:
    
    javax.persistence.PersistenceException
  - setOrmQueryDetail
```
protected void setOrmQueryDetail(OrmQueryDetail detail)
```
  - setRawWhereClause
```
protected void setRawWhereClause(String rawWhereClause)
```
  - setProperties
```
public DefaultOrmQuery<T> setProperties(String columns)
```
  - setDefaultSelectClause
```
public void setDefaultSelectClause()
```
    Description copied from interface: SpiQuery
    
    Set default select clauses where none have been explicitly defined.
    
    Specified by:
    
    setDefaultSelectClause in interface SpiQuery<T>
  - select
```
public DefaultOrmQuery<T> select(String columns)
```
    Description copied from interface: Query
    Explicitly set a comma delimited list of the properties to fetch on the 'main' entity bean (aka partial object). Note that '*' means all properties.
```
 Query<Customer> query = Ebean.createQuery(Customer.class);
 
 // Only fetch the customer id, name and status.
 // This is described as a "Partial Object"
 query.select("name, status");
 query.where("lower(name) like :custname").setParameter("custname", "rob%");
 
 List<Customer> customerList = query.findList();
 
```
    Specified by:
    
    select in interface Query<T>
    
    Parameters:
    columns - the properties to fetch for this bean (* = all properties).
  - fetch
```
public DefaultOrmQuery<T> fetch(String property)
```
    Description copied from interface: Query
    
    Specify a path to load including all its properties.
    The same as Query.fetch(String, String) with the fetchProperties as "*".
    
    Specified by:
    
    fetch in interface Query<T>
    
    Parameters:
    property - the property of an associated (1-1,1-M,M-1,M-M) bean.
  - fetch
```
public DefaultOrmQuery<T> fetch(String property,
                       FetchConfig joinConfig)
```
    Description copied from interface: Query
    
    Additionally specify a JoinConfig to specify a "query join" and or define the lazy loading query.
    
    Specified by:
    
    fetch in interface Query<T>
  - fetch
```
public DefaultOrmQuery<T> fetch(String property,
                       String columns)
```
    Description copied from interface: Query
    Specify a path to fetch with its specific properties to include (aka partial object).
    When you specify a join this means that property (associated bean(s)) will be fetched and populated. If you specify "*" then all the properties of the associated bean will be fetched and populated. You can specify a comma delimited list of the properties of that associated bean which means that only those properties are fetched and populated resulting in a "Partial Object" - a bean that only has some of its properties populated.
```
 // query orders...
 Query<Order> query = Ebean.createQuery(Order.class);
 
 // fetch the customer...
 // ... getting the customer's name and phone number
 query.fetch("customer", "name, phNumber");
 
 // ... also fetch the customers billing address (* = all properties)
 query.fetch("customer.billingAddress", "*");
 
```
    If columns is null or "*" then all columns/properties for that path are fetched.
```
 // fetch customers (their id, name and status)
 Query<Customer> query = Ebean.createQuery(Customer.class);
 
 // only fetch some of the properties of the customers
 query.select("name, status");
 List<Customer> list = query.findList();
 
```
    Specified by:
    
    fetch in interface Query<T>
    
    Parameters:
    property - the path of an associated (1-1,1-M,M-1,M-M) bean.
    columns - properties of the associated bean that you want to include in the fetch (* means all properties, null also means all properties).
  - fetch
```
public DefaultOrmQuery<T> fetch(String property,
                       String columns,
                       FetchConfig config)
```
    Description copied from interface: Query
    
    Additionally specify a FetchConfig to use a separate query or lazy loading to load this path.
    
    Specified by:
    
    fetch in interface Query<T>
  - findIds
```
public List<Object> findIds()
```
    Description copied from interface: Query
    
    Execute the query returning the list of Id's.
    This query will execute against the EbeanServer that was used to create it.
    
    Specified by:
    
    findIds in interface Query<T>
    
    See Also:
    EbeanServer.findIds(Query, Transaction)
  - findRowCount
```
public int findRowCount()
```
    Description copied from interface: Query
    
    Return the count of entities this query should return.
    This is the number of 'top level' or 'root level' entities.
    
    Specified by:
    
    findRowCount in interface Query<T>
  - findVisit
```
public void findVisit(QueryResultVisitor<T> visitor)
```
    Description copied from interface: Query
    Execute the query using callbacks to a visitor to process the resulting beans one at a time.
    Similar to findIterate() this query method does not require all the result beans to be all held in memory at once and as such is useful for processing large queries.
```
 
 Query<Customer> query = server.find(Customer.class)
     .fetch("contacts", new FetchConfig().query(2))
     .where().gt("id", 0)
     .orderBy("id")
     .setMaxRows(2);
 
 query.findVisit(new QueryResultVisitor<Customer>() {
 
   public boolean accept(Customer customer) {
     // do something with customer
     System.out.println("-- visit " + customer);
     return true;
   }
 });
 
```
    Specified by:
    
    findVisit in interface Query<T>
    
    Parameters:
    visitor - the visitor used to process the queried beans.
  - findIterate
```
public QueryIterator<T> findIterate()
```
    Description copied from interface: Query
    
    Execute the query iterating over the results.
    Remember that with QueryIterator you must call QueryIterator.close() when you have finished iterating the results (typically in a finally block).
    
    This query will execute against the EbeanServer that was used to create it.
    
    Specified by:
    
    findIterate in interface Query<T>
  - findList
```
public List<T> findList()
```
    Description copied from interface: Query
    
    Execute the query returning the list of objects.
    This query will execute against the EbeanServer that was used to create it.
    
    Specified by:
    
    findList in interface Query<T>
    
    See Also:
    EbeanServer.findList(Query, Transaction)
  - findSet
```
public Set<T> findSet()
```
    Description copied from interface: Query
    
    Execute the query returning the set of objects.
    This query will execute against the EbeanServer that was used to create it.
    
    Specified by:
    
    findSet in interface Query<T>
    
    See Also:
    EbeanServer.findSet(Query, Transaction)
  - findMap
```
public Map<?,T> findMap()
```
    Description copied from interface: Query
    Execute the query returning a map of the objects.
    This query will execute against the EbeanServer that was used to create it.
    
    You can use setMapKey() so specify the property values to be used as keys on the map. If one is not specified then the id property is used.
```
 Query<Product> query = Ebean.createQuery(Product.class);
 query.setMapKey("sku");
 Map<?, Product> map = query.findMap();
 
```
    Specified by:
    
    findMap in interface Query<T>
    
    See Also:
    EbeanServer.findMap(Query, Transaction)
  - findMap
```
public <K> Map<K,T> findMap(String keyProperty,
                   Class<K> keyType)
```
    Description copied from interface: Query
    
    Return a typed map specifying the key property and type.
    
    Specified by:
    
    findMap in interface Query<T>
  - findUnique
```
public T findUnique()
```
    Description copied from interface: Query
    Execute the query returning either a single bean or null (if no matching bean is found).
    If more than 1 row is found for this query then a PersistenceException is thrown.
    
    This is useful when your predicates dictate that your query should only return 0 or 1 results.
```
 // assuming the sku of products is unique...
 Product product =
     Ebean.find(Product.class)
         .where("sku = ?")
         .set(1, "aa113")
         .findUnique();
 ...
 
```
    It is also useful with finding objects by their id when you want to specify further join information.
```
 // Fetch order 1 and additionally fetch join its order details...
 Order order = 
     Ebean.find(Order.class)
       .setId(1)
       .fetch("details")
       .findUnique();
       
 List<OrderDetail> details = order.getDetails();
 ...
 
```
    Specified by:
    
    findUnique in interface Query<T>
  - findFutureIds
```
public FutureIds<T> findFutureIds()
```
    Description copied from interface: Query
    
    Execute find Id's query in a background thread.
    This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).
    
    Specified by:
    
    findFutureIds in interface Query<T>
    
    Returns:
    a Future object for the list of Id's
  - findFutureList
```
public FutureList<T> findFutureList()
```
    Description copied from interface: Query
    
    Execute find list query in a background thread.
    This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).
    
    Specified by:
    
    findFutureList in interface Query<T>
    
    Returns:
    a Future object for the list result of the query
  - findFutureRowCount
```
public FutureRowCount<T> findFutureRowCount()
```
    Description copied from interface: Query
    
    Execute find row count query in a background thread.
    This returns a Future object which can be used to cancel, check the execution status (isDone etc) and get the value (with or without a timeout).
    
    Specified by:
    
    findFutureRowCount in interface Query<T>
    
    Returns:
    a Future object for the row count query
  - findPagingList
```
public PagingList<T> findPagingList(int pageSize)
```
    Description copied from interface: Query
    
    Return a PagingList for this query.
    This can be used to break up a query into multiple queries to fetch the data a page at a time.
    
    This typically works by using a query per page and setting Query.setFirstRow(int) and and Query.setMaxRows(int) on the query. This usually would translate into SQL that uses limit offset, rownum or row_number function to limit the result set.
    
    Specified by:
    
    findPagingList in interface Query<T>
    
    Parameters:
    pageSize - the number of beans fetched per Page
  - setParameter
```
public DefaultOrmQuery<T> setParameter(int position,
                              Object value)
```
    Set an ordered bind parameter according to its position. Note that the position starts at 1 to be consistent with JDBC PreparedStatement. You need to set a parameter value for each ? you have in the query.
    
    Specified by:
    
    setParameter in interface Query<T>
    
    Parameters:
    position - the parameter bind position starting from 1 (not 0)
    value - the parameter bind value.
  - setParameter
```
public DefaultOrmQuery<T> setParameter(String name,
                              Object value)
```
    Set a named bind parameter. Named parameters have a colon to prefix the name.
    
    Specified by:
    
    setParameter in interface Query<T>
    
    Parameters:
    name - the parameter name
    value - the parameter value
  - getOrderBy
```
public OrderBy<T> getOrderBy()
```
    Description copied from interface: SpiQuery
    
    Return the Order By clause or null if there is none defined.
    
    Specified by:
    
    getOrderBy in interface SpiQuery<T>
  - getRawWhereClause
```
public String getRawWhereClause()
```
    Return the order by clause.
    
    Specified by:
    
    getRawWhereClause in interface SpiQuery<T>
  - orderBy
```
public OrderBy<T> orderBy()
```
    Description copied from interface: Query
    
    Return the OrderBy so that you can append an ascending or descending property to the order by clause.
    This will never return a null. If no order by clause exists then an 'empty' OrderBy object is returned.
    
    This is EXACTLY the same as Query.order().
    
    Specified by:
    
    orderBy in interface Query<T>
  - order
```
public OrderBy<T> order()
```
    Description copied from interface: Query
    
    Return the OrderBy so that you can append an ascending or descending property to the order by clause.
    This will never return a null. If no order by clause exists then an 'empty' OrderBy object is returned.
    
    This is EXACTLY the same as Query.orderBy().
    
    Specified by:
    
    order in interface Query<T>
  - setOrderBy
```
public DefaultOrmQuery<T> setOrderBy(String orderByClause)
```
  - orderBy
```
public DefaultOrmQuery<T> orderBy(String orderByClause)
```
    Description copied from interface: Query
    
    Set the order by clause replacing the existing order by clause if there is one.
    This follows SQL syntax using commas between each property with the optional asc and desc keywords representing ascending and descending order respectively.
    
    This is EXACTLY the same as Query.order(String).
    
    Specified by:
    
    orderBy in interface Query<T>
  - order
```
public DefaultOrmQuery<T> order(String orderByClause)
```
    Description copied from interface: Query
    
    Set the order by clause replacing the existing order by clause if there is one.
    This follows SQL syntax using commas between each property with the optional asc and desc keywords representing ascending and descending order respectively.
    
    This is EXACTLY the same as Query.orderBy(String).
    
    Specified by:
    
    order in interface Query<T>
  - setOrderBy
```
public DefaultOrmQuery<T> setOrderBy(OrderBy<T> orderBy)
```
    Description copied from interface: Query
    
    Set an OrderBy object to replace any existing OrderBy clause.
    This is EXACTLY the same as Query.setOrder(OrderBy).
    
    Specified by:
    
    setOrderBy in interface Query<T>
  - setOrder
```
public DefaultOrmQuery<T> setOrder(OrderBy<T> orderBy)
```
    Description copied from interface: Query
    
    Set an OrderBy object to replace any existing OrderBy clause.
    This is EXACTLY the same as Query.setOrderBy(OrderBy).
    
    Specified by:
    
    setOrder in interface Query<T>
  - isDistinct
```
public boolean isDistinct()
```
    return true if this query uses DISTINCT.
    
    Specified by:
    
    isDistinct in interface SpiQuery<T>
  - setDistinct
```
public DefaultOrmQuery<T> setDistinct(boolean isDistinct)
```
    Set whether this query uses DISTINCT.
    
    Specified by:
    
    setDistinct in interface Query<T>
  - getListener
```
public QueryListener<T> getListener()
```
    Return the findListener is one has been set.
    
    Specified by:
    
    getListener in interface SpiQuery<T>
  - setListener
```
public DefaultOrmQuery<T> setListener(QueryListener<T> queryListener)
```
    Set a FindListener. This is designed for large fetches where lots are rows are to be processed and instead of returning all the rows they are processed one at a time.
    Note that the returning List Set or Map will be empty.
    
    Specified by:
    
    setListener in interface Query<T>
  - getBeanType
```
public Class<T> getBeanType()
```
    Description copied from interface: SpiQuery
    
    Return the type of beans queries.
    
    Specified by:
    
    getBeanType in interface SpiQuery<T>
  - setDetail
```
public void setDetail(OrmQueryDetail detail)
```
    Description copied from interface: SpiQuery
    
    Replace the query detail. This is used by the autoFetch feature to as a fast way to set the query properties and joins.
    Note care must be taken to keep the where, orderBy, firstRows and maxRows held in the detail attributes.
    
    Specified by:
    
    setDetail in interface SpiQuery<T>
  - tuneFetchProperties
```
public boolean tuneFetchProperties(OrmQueryDetail tunedDetail)
```
    Description copied from interface: SpiQuery
    
    Autofetch tune the detail specifying properties to select on already defined joins and adding extra joins where they are missing.
    
    Specified by:
    
    tuneFetchProperties in interface SpiQuery<T>
  - getDetail
```
public OrmQueryDetail getDetail()
```
    Description copied from interface: SpiQuery
    
    Return the query detail.
    
    Specified by:
    
    getDetail in interface SpiQuery<T>
  - getContextAdditions
```
public final ArrayList<EntityBean> getContextAdditions()
```
    Return any beans that should be added to the persistence context prior to executing the query.
    
    Specified by:
    
    getContextAdditions in interface SpiQuery<T>
  - contextAdd
```
public void contextAdd(EntityBean bean)
```
    Add a bean to the context additions.
    These are added to the persistence context before executing the query.
    
    Specified by:
    
    contextAdd in interface SpiQuery<T>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getIncludeTableJoin
```
public TableJoin getIncludeTableJoin()
```
    Specified by:
    
    getIncludeTableJoin in interface SpiQuery<T>
  - setIncludeTableJoin
```
public void setIncludeTableJoin(TableJoin includeTableJoin)
```
    Specified by:
    
    setIncludeTableJoin in interface SpiQuery<T>
  - getFirstRow
```
public int getFirstRow()
```
    Description copied from interface: SpiQuery
    
    Return the index of the first row to return in the query.
    
    Specified by:
    
    getFirstRow in interface Query<T>
    
    Specified by:
    
    getFirstRow in interface SpiQuery<T>
  - setFirstRow
```
public DefaultOrmQuery<T> setFirstRow(int firstRow)
```
    Description copied from interface: Query
    
    Set the first row to return for this query.
    
    Specified by:
    
    setFirstRow in interface Query<T>
  - getMaxRows
```
public int getMaxRows()
```
    Description copied from interface: SpiQuery
    
    Return the maximum number of rows to return in the query.
    
    Specified by:
    
    getMaxRows in interface Query<T>
    
    Specified by:
    
    getMaxRows in interface SpiQuery<T>
  - setMaxRows
```
public DefaultOrmQuery<T> setMaxRows(int maxRows)
```
    Description copied from interface: Query
    
    Set the maximum number of rows to return in the query.
    
    Specified by:
    
    setMaxRows in interface Query<T>
    
    Parameters:
    maxRows - the maximum number of rows to return in the query.
  - getMapKey
```
public String getMapKey()
```
    Description copied from interface: SpiQuery
    
    Return the property used to specify keys for a map.
    
    Specified by:
    
    getMapKey in interface SpiQuery<T>
  - setMapKey
```
public DefaultOrmQuery<T> setMapKey(String mapKey)
```
    Description copied from interface: Query
    Set the property to use as keys for a map.
    If no property is set then the id property is used.
```
 // Assuming sku is unique for products...
    
 Query<Product> query = Ebean.createQuery(Product.class);
   
 // use sku for keys...
 query.setMapKey("sku");
   
 Map<?,Product> productMap = query.findMap();
 ...
 
```
    Specified by:
    
    setMapKey in interface Query<T>
    
    Parameters:
    mapKey - the property to use as keys for a map.
  - getBackgroundFetchAfter
```
public int getBackgroundFetchAfter()
```
    Description copied from interface: SpiQuery
    
    Return the number of rows after which fetching should occur in a background thread.
    
    Specified by:
    
    getBackgroundFetchAfter in interface SpiQuery<T>
  - setBackgroundFetchAfter
```
public DefaultOrmQuery<T> setBackgroundFetchAfter(int backgroundFetchAfter)
```
    Description copied from interface: Query
    
    Set the rows after which fetching should continue in a background thread.
    
    Specified by:
    
    setBackgroundFetchAfter in interface Query<T>
  - getId
```
public Object getId()
```
    Description copied from interface: SpiQuery
    
    Return the Id value.
    
    Specified by:
    
    getId in interface SpiQuery<T>
  - setId
```
public DefaultOrmQuery<T> setId(Object id)
```
    Description copied from interface: Query
    Set the Id value to query. This is used with findUnique().
    You can use this to have further control over the query. For example adding fetch joins.
```
 Query<Order> query = Ebean.createQuery(Order.class);
 Order order = query.setId(1).join("details").findUnique();
 List<OrderDetail> details = order.getDetails();
 ...
 
```
    Specified by:
    
    setId in interface Query<T>
  - getBindParams
```
public BindParams getBindParams()
```
    Description copied from interface: SpiQuery
    
    Return the bind parameters.
    
    Specified by:
    
    getBindParams in interface SpiQuery<T>
  - getQuery
```
public String getQuery()
```
    Description copied from interface: SpiQuery
    
    Get the orm query as a String. Only available if the query was built from a string.
    
    Specified by:
    
    getQuery in interface SpiQuery<T>
  - addWhere
```
public DefaultOrmQuery<T> addWhere(String addToWhereClause)
```
  - addWhere
```
public DefaultOrmQuery<T> addWhere(Expression expression)
```
  - addWhere
```
public ExpressionList<T> addWhere()
```
  - where
```
public DefaultOrmQuery<T> where(String addToWhereClause)
```
    Description copied from interface: Query
    Add additional clause(s) to the where clause.
    This typically contains named parameters which will need to be set via Query.setParameter(String, Object).
```
 Query<Order> query = Ebean.createQuery(Order.class, "top");
 ...
 if (...) {
   query.where("status = :status and lower(customer.name) like :custName");
   query.setParameter("status", Order.NEW);
   query.setParameter("custName", "rob%");
 }
 
```
    Internally the addToWhereClause string is processed by removing named parameters (replacing them with ?) and by converting logical property names to database column names (with table alias). The rest of the string is left as is and it is completely acceptable and expected for the addToWhereClause string to include sql functions and columns.
    Specified by:
    
    where in interface Query<T>
    
    Parameters:
    addToWhereClause - the clause to append to the where clause which typically contains named parameters.
    
    Returns:
    The query object
  - where
```
public DefaultOrmQuery<T> where(Expression expression)
```
    Description copied from interface: Query
    Add a single Expression to the where clause returning the query.
```
 List<Order> newOrders = 
     Ebean.find(Order.class)
                .where().eq("status", Order.NEW)
                .findList();
 ...
 
```
    Specified by:
    
    where in interface Query<T>
  - where
```
public ExpressionList<T> where()
```
    Description copied from interface: Query
    Add Expressions to the where clause with the ability to chain on the ExpressionList. You can use this for adding multiple expressions to the where clause.
```
 Query<Order> query = Ebean.createQuery(Order.class, "top");
 ...
 if (...) {
   query.where()
     .eq("status", Order.NEW)
     .ilike("customer.name","rob%");
 }
 
```
    Specified by:
    
    where in interface Query<T>
    
    Returns:
    The ExpressionList for adding expressions to.
    See Also:
    Expr
  - filterMany
```
public ExpressionList<T> filterMany(String prop)
```
    Description copied from interface: Query
    This applies a filter on the 'many' property list rather than the root level objects.
    Typically you will use this in a scenario where the cardinality is high on the 'many' property you wish to join to. Say you want to fetch customers and their associated orders... but instead of getting all the orders for each customer you only want to get the new orders they placed since last week. In this case you can use filterMany() to filter the orders.
```
 
 List<Customer> list = Ebean
     .find(Customer.class)
     // .fetch("orders", new FetchConfig().lazy())
     // .fetch("orders", new FetchConfig().query())
     .fetch("orders").where().ilike("name", "rob%").filterMany("orders")
     .eq("status", Order.Status.NEW).gt(
         "orderDate", lastWeek).findList();
 
 
```
    Please note you have to be careful that you add expressions to the correct expression list - as there is one for the 'root level' and one for each filterMany that you have.
    Specified by:
    
    filterMany in interface Query<T>
    
    Parameters:
    prop - the name of the many property that you want to have a filter on.
    
    Returns:
    the expression list that you add filter expressions for the many to.
  - setFilterMany
```
public void setFilterMany(String prop,
                 ExpressionList<?> filterMany)
```
    Description copied from interface: SpiQuery
    
    Set a filter to a join path.
    
    Specified by:
    
    setFilterMany in interface SpiQuery<T>
  - addHaving
```
public DefaultOrmQuery<T> addHaving(String addToHavingClause)
```
  - addHaving
```
public DefaultOrmQuery<T> addHaving(Expression expression)
```
  - addHaving
```
public ExpressionList<T> addHaving()
```
  - having
```
public DefaultOrmQuery<T> having(String addToHavingClause)
```
    Description copied from interface: Query
    Add additional clause(s) to the having clause.
    This typically contains named parameters which will need to be set via Query.setParameter(String, Object).
```
 Query<ReportOrder> query = Ebean.createQuery(ReportOrder.class);
 ...
 if (...) {
   query.having("score > :min");
   query.setParameter("min", 1);
 }
 
```
    Specified by:
    
    having in interface Query<T>
    
    Parameters:
    addToHavingClause - the clause to append to the having clause which typically contains named parameters.
    
    Returns:
    The query object
  - having
```
public DefaultOrmQuery<T> having(Expression expression)
```
    Description copied from interface: Query
    
    Add an expression to the having clause returning the query.
    Currently only beans based on raw sql will use the having clause.
    
    This is similar to Query.having() except it returns the query rather than the ExpressionList. This is useful when you want to further specify something on the query.
    
    Specified by:
    
    having in interface Query<T>
    
    Parameters:
    expression - the expression to add to the having clause.
    
    Returns:
    the Query object
  - having
```
public ExpressionList<T> having()
```
    Description copied from interface: Query
    
    Add Expressions to the Having clause return the ExpressionList.
    Currently only beans based on raw sql will use the having clause.
    
    Note that this returns the ExpressionList (so you can add multiple expressions to the query in a fluent API way).
    
    Specified by:
    
    having in interface Query<T>
    
    Returns:
    The ExpressionList for adding more expressions to.
    See Also:
    Expr
  - getHavingExpressions
```
public SpiExpressionList<T> getHavingExpressions()
```
    Description copied from interface: SpiQuery
    
    Can return null if no expressions where added to the having clause.
    
    Specified by:
    
    getHavingExpressions in interface SpiQuery<T>
  - getWhereExpressions
```
public SpiExpressionList<T> getWhereExpressions()
```
    Description copied from interface: SpiQuery
    
    Can return null if no expressions where added to the where clause.
    
    Specified by:
    
    getWhereExpressions in interface SpiQuery<T>
  - createOwnTransaction
```
public boolean createOwnTransaction()
```
    Return true if using background fetching or a queryListener.
    
    Specified by:
    
    createOwnTransaction in interface SpiQuery<T>
  - getGeneratedSql
```
public String getGeneratedSql()
```
    Description copied from interface: Query
    
    Return the sql that was generated for executing this query.
    This is only available after the query has been executed and provided only for informational purposes.
    
    Specified by:
    
    getGeneratedSql in interface Query<T>
  - setGeneratedSql
```
public void setGeneratedSql(String generatedSql)
```
    Description copied from interface: SpiQuery
    
    Set the generated sql for debug purposes.
    
    Specified by:
    
    setGeneratedSql in interface SpiQuery<T>
  - setBufferFetchSizeHint
```
public Query<T> setBufferFetchSizeHint(int bufferFetchSizeHint)
```
    Description copied from interface: Query
    
    A hint which for JDBC translates to the Statement.fetchSize().
    Gives the JDBC driver a hint as to the number of rows that should be fetched from the database when more rows are needed for ResultSet.
    
    Specified by:
    
    setBufferFetchSizeHint in interface Query<T>
  - getBufferFetchSizeHint
```
public int getBufferFetchSizeHint()
```
    Description copied from interface: SpiQuery
    
    Return the hint for Statement.setFetchSize().
    
    Specified by:
    
    getBufferFetchSizeHint in interface SpiQuery<T>
  - setBeanCollectionTouched
```
public void setBeanCollectionTouched(BeanCollectionTouched notify)
```
    Description copied from interface: SpiQuery
    
    Set a listener to be notified when the bean collection has been touched (when the list/set/map is first used).
    
    Specified by:
    
    setBeanCollectionTouched in interface SpiQuery<T>
  - getBeanCollectionTouched
```
public BeanCollectionTouched getBeanCollectionTouched()
```
    Description copied from interface: SpiQuery
    
    Return a listener that wants to be notified when the bean collection is first used.
    
    Specified by:
    
    getBeanCollectionTouched in interface SpiQuery<T>
  - getIdList
```
public List<Object> getIdList()
```
    Description copied from interface: SpiQuery
    
    Return the list of Id's that is currently being fetched by a background thread.
    
    Specified by:
    
    getIdList in interface SpiQuery<T>
  - setIdList
```
public void setIdList(List<Object> partialIds)
```
    Description copied from interface: SpiQuery
    
    Set the list of Id's that is being populated.
    This is a mutating list of id's and we are setting this so that other threads have access to the id's before the id query has finished.
    
    Specified by:
    
    setIdList in interface SpiQuery<T>
  - isFutureFetch
```
public boolean isFutureFetch()
```
    Description copied from interface: SpiQuery
    
    Return true if this is a query executing in the background.
    
    Specified by:
    
    isFutureFetch in interface SpiQuery<T>
  - setFutureFetch
```
public void setFutureFetch(boolean backgroundFetch)
```
    Description copied from interface: SpiQuery
    
    Set to true to indicate the query is executing in a background thread asynchronously.
    
    Specified by:
    
    setFutureFetch in interface SpiQuery<T>
  - setCancelableQuery
```
public void setCancelableQuery(CancelableQuery cancelableQuery)
```
    Description copied from interface: SpiQuery
    
    Set the underlying cancelable query (with the PreparedStatement).
    
    Specified by:
    
    setCancelableQuery in interface SpiQuery<T>
  - cancel
```
public void cancel()
```
    Description copied from interface: Query
    
    Cancel the query execution if supported by the underlying database and driver.
    This must be called from a different thread to the query executor.
    
    Specified by:
    
    cancel in interface Query<T>
  - isCancelled
```
public boolean isCancelled()
```
    Description copied from interface: SpiQuery
    
    Return true if this query has been cancelled.
    
    Specified by:
    
    isCancelled in interface SpiQuery<T>

Class DefaultOrmQuery<T>

Property Summary

Nested Class Summary

Nested classes/interfaces inherited from interface com.avaje.ebeaninternal.api.SpiQuery

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Property Detail

selectAllForLazyLoad

Constructor Detail

DefaultOrmQuery

DefaultOrmQuery

Method Detail

getTotalHits

setTotalHits

setBeanDescriptor

selectAllForLazyLoadProperty

getRawSql

setRawSql

getLazyLoadProperty

setLazyLoadProperty

getLazyLoadManyPath

getExpressionFactory

initManyWhereJoins

getManyWhereJoins

removeQueryJoins

removeLazyJoins

setLazyLoadManyPath

convertManyFetchJoinsToQueryJoins

setSelectId

convertWhereNaturalKeyToId

getNaturalKeyBindParam

copy

getType

setType

getLoadDescription

getLoadMode

setLoadDescription

getPersistenceContext

setPersistenceContext

setLazyLoadForParents

getLazyLoadForParentIds

getLazyLoadForParentsProperty

isDetailEmpty

isAutofetchTuned

setAutoFetchTuned

isAutofetch

isForUpdate

setAutoFetch

setAutofetch

setForUpdate

getAutoFetchManager

setAutoFetchManager

getMode

setMode

isUsageProfiling

setUsageProfiling

setParentNode

getParentNode

setOrigin

queryAutofetchHash

queryPlanHash

queryBindHash

queryHash

getName

isSqlSelect

isRawSql

getAdditionalWhere

getTimeout

getAdditionalHaving

hasMaxRowsOrFirstRow

isReadOnly

setReadOnly

isUseBeanCache

isUseQueryCache

setUseCache

setUseQueryCache

isLoadBeanCache

setLoadBeanCache

setTimeout