EbeanQuery (ACT Ebean 1.6.1 API)

java.lang.Object
- act.db.ebean.EbeanQuery<MODEL_TYPE>

All Implemented Interfaces:: act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>, io.ebean.Query<MODEL_TYPE>

public class EbeanQuery<MODEL_TYPE>
extends Object
implements io.ebean.Query<MODEL_TYPE>, act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>

Nested Class Summary
- Nested classes/interfaces inherited from interface io.ebean.Query
  io.ebean.Query.ForUpdate

Field Summary

Fields
Modifier and Type Field and Description

protected Class<MODEL_TYPE> modelType

Fields
Modifier and Type	Field and Description
`protected Class<MODEL_TYPE>`	`modelType`

Constructor Summary

Constructors
Constructor and Description

EbeanQuery()

EbeanQuery(EbeanDao dao, Class<MODEL_TYPE> modelType)

Constructors
Constructor and Description
`EbeanQuery()`
`EbeanQuery(EbeanDao dao, Class<MODEL_TYPE> modelType)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`EbeanQuery<MODEL_TYPE>`	`alias(String alias)`
`EbeanQuery<MODEL_TYPE>`	`apply(io.ebean.FetchPath fetchPath)`
`EbeanQuery<MODEL_TYPE>`	`asDraft()`
`<D> io.ebean.DtoQuery<D>`	`asDto(Class<D> aClass)`
`EbeanQuery<MODEL_TYPE>`	`asOf(Timestamp timestamp)`
`void`	`cancel()`
`void`	`consume(org.osgl.Lang.Visitor<MODEL_TYPE> visitor)`
`EbeanQuery<MODEL_TYPE>`	`copy()`
`long`	`count()`
`int`	`delete()`
`Iterable<MODEL_TYPE>`	`fetch()`
`EbeanQuery<MODEL_TYPE>`	`fetch(String path)`
`EbeanQuery<MODEL_TYPE>`	`fetch(String path, io.ebean.FetchConfig joinConfig)`
`EbeanQuery<MODEL_TYPE>`	`fetch(String path, String fetchProperties)`
`EbeanQuery<MODEL_TYPE>`	`fetch(String assocProperty, String fetchProperties, io.ebean.FetchConfig fetchConfig)`
`EbeanQuery<MODEL_TYPE>`	`fetchLazy(String path)`
`EbeanQuery<MODEL_TYPE>`	`fetchLazy(String path, String fetchProperties)`
`EbeanQuery<MODEL_TYPE>`	`fetchQuery(String path)`
`EbeanQuery<MODEL_TYPE>`	`fetchQuery(String path, String fetchProperties)`
`io.ebean.ExpressionList<MODEL_TYPE>`	`filterMany(String propertyName)`
`int`	`findCount()`
`void`	`findEach(Consumer<MODEL_TYPE> consumer)`
`void`	`findEachWhile(Predicate<MODEL_TYPE> consumer)`
`io.ebean.FutureRowCount<MODEL_TYPE>`	`findFutureCount()`
`io.ebean.FutureIds<MODEL_TYPE>`	`findFutureIds()`
`io.ebean.FutureList<MODEL_TYPE>`	`findFutureList()`
`<A> List<A>`	`findIds()`
`io.ebean.QueryIterator<MODEL_TYPE>`	`findIterate()`
`List<MODEL_TYPE>`	`findList()`
`<K> Map<K,MODEL_TYPE>`	`findMap()`
`MODEL_TYPE`	`findOne()`
`Optional<MODEL_TYPE>`	`findOneOrEmpty()`
`io.ebean.PagedList<MODEL_TYPE>`	`findPagedList()`
`Set<MODEL_TYPE>`	`findSet()`
`<A> A`	`findSingleAttribute()`
`<A> List<A>`	`findSingleAttributeList()`
`List<io.ebean.Version<MODEL_TYPE>>`	`findVersions()`
`List<io.ebean.Version<MODEL_TYPE>>`	`findVersionsBetween(Timestamp timestamp, Timestamp timestamp1)`
`MODEL_TYPE`	`first()`
`EbeanQuery<MODEL_TYPE>`	`forUpdate()`
`EbeanQuery<MODEL_TYPE>`	`forUpdateNoWait()`
`EbeanQuery<MODEL_TYPE>`	`forUpdateSkipLocked()`
`Class<MODEL_TYPE>`	`getBeanType()`
`io.ebean.ExpressionFactory`	`getExpressionFactory()`
`int`	`getFirstRow()`
`io.ebean.Query.ForUpdate`	`getForUpdateMode()`
`String`	`getGeneratedSql()`
`Object`	`getId()`
`int`	`getMaxRows()`
`io.ebean.QueryType`	`getQueryType()`
`io.ebean.ExpressionList<MODEL_TYPE>`	`having()`
`EbeanQuery<MODEL_TYPE>`	`having(io.ebean.Expression addExpressionToHaving)`
`boolean`	`isAutoTuned()`
`boolean`	`isCountDistinct()`
`boolean`	`isForUpdate()`
`EbeanQuery<MODEL_TYPE>`	`limit(int limit)`
`EbeanQuery<MODEL_TYPE>`	`offset(int pos)`
`io.ebean.OrderBy<MODEL_TYPE>`	`order()`
`EbeanQuery<MODEL_TYPE>`	`order(String orderByClause)`
`io.ebean.OrderBy<MODEL_TYPE>`	`orderBy()`
`EbeanQuery<MODEL_TYPE>`	`orderBy(String... fieldList)`
`EbeanQuery<MODEL_TYPE>`	`orderBy(String orderByClause)`
`io.ebean.Query<MODEL_TYPE>`	`orderById(boolean b)`
`io.ebean.Query<MODEL_TYPE>`	`rawQuery()`
`EbeanQuery<MODEL_TYPE>`	`select(String fetchProperties)`
`EbeanQuery<MODEL_TYPE>`	`setAutoTune(boolean b)`
`io.ebean.Query<MODEL_TYPE>`	`setBeanCacheMode(io.ebean.CacheMode beanCacheMode)`
`EbeanQuery<MODEL_TYPE>`	`setBufferFetchSizeHint(int fetchSize)`
`io.ebean.Query<MODEL_TYPE>`	`setCountDistinct(io.ebean.CountDistinctOrder countDistinctOrder)`
`EbeanQuery<MODEL_TYPE>`	`setDisableLazyLoading(boolean b)`
`EbeanQuery<MODEL_TYPE>`	`setDisableReadAuditing()`
`EbeanQuery<MODEL_TYPE>`	`setDistinct(boolean isDistinct)`
`EbeanQuery<MODEL_TYPE>`	`setDocIndexName(String indexName)`
`EbeanQuery<MODEL_TYPE>`	`setFirstRow(int firstRow)`
`EbeanQuery<MODEL_TYPE>`	`setForUpdate(boolean forUpdate)`
`EbeanQuery<MODEL_TYPE>`	`setId(Object id)`
`EbeanQuery<MODEL_TYPE>`	`setIncludeSoftDeletes()`
`io.ebean.Query<MODEL_TYPE>`	`setLabel(String s)`
`EbeanQuery<MODEL_TYPE>`	`setLazyLoadBatchSize(int lazyLoadBatchSize)`
`EbeanQuery<MODEL_TYPE>`	`setLoadBeanCache(boolean loadBeanCache)`
`EbeanQuery<MODEL_TYPE>`	`setMapKey(String mapKey)`
`EbeanQuery<MODEL_TYPE>`	`setMaxRows(int maxRows)`
`EbeanQuery<MODEL_TYPE>`	`setOrder(io.ebean.OrderBy<MODEL_TYPE> orderBy)`
`EbeanQuery<MODEL_TYPE>`	`setOrderBy(io.ebean.OrderBy<MODEL_TYPE> orderBy)`
`EbeanQuery<MODEL_TYPE>`	`setParameter(int position, Object value)`
`EbeanQuery<MODEL_TYPE>`	`setParameter(String name, Object value)`
`EbeanQuery<MODEL_TYPE>`	`setPersistenceContextScope(io.ebean.PersistenceContextScope scope)`
`EbeanQuery<MODEL_TYPE>`	`setProfileId(int i)`
`io.ebean.Query<MODEL_TYPE>`	`setProfileLocation(io.ebean.ProfileLocation profileLocation)`
`EbeanQuery<MODEL_TYPE>`	`setRawSql(io.ebean.RawSql rawSql)`
`EbeanQuery<MODEL_TYPE>`	`setReadOnly(boolean readOnly)`
`EbeanQuery<MODEL_TYPE>`	`setTimeout(int secs)`
`EbeanQuery<MODEL_TYPE>`	`setUseCache(boolean useBeanCache)`
`EbeanQuery<MODEL_TYPE>`	`setUseDocStore(boolean b)`
`EbeanQuery<MODEL_TYPE>`	`setUseQueryCache(boolean useQueryCache)`
`EbeanQuery<MODEL_TYPE>`	`setUseQueryCache(io.ebean.CacheMode useQueryCache)`
`io.ebean.ExpressionList<MODEL_TYPE>`	`text()`
`int`	`update()`
`Set<String>`	`validate()`
`io.ebean.ExpressionList<MODEL_TYPE>`	`where()`
`EbeanQuery<MODEL_TYPE>`	`where(io.ebean.Expression expression)`

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

- Field Detail
  - modelType
```
protected Class<MODEL_TYPE> modelType
```
- Constructor Detail
  - EbeanQuery
```
public EbeanQuery()
```
  - EbeanQuery
```
public EbeanQuery(EbeanDao dao,
                  Class<MODEL_TYPE> modelType)
```
- Method Detail
  - rawQuery
```
public io.ebean.Query<MODEL_TYPE> rawQuery()
```
  - asOf
```
public EbeanQuery<MODEL_TYPE> asOf(Timestamp timestamp)
```
    Specified by:
    
    asOf in interface io.ebean.Query<MODEL_TYPE>
  - findSingleAttribute
```
public <A> A findSingleAttribute()
```
    Specified by:
    
    findSingleAttribute in interface io.ebean.Query<MODEL_TYPE>
  - findVersions
```
public List<io.ebean.Version<MODEL_TYPE>> findVersions()
```
    Specified by:
    
    findVersions in interface io.ebean.Query<MODEL_TYPE>
  - findVersionsBetween
```
public List<io.ebean.Version<MODEL_TYPE>> findVersionsBetween(Timestamp timestamp,
                                                              Timestamp timestamp1)
```
    Specified by:
    
    findVersionsBetween in interface io.ebean.Query<MODEL_TYPE>
  - apply
```
public EbeanQuery<MODEL_TYPE> apply(io.ebean.FetchPath fetchPath)
```
    Specified by:
    
    apply in interface io.ebean.Query<MODEL_TYPE>
  - text
```
public io.ebean.ExpressionList<MODEL_TYPE> text()
```
    Specified by:
    
    text in interface io.ebean.Query<MODEL_TYPE>
  - setUseDocStore
```
public EbeanQuery<MODEL_TYPE> setUseDocStore(boolean b)
```
    Specified by:
    
    setUseDocStore in interface io.ebean.Query<MODEL_TYPE>
  - setBeanCacheMode
```
public io.ebean.Query<MODEL_TYPE> setBeanCacheMode(io.ebean.CacheMode beanCacheMode)
```
    Specified by:
    
    setBeanCacheMode in interface io.ebean.Query<MODEL_TYPE>
  - setProfileLocation
```
public io.ebean.Query<MODEL_TYPE> setProfileLocation(io.ebean.ProfileLocation profileLocation)
```
    Specified by:
    
    setProfileLocation in interface io.ebean.Query<MODEL_TYPE>
  - update
```
public int update()
```
    Specified by:
    
    update in interface io.ebean.Query<MODEL_TYPE>
  - delete
```
public int delete()
```
    Specified by:
    
    delete in interface io.ebean.Query<MODEL_TYPE>
  - getId
```
public Object getId()
```
    Specified by:
    
    getId in interface io.ebean.Query<MODEL_TYPE>
  - getBeanType
```
public Class<MODEL_TYPE> getBeanType()
```
    Specified by:
    
    getBeanType in interface io.ebean.Query<MODEL_TYPE>
  - setDisableLazyLoading
```
public EbeanQuery<MODEL_TYPE> setDisableLazyLoading(boolean b)
```
    Specified by:
    
    setDisableLazyLoading in interface io.ebean.Query<MODEL_TYPE>
  - offset
```
public EbeanQuery<MODEL_TYPE> offset(int pos)
```
    Specified by:
    
    offset in interface act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>
  - limit
```
public EbeanQuery<MODEL_TYPE> limit(int limit)
```
    Specified by:
    
    limit in interface act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>
  - orderBy
```
public EbeanQuery<MODEL_TYPE> orderBy(String... fieldList)
```
    Specified by:
    
    orderBy in interface act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>
  - first
```
public MODEL_TYPE first()
```
    Specified by:
    
    first in interface act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>
  - fetchQuery
```
public EbeanQuery<MODEL_TYPE> fetchQuery(String path,
                                         String fetchProperties)
```
    Specified by:
    
    fetchQuery in interface io.ebean.Query<MODEL_TYPE>
  - fetchLazy
```
public EbeanQuery<MODEL_TYPE> fetchLazy(String path,
                                        String fetchProperties)
```
    Specified by:
    
    fetchLazy in interface io.ebean.Query<MODEL_TYPE>
  - fetchQuery
```
public EbeanQuery<MODEL_TYPE> fetchQuery(String path)
```
    Specified by:
    
    fetchQuery in interface io.ebean.Query<MODEL_TYPE>
  - fetchLazy
```
public EbeanQuery<MODEL_TYPE> fetchLazy(String path)
```
    Specified by:
    
    fetchLazy in interface io.ebean.Query<MODEL_TYPE>
  - fetch
```
public Iterable<MODEL_TYPE> fetch()
```
    Specified by:
    
    fetch in interface act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>
  - count
```
public long count()
```
    Specified by:
    
    count in interface act.db.Dao.Query<MODEL_TYPE,EbeanQuery<MODEL_TYPE>>
  - setIncludeSoftDeletes
```
public EbeanQuery<MODEL_TYPE> setIncludeSoftDeletes()
```
    Specified by:
    
    setIncludeSoftDeletes in interface io.ebean.Query<MODEL_TYPE>
  - asDraft
```
public EbeanQuery<MODEL_TYPE> asDraft()
```
    Specified by:
    
    asDraft in interface io.ebean.Query<MODEL_TYPE>
  - isAutoTuned
```
public boolean isAutoTuned()
```
    Specified by:
    
    isAutoTuned in interface io.ebean.Query<MODEL_TYPE>
  - setAutoTune
```
public EbeanQuery<MODEL_TYPE> setAutoTune(boolean b)
```
    Specified by:
    
    setAutoTune in interface io.ebean.Query<MODEL_TYPE>
  - setDisableReadAuditing
```
public EbeanQuery<MODEL_TYPE> setDisableReadAuditing()
```
    Specified by:
    
    setDisableReadAuditing in interface io.ebean.Query<MODEL_TYPE>
  - setUseQueryCache
```
public EbeanQuery<MODEL_TYPE> setUseQueryCache(io.ebean.CacheMode useQueryCache)
```
    Specified by:
    
    setUseQueryCache in interface io.ebean.Query<MODEL_TYPE>
  - setProfileId
```
public EbeanQuery<MODEL_TYPE> setProfileId(int i)
```
    Specified by:
    
    setProfileId in interface io.ebean.Query<MODEL_TYPE>
  - setRawSql
```
public EbeanQuery<MODEL_TYPE> setRawSql(io.ebean.RawSql rawSql)
```
    Specified by:
    
    setRawSql in interface io.ebean.Query<MODEL_TYPE>
  - setDocIndexName
```
public EbeanQuery<MODEL_TYPE> setDocIndexName(String indexName)
```
    Specified by:
    
    setDocIndexName in interface io.ebean.Query<MODEL_TYPE>
  - findEach
```
public void findEach(Consumer<MODEL_TYPE> consumer)
```
    Specified by:
    
    findEach in interface io.ebean.Query<MODEL_TYPE>
  - findEachWhile
```
public void findEachWhile(Predicate<MODEL_TYPE> consumer)
```
    Specified by:
    
    findEachWhile in interface io.ebean.Query<MODEL_TYPE>
  - forUpdate
```
public EbeanQuery<MODEL_TYPE> forUpdate()
```
    Specified by:
    
    forUpdate in interface io.ebean.Query<MODEL_TYPE>
  - forUpdateNoWait
```
public EbeanQuery<MODEL_TYPE> forUpdateNoWait()
```
    Specified by:
    
    forUpdateNoWait in interface io.ebean.Query<MODEL_TYPE>
  - forUpdateSkipLocked
```
public EbeanQuery<MODEL_TYPE> forUpdateSkipLocked()
```
    Specified by:
    
    forUpdateSkipLocked in interface io.ebean.Query<MODEL_TYPE>
  - getForUpdateMode
```
public io.ebean.Query.ForUpdate getForUpdateMode()
```
    Specified by:
    
    getForUpdateMode in interface io.ebean.Query<MODEL_TYPE>
  - cancel
```
public void cancel()
```
    Specified by:
    
    cancel in interface io.ebean.Query<MODEL_TYPE>
  - copy
```
public EbeanQuery<MODEL_TYPE> copy()
```
    Specified by:
    
    copy in interface io.ebean.Query<MODEL_TYPE>
  - setPersistenceContextScope
```
public EbeanQuery<MODEL_TYPE> setPersistenceContextScope(io.ebean.PersistenceContextScope scope)
```
    Specified by:
    
    setPersistenceContextScope in interface io.ebean.Query<MODEL_TYPE>
  - getExpressionFactory
```
public io.ebean.ExpressionFactory getExpressionFactory()
```
    Specified by:
    
    getExpressionFactory in interface io.ebean.Query<MODEL_TYPE>
  - setLazyLoadBatchSize
```
public EbeanQuery<MODEL_TYPE> setLazyLoadBatchSize(int lazyLoadBatchSize)
```
    Specified by:
    
    setLazyLoadBatchSize in interface io.ebean.Query<MODEL_TYPE>
  - select
```
public EbeanQuery<MODEL_TYPE> select(String fetchProperties)
```
    Specified by:
    
    select in interface io.ebean.Query<MODEL_TYPE>
  - fetch
```
public EbeanQuery<MODEL_TYPE> fetch(String path,
                                    String fetchProperties)
```
    Specified by:
    
    fetch in interface io.ebean.Query<MODEL_TYPE>
  - fetch
```
public EbeanQuery<MODEL_TYPE> fetch(String assocProperty,
                                    String fetchProperties,
                                    io.ebean.FetchConfig fetchConfig)
```
    Specified by:
    
    fetch in interface io.ebean.Query<MODEL_TYPE>
  - fetch
```
public EbeanQuery<MODEL_TYPE> fetch(String path)
```
    Specified by:
    
    fetch in interface io.ebean.Query<MODEL_TYPE>
  - fetch
```
public EbeanQuery<MODEL_TYPE> fetch(String path,
                                    io.ebean.FetchConfig joinConfig)
```
    Specified by:
    
    fetch in interface io.ebean.Query<MODEL_TYPE>
  - findIds
```
public <A> List<A> findIds()
```
    Specified by:
    
    findIds in interface io.ebean.Query<MODEL_TYPE>
  - findIterate
```
public io.ebean.QueryIterator<MODEL_TYPE> findIterate()
```
    Specified by:
    
    findIterate in interface io.ebean.Query<MODEL_TYPE>
  - isCountDistinct
```
public boolean isCountDistinct()
```
    Specified by:
    
    isCountDistinct in interface io.ebean.Query<MODEL_TYPE>
  - setCountDistinct
```
public io.ebean.Query<MODEL_TYPE> setCountDistinct(io.ebean.CountDistinctOrder countDistinctOrder)
```
    Specified by:
    
    setCountDistinct in interface io.ebean.Query<MODEL_TYPE>
  - getQueryType
```
public io.ebean.QueryType getQueryType()
```
    Specified by:
    
    getQueryType in interface io.ebean.Query<MODEL_TYPE>
  - orderById
```
public io.ebean.Query<MODEL_TYPE> orderById(boolean b)
```
    Specified by:
    
    orderById in interface io.ebean.Query<MODEL_TYPE>
  - consume
```
public void consume(org.osgl.Lang.Visitor<MODEL_TYPE> visitor)
```
  - findList
```
public List<MODEL_TYPE> findList()
```
    Specified by:
    
    findList in interface io.ebean.Query<MODEL_TYPE>
  - findSet
```
public Set<MODEL_TYPE> findSet()
```
    Specified by:
    
    findSet in interface io.ebean.Query<MODEL_TYPE>
  - findMap
```
public <K> Map<K,MODEL_TYPE> findMap()
```
    Specified by:
    
    findMap in interface io.ebean.Query<MODEL_TYPE>
  - findSingleAttributeList
```
public <A> List<A> findSingleAttributeList()
```
    Specified by:
    
    findSingleAttributeList in interface io.ebean.Query<MODEL_TYPE>
  - findCount
```
public int findCount()
```
    Specified by:
    
    findCount in interface io.ebean.Query<MODEL_TYPE>
  - findOne
```
public MODEL_TYPE findOne()
```
    Specified by:
    
    findOne in interface io.ebean.Query<MODEL_TYPE>
  - findOneOrEmpty
```
public Optional<MODEL_TYPE> findOneOrEmpty()
```
    Specified by:
    
    findOneOrEmpty in interface io.ebean.Query<MODEL_TYPE>
  - findFutureCount
```
public io.ebean.FutureRowCount<MODEL_TYPE> findFutureCount()
```
    Specified by:
    
    findFutureCount in interface io.ebean.Query<MODEL_TYPE>
  - findFutureIds
```
public io.ebean.FutureIds<MODEL_TYPE> findFutureIds()
```
    Specified by:
    
    findFutureIds in interface io.ebean.Query<MODEL_TYPE>
  - findFutureList
```
public io.ebean.FutureList<MODEL_TYPE> findFutureList()
```
    Specified by:
    
    findFutureList in interface io.ebean.Query<MODEL_TYPE>
  - setParameter
```
public EbeanQuery<MODEL_TYPE> setParameter(String name,
                                           Object value)
```
    Specified by:
    
    setParameter in interface io.ebean.Query<MODEL_TYPE>
  - setParameter
```
public EbeanQuery<MODEL_TYPE> setParameter(int position,
                                           Object value)
```
    Specified by:
    
    setParameter in interface io.ebean.Query<MODEL_TYPE>
  - setId
```
public EbeanQuery<MODEL_TYPE> setId(Object id)
```
    Specified by:
    
    setId in interface io.ebean.Query<MODEL_TYPE>
  - where
```
public EbeanQuery<MODEL_TYPE> where(io.ebean.Expression expression)
```
    Specified by:
    
    where in interface io.ebean.Query<MODEL_TYPE>
  - where
```
public io.ebean.ExpressionList<MODEL_TYPE> where()
```
    Specified by:
    
    where in interface io.ebean.Query<MODEL_TYPE>
  - filterMany
```
public io.ebean.ExpressionList<MODEL_TYPE> filterMany(String propertyName)
```
    Specified by:
    
    filterMany in interface io.ebean.Query<MODEL_TYPE>
  - having
```
public io.ebean.ExpressionList<MODEL_TYPE> having()
```
    Specified by:
    
    having in interface io.ebean.Query<MODEL_TYPE>
  - having
```
public EbeanQuery<MODEL_TYPE> having(io.ebean.Expression addExpressionToHaving)
```
    Specified by:
    
    having in interface io.ebean.Query<MODEL_TYPE>
  - orderBy
```
public EbeanQuery<MODEL_TYPE> orderBy(String orderByClause)
```
    Specified by:
    
    orderBy in interface io.ebean.Query<MODEL_TYPE>
  - order
```
public EbeanQuery<MODEL_TYPE> order(String orderByClause)
```
    Specified by:
    
    order in interface io.ebean.Query<MODEL_TYPE>
  - order
```
public io.ebean.OrderBy<MODEL_TYPE> order()
```
    Specified by:
    
    order in interface io.ebean.Query<MODEL_TYPE>
  - orderBy
```
public io.ebean.OrderBy<MODEL_TYPE> orderBy()
```
    Specified by:
    
    orderBy in interface io.ebean.Query<MODEL_TYPE>
  - setOrder
```
public EbeanQuery<MODEL_TYPE> setOrder(io.ebean.OrderBy<MODEL_TYPE> orderBy)
```
    Specified by:
    
    setOrder in interface io.ebean.Query<MODEL_TYPE>
  - setOrderBy
```
public EbeanQuery<MODEL_TYPE> setOrderBy(io.ebean.OrderBy<MODEL_TYPE> orderBy)
```
    Specified by:
    
    setOrderBy in interface io.ebean.Query<MODEL_TYPE>
  - setDistinct
```
public EbeanQuery<MODEL_TYPE> setDistinct(boolean isDistinct)
```
    Specified by:
    
    setDistinct in interface io.ebean.Query<MODEL_TYPE>
  - getFirstRow
```
public int getFirstRow()
```
    Specified by:
    
    getFirstRow in interface io.ebean.Query<MODEL_TYPE>
  - setFirstRow
```
public EbeanQuery<MODEL_TYPE> setFirstRow(int firstRow)
```
    Specified by:
    
    setFirstRow in interface io.ebean.Query<MODEL_TYPE>
  - getMaxRows
```
public int getMaxRows()
```
    Specified by:
    
    getMaxRows in interface io.ebean.Query<MODEL_TYPE>
  - setMaxRows
```
public EbeanQuery<MODEL_TYPE> setMaxRows(int maxRows)
```
    Specified by:
    
    setMaxRows in interface io.ebean.Query<MODEL_TYPE>
  - setMapKey
```
public EbeanQuery<MODEL_TYPE> setMapKey(String mapKey)
```
    Specified by:
    
    setMapKey in interface io.ebean.Query<MODEL_TYPE>
  - setUseCache
```
public EbeanQuery<MODEL_TYPE> setUseCache(boolean useBeanCache)
```
    Specified by:
    
    setUseCache in interface io.ebean.Query<MODEL_TYPE>
  - setUseQueryCache
```
public EbeanQuery<MODEL_TYPE> setUseQueryCache(boolean useQueryCache)
```
    Specified by:
    
    setUseQueryCache in interface io.ebean.Query<MODEL_TYPE>
  - setReadOnly
```
public EbeanQuery<MODEL_TYPE> setReadOnly(boolean readOnly)
```
    Specified by:
    
    setReadOnly in interface io.ebean.Query<MODEL_TYPE>
  - setLoadBeanCache
```
public EbeanQuery<MODEL_TYPE> setLoadBeanCache(boolean loadBeanCache)
```
    Specified by:
    
    setLoadBeanCache in interface io.ebean.Query<MODEL_TYPE>
  - setTimeout
```
public EbeanQuery<MODEL_TYPE> setTimeout(int secs)
```
    Specified by:
    
    setTimeout in interface io.ebean.Query<MODEL_TYPE>
  - setBufferFetchSizeHint
```
public EbeanQuery<MODEL_TYPE> setBufferFetchSizeHint(int fetchSize)
```
    Specified by:
    
    setBufferFetchSizeHint in interface io.ebean.Query<MODEL_TYPE>
  - getGeneratedSql
```
public String getGeneratedSql()
```
    Specified by:
    
    getGeneratedSql in interface io.ebean.Query<MODEL_TYPE>
  - setForUpdate
```
public EbeanQuery<MODEL_TYPE> setForUpdate(boolean forUpdate)
```
    Specified by:
    
    setForUpdate in interface io.ebean.Query<MODEL_TYPE>
  - isForUpdate
```
public boolean isForUpdate()
```
    Specified by:
    
    isForUpdate in interface io.ebean.Query<MODEL_TYPE>
  - alias
```
public EbeanQuery<MODEL_TYPE> alias(String alias)
```
    Specified by:
    
    alias in interface io.ebean.Query<MODEL_TYPE>
  - findPagedList
```
public io.ebean.PagedList<MODEL_TYPE> findPagedList()
```
    Specified by:
    
    findPagedList in interface io.ebean.Query<MODEL_TYPE>
  - validate
```
public Set<String> validate()
```
    Specified by:
    
    validate in interface io.ebean.Query<MODEL_TYPE>
  - asDto
```
public <D> io.ebean.DtoQuery<D> asDto(Class<D> aClass)
```
    Specified by:
    
    asDto in interface io.ebean.Query<MODEL_TYPE>
  - setLabel
```
public io.ebean.Query<MODEL_TYPE> setLabel(String s)
```
    Specified by:
    
    setLabel in interface io.ebean.Query<MODEL_TYPE>

Class EbeanQuery<MODEL_TYPE>

Nested Class Summary

Nested classes/interfaces inherited from interface io.ebean.Query

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

modelType

Constructor Detail

EbeanQuery

EbeanQuery

Method Detail

rawQuery

asOf

findSingleAttribute

findVersions

findVersionsBetween

apply

text

setUseDocStore

setBeanCacheMode

setProfileLocation

update

delete

getId

getBeanType

setDisableLazyLoading

offset

limit

orderBy

first

fetchQuery

fetchLazy

fetchQuery

fetchLazy

fetch

count

setIncludeSoftDeletes

asDraft

isAutoTuned

setAutoTune

setDisableReadAuditing

setUseQueryCache

setProfileId

setRawSql

setDocIndexName

findEach

findEachWhile

forUpdate

forUpdateNoWait

forUpdateSkipLocked

getForUpdateMode

cancel

copy

setPersistenceContextScope

getExpressionFactory

setLazyLoadBatchSize

select

fetch

fetch

fetch

fetch

findIds

findIterate

isCountDistinct

setCountDistinct

getQueryType

orderById

consume

findList

findSet

findMap

findSingleAttributeList

findCount

findOne

findOneOrEmpty

findFutureCount

findFutureIds

findFutureList