Uses of Interface
com.avaje.ebean.Query

Packages that use Query

Package	Description
com.avaje.ebean	Core API (see EbeanServer and Ebean).
com.avaje.ebean.config.dbplatform	Database platform specific support
com.avaje.ebean.event	Persist and Query Event Controllers and Listeners
com.avaje.ebean.plugin	Provides a API for plugins.
com.avaje.ebean.text	Utility objects for CSV, JSON and XML processing.
com.avaje.ebeanservice.docstore.api	The service API for document store integration.
com.avaje.ebeanservice.docstore.api.support	Support objects for implementing integration.
com.avaje.ebeanservice.docstore.none	"No op" implementation of document store.

Uses of Query in com.avaje.ebean

Methods in com.avaje.ebean that return Query

Modifier and Type	Method and Description
Query<T>	Query.alias(String alias) Set root table alias.
Query<T>	Model.Find.apply(FetchPath fetchPath) Creates a query applying the path properties to set the select and fetch clauses.
Query<T>	Query.apply(FetchPath fetchPath) Apply the path properties replacing the select and fetch clauses.
Query<T>	ExpressionList.apply(FetchPath fetchPath) Apply the path properties to the query replacing the select and fetch clauses.
Query<T>	OrderBy.asc(String propertyName) Add a property with ascending order to this OrderBy.
Query<T>	Query.asDraft() Execute the query against the draft set of tables.
Query<T>	ExpressionList.asDraft() Execute the query against the draft set of tables.
Query<T>	Query.asOf(Timestamp asOf) Perform an 'As of' query using history tables to return the object graph as of a time in the past.
Query<T>	ExpressionList.asOf(Timestamp asOf) Perform an 'As of' query using history tables to return the object graph as of a time in the past.
Query<T>	Query.copy() Return a copy of the query.
static <T> Query<T>	Ebean.createNamedQuery(Class<T> beanType, String namedQuery) Create a named query.
<T> Query<T>	EbeanServer.createNamedQuery(Class<T> beanType, String namedQuery) Create a named query.
static <T> Query<T>	Ebean.createQuery(Class<T> beanType) Create a query for a type of entity bean.
<T> Query<T>	EbeanServer.createQuery(Class<T> beanType) Create a query for an entity bean and synonym for EbeanServer.find(Class).
static <T> Query<T>	Ebean.createQuery(Class<T> beanType, String eql) Parse the Ebean query language statement returning the query which can then be modified (add expressions, change order by clause, change maxRows, change fetch and select paths etc).
<T> Query<T>	EbeanServer.createQuery(Class<T> beanType, String eql) Parse the Ebean query language statement returning the query which can then be modified (add expressions, change order by clause, change maxRows, change fetch and select paths etc).
Query<T>	OrderBy.desc(String propertyName) Add a property with descending order to this OrderBy.
Query<T>	Model.Find.fetch(String path) Specifies a path to load including all its properties.
Query<T>	Query.fetch(String path) Specify a path to fetch eagerly including all its properties.
Query<T>	Model.Find.fetch(String path, FetchConfig joinConfig) Additionally specifies a FetchConfig to specify a 'query join' and/or define the lazy loading query.
Query<T>	Query.fetch(String path, FetchConfig fetchConfig) Additionally specify a JoinConfig to specify a "query join" and or define the lazy loading query.
Query<T>	Model.Find.fetch(String path, String fetchProperties) Specifies a path to fetch with a specific list properties to include, to load a partial object.
Query<T>	Query.fetch(String path, String fetchProperties) Specify a path to fetch eagerly including specific properties.
Query<T>	Model.Find.fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig) Additionally specifies a FetchConfig to use a separate query or lazy loading to load this path.
Query<T>	Query.fetch(String path, String fetchProperties, FetchConfig fetchConfig) Additionally specify a FetchConfig to use a separate query or lazy loading to load this path.
Query<T>	Query.fetchLazy(String path) Fetch the path lazily (via batch lazy loading).
Query<T>	Query.fetchLazy(String path, String fetchProperties) Fetch the path and properties lazily (via batch lazy loading).
Query<T>	Query.fetchQuery(String path) Fetch the path eagerly using a "query join" (separate SQL query).
Query<T>	Query.fetchQuery(String path, String fetchProperties) Fetch the path and properties using a "query join" (separate SQL query).
static <T> Query<T>	Ebean.find(Class<T> beanType) Create a query for a type of entity bean.
<T> Query<T>	EbeanServer.find(Class<T> beanType) Create a query for a type of entity bean.
Query<T>	FutureIds.getQuery() Returns the original query used to fetch the Id's.
Query<T>	OrderBy.getQuery() Return the associated query if there is one.
Query<T>	FutureList.getQuery() Return the query that is being executed by a background thread.
Query<T>	Query.having(Expression addExpressionToHaving) Add an expression to the having clause returning the query.
Query<T>	ExpressionList.includeSoftDeletes() Deprecated.
Query<T>	Model.Find.order(String orderByClause) Sets the order by clause, replacing the existing order by clause if there is one.
Query<T>	Query.order(String orderByClause) Set the order by clause replacing the existing order by clause if there is one.
Query<T>	ExpressionList.order(String orderByClause) Set the order by clause replacing the existing order by clause if there is one.
Query<T>	Model.Find.orderBy(String orderByClause) Set the order by clause replacing the existing order by clause if there is one.
Query<T>	Query.orderBy(String orderByClause) Set the order by clause replacing the existing order by clause if there is one.
Query<T>	ExpressionList.orderBy(String orderBy) Add an orderBy clause to the query.
Query<T>	Finder.query() Creates a query.
Query<T>	Model.Find.query() Creates a query.
Query<T>	ExpressionList.query() Return the query that owns this expression list.
Query<T>	Model.Find.select(String fetchProperties) Explicitly sets a comma delimited list of the properties to fetch on the 'main' entity bean, to load a partial object.
Query<T>	Query.select(String fetchProperties) Specify the properties to fetch on the root level entity bean in comma delimited format.
Query<T>	ExpressionList.select(String properties) Specify specific properties to fetch on the main/root bean (aka partial object).
Query<T>	Model.Find.setAutoTune(boolean autoTune) Create a query with explicit 'AutoTune' use.
Query<T>	Query.setAutoTune(boolean autoTune) Explicitly specify whether to use AutoTune for this query.
Query<T>	Query.setBufferFetchSizeHint(int fetchSize) A hint which for JDBC translates to the Statement.fetchSize().
Query<T>	Query.setDisableLazyLoading(boolean disableLazyLoading) Set true if you want to disable lazy loading.
Query<T>	ExpressionList.setDisableLazyLoading(boolean disableLazyLoading) Set true if you want to disable lazy loading.
Query<T>	Query.setDisableReadAuditing() Disable read auditing for this query.
Query<T>	ExpressionList.setDisableReadAuditing() Disable read auditing for this query.
Query<T>	Query.setDistinct(boolean isDistinct) Set whether this query uses DISTINCT.
Query<T>	ExpressionList.setDistinct(boolean distinct) Set whether this query uses DISTINCT.
Query<T>	Model.Find.setFirstRow(int firstRow) Sets the first row to return for this query.
Query<T>	Query.setFirstRow(int firstRow) Set the first row to return for this query.
Query<T>	ExpressionList.setFirstRow(int firstRow) Set the first row to fetch.
Query<T>	Model.Find.setForUpdate(boolean forUpdate) Create a query with the select with "for update" specified.
Query<T>	Query.setForUpdate(boolean forUpdate) executed the select with "for update" which should lock the record "on read"
Query<T>	Model.Find.setId(Object id) Sets the ID value to query.
Query<T>	Query.setId(Object id) Set the Id value to query.
Query<T>	Query.setIncludeSoftDeletes() Execute the query including soft deleted rows.
Query<T>	ExpressionList.setIncludeSoftDeletes() Execute the query including soft deleted rows.
Query<T>	Query.setLazyLoadBatchSize(int lazyLoadBatchSize) Set the default lazy loading batch size to use.
Query<T>	Model.Find.setLoadBeanCache(boolean loadBeanCache) Create a query specifying if the beans should be loaded into the L2 cache.
Query<T>	Query.setLoadBeanCache(boolean loadBeanCache) When set to true all the beans from this query are loaded into the bean cache.
Query<T>	Query.setMapKey(String mapKey) Set the property to use as keys for a map.
Query<T>	ExpressionList.setMapKey(String mapKey) Set the name of the property which values become the key of a map.
Query<T>	Model.Find.setMaxRows(int maxRows) Sets the maximum number of rows to return in the query.
Query<T>	Query.setMaxRows(int maxRows) Set the maximum number of rows to return in the query.
Query<T>	ExpressionList.setMaxRows(int maxRows) Set the maximum number of rows to fetch.
Query<T>	Query.setOrder(OrderBy<T> orderBy) Set an OrderBy object to replace any existing OrderBy clause.
Query<T>	Query.setOrderBy(OrderBy<T> orderBy) Set an OrderBy object to replace any existing OrderBy clause.
Query<T>	ExpressionList.setOrderBy(String orderBy) Add an orderBy clause to the query.
Query<T>	Query.setParameter(int position, Object value) Set an ordered bind parameter according to its position.
Query<T>	Query.setParameter(String name, Object value) Set a named bind parameter.
Query<T>	Query.setPersistenceContextScope(PersistenceContextScope scope) Specify the PersistenceContextScope to use for this query.
Query<T>	Model.Find.setRawSql(RawSql rawSql) Create and return a new query based on the RawSql.
Query<T>	Query.setRawSql(RawSql rawSql) Set RawSql to use for this query.
Query<T>	Model.Find.setReadOnly(boolean readOnly) Create a query specifying whether the returned beans will be read-only.
Query<T>	Query.setReadOnly(boolean readOnly) When set to true when you want the returned beans to be read only.
Query<T>	Query.setTimeout(int secs) Set a timeout on this query.
Query<T>	Model.Find.setUseCache(boolean useBeanCache) Create a query specifying if the L2 bean cache should be used.
Query<T>	Query.setUseCache(boolean useCache) Set this to false to not use the bean cache.
Query<T>	ExpressionList.setUseCache(boolean useCache) Set to true to use the query for executing this query.
Query<T>	Query.setUseDocStore(boolean useDocStore) Set to true if this query should execute against the doc store.
Query<T>	ExpressionList.setUseDocStore(boolean useDocsStore) Set to true if this query should execute against the doc store.
Query<T>	Model.Find.setUseQueryCache(boolean useQueryCache) Create a query specifying if the L2 query cache should be used.
Query<T>	Query.setUseQueryCache(boolean useQueryCache) Set this to true to use the query cache.
Query<T>	ExpressionList.setUseQueryCache(boolean useCache) Set to true to use the query for executing this query.
Query<T>	Query.where(Expression expression) Add a single Expression to the where clause returning the query.

Methods in com.avaje.ebean with parameters of type Query

Modifier and Type	Method and Description
<T> void	FetchPath.apply(Query<T> query) Apply the fetch path to the query.
static <T> Junction<T>	Expr.conjunction(Query<T> query) Return a list of expressions that will be joined by AND's.
<T> Junction<T>	ExpressionFactory.conjunction(Query<T> query) Return a list of expressions that will be joined by AND's.
<T> Junction<T>	ExpressionFactory.conjunction(Query<T> query, ExpressionList<T> parent) Return a list of expressions that will be joined by AND's.
long	DocumentStore.copyIndex(Query<?> query, String newIndex, int bulkBatchSize) Copy from a source index to a new index taking only the documents matching the given query.
<T> int	EbeanServer.delete(Query<T> query, Transaction transaction) Execute as a delete query deleting the 'root level' beans that match the predicates in the query.
static <T> Junction<T>	Expr.disjunction(Query<T> query) Return a list of expressions that will be joined by OR's.
<T> Junction<T>	ExpressionFactory.disjunction(Query<T> query) Return a list of expressions that will be joined by OR's.
<T> Junction<T>	ExpressionFactory.disjunction(Query<T> query, ExpressionList<T> parent) Return a list of expressions that will be joined by OR's.
<T> List<T>	EbeanServer.draftRestore(Query<T> query) Restore the draft beans matching the query back to the live state.
<T> List<T>	EbeanServer.draftRestore(Query<T> query, Transaction transaction) Restore the draft beans matching the query back to the live state.
ExpressionList<T>	ExpressionList.exists(Query<?> subQuery) Exists expression
Expression	ExpressionFactory.exists(Query<?> subQuery) Exists expression
<T> int	EbeanServer.findCount(Query<T> query, Transaction transaction) Return the number of 'top level' or 'root' entities this query should return.
<T> void	EbeanServer.findEach(Query<T> query, QueryEachConsumer<T> consumer, Transaction transaction) Execute the query visiting the each bean one at a time.
<T> void	EbeanServer.findEachWhile(Query<T> query, QueryEachWhileConsumer<T> consumer, Transaction transaction) Execute the query visiting the each bean one at a time.
<T> FutureRowCount<T>	EbeanServer.findFutureCount(Query<T> query, Transaction transaction) Execute find row count query in a background thread.
<T> FutureIds<T>	EbeanServer.findFutureIds(Query<T> query, Transaction transaction) Execute find Id's query in a background thread.
<T> FutureList<T>	EbeanServer.findFutureList(Query<T> query, Transaction transaction) Execute find list query in a background thread returning a FutureList object.
<T> FutureRowCount<T>	EbeanServer.findFutureRowCount(Query<T> query, Transaction transaction) Deprecated.
<T> List<Object>	EbeanServer.findIds(Query<T> query, Transaction transaction) Return the Id values of the query as a List.
<T> List<T>	EbeanServer.findList(Query<T> query, Transaction transaction) Execute a query returning a list of beans.
<T> Map<?,T>	EbeanServer.findMap(Query<T> query, Transaction transaction) Execute the query returning the entity beans in a Map.
<T> PagedList<T>	EbeanServer.findPagedList(Query<T> query, Transaction transaction) Return a PagedList for this query using firstRow and maxRows.
<T> int	EbeanServer.findRowCount(Query<T> query, Transaction transaction) Deprecated.
<T> Set<T>	EbeanServer.findSet(Query<T> query, Transaction transaction) Execute the query returning a set of entity beans.
<T> T	EbeanServer.findUnique(Query<T> query, Transaction transaction) Execute the query returning at most one entity bean or null (if no matching bean is found).
<T> List<Version<T>>	EbeanServer.findVersions(Query<T> query, Transaction transaction) Return versions of a @History entity bean.
ExpressionList<T>	ExpressionList.in(String propertyName, Query<?> subQuery) In - using a subQuery.
static Expression	Expr.in(String propertyName, Query<?> subQuery) In - using a subQuery.
Expression	ExpressionFactory.in(String propertyName, Query<?> subQuery) In - using a subQuery.
<T> void	DocumentStore.indexByQuery(Query<T> query) Update the associated document store using the result of the query.
<T> void	DocumentStore.indexByQuery(Query<T> query, int bulkBatchSize) Update the associated document store index using the result of the query additionally specifying a bulkBatchSize to use for sending the messages to ElasticSearch.
<T> Junction<T>	ExpressionFactory.junction(Junction.Type type, Query<T> query, ExpressionList<T> parent) Return a Text query junction for MUST, SHOULD or MUST NOT.
ExpressionList<T>	ExpressionList.notExists(Query<?> subQuery) Not exists expression
Expression	ExpressionFactory.notExists(Query<?> subQuery) Not exists expression
ExpressionList<T>	ExpressionList.notIn(String propertyName, Query<?> subQuery) Not In - using a subQuery.
Expression	ExpressionFactory.notIn(String propertyName, Query<?> subQuery) Not In - using a subQuery.
<T> List<T>	EbeanServer.publish(Query<T> query) Publish the beans that match the query returning the resulting published beans.
<T> List<T>	EbeanServer.publish(Query<T> query, Transaction transaction) Publish the beans that match the query returning the resulting published beans.
void	OrderBy.setQuery(Query<T> query) Associate this OrderBy with a query.
<T> int	EbeanServer.update(Query<T> query, Transaction transaction) Execute the update query returning the number of rows updated.
<T> Set<String>	EbeanServer.validateQuery(Query<T> query) Returns the set of properties/paths that are unknown (do not map to known properties or paths).

Constructors in com.avaje.ebean with parameters of type Query

Constructor and Description
OrderBy(Query<T> query, String orderByClause) Construct with a given query and order by clause.

Uses of Query in com.avaje.ebean.config.dbplatform

Methods in com.avaje.ebean.config.dbplatform that return Query

Modifier and Type	Method and Description
Query<?>	SqlLimitRequest.getOrmQuery() return the query

Methods in com.avaje.ebean.config.dbplatform with parameters of type Query

Modifier and Type	Method and Description
String	DatabasePlatform.completeSql(String sql, Query<?> query)

Uses of Query in com.avaje.ebean.event

Methods in com.avaje.ebean.event that return Query

Modifier and Type	Method and Description
Query<T>	BeanQueryRequest.getQuery() Returns the query.

Uses of Query in com.avaje.ebean.plugin

Methods in com.avaje.ebean.plugin with parameters of type Query

Modifier and Type	Method and Description
void	BeanDocType.applyPath(Query<T> spiQuery) Apply the appropriate fetch path to the query such that the query returns beans matching the document store structure with the expected embedded properties.

Uses of Query in com.avaje.ebean.text

Methods in com.avaje.ebean.text with parameters of type Query

Modifier and Type	Method and Description
<T> void	PathProperties.apply(Query<T> query) Apply these path properties as fetch paths to the query.

Uses of Query in com.avaje.ebeanservice.docstore.api

Methods in com.avaje.ebeanservice.docstore.api with parameters of type Query

Modifier and Type	Method and Description
void	DocStoreBeanAdapter.applyPath(Query<T> query) Apply the document structure to the query so that it fetches the required properties to build the document (typically in JSON form).

Uses of Query in com.avaje.ebeanservice.docstore.api.support

Methods in com.avaje.ebeanservice.docstore.api.support with parameters of type Query

Modifier and Type	Method and Description
void	DocStoreBeanBaseAdapter.applyPath(Query<T> query)

Uses of Query in com.avaje.ebeanservice.docstore.none

Methods in com.avaje.ebeanservice.docstore.none with parameters of type Query

Modifier and Type	Method and Description
long	NoneDocStore.copyIndex(Query<?> query, String newIndex, int bulkBatchSize)
<T> void	NoneDocStore.indexByQuery(Query<T> query)
<T> void	NoneDocStore.indexByQuery(Query<T> query, int bulkBatchSize)