com.avaje.ebean

Class Model.Find<I,T>

java.lang.Object

com.avaje.ebean.Model.Find<I,T>

Type Parameters:

I - The Id type. This is most often a Long but is also often a UUID or String.

T - The entity bean type

Direct Known Subclasses:

Model.Finder

Enclosing class:

Model

public abstract static class Model.Find<I,T>
extends Object

Helper object for performing queries.

Typically a Find instance is defined as a public static field on an entity bean class to provide a nice way to write queries.

Example use:

@Entity
public class Customer extends BaseModel {

  public static final Find<Long,Customer> find = new Find<Long,Customer>(){};

  ...

This enables you to write code like:

Customer customer = Customer.find.byId(42L);

List<Customer> customers =
    Customer.find
        .select("name, dateOfBirth")
        .findList();

Kotlin

In Kotlin you would typically create Find as a companion object.

  // kotlin
  companion object : Model.Find<Long, Product>() {}

Constructor Summary

Constructors

Modifier	Constructor and Description
	Find() Creates a finder for entity of type T with ID of type I.
protected	Find(String serverName, Class<T> type) Construct passing the class literal type of the entity type.

Method Summary

Modifier and Type	Method and Description
List<T>	all() Retrieves all entities of the given type.
Query<T>	apply(FetchPath fetchPath) Creates a query applying the path properties to set the select and fetch clauses.
T	byId(I id) Retrieves an entity by ID.
EbeanServer	db() Return the underlying 'default' EbeanServer.
EbeanServer	db(String server) Return typically a different EbeanServer to the default.
void	deleteById(I id) Delete a bean by Id.
Query<T>	fetch(String path) Specifies a path to load including all its properties.
Query<T>	fetch(String path, FetchConfig joinConfig) Additionally specifies a FetchConfig to specify a 'query join' and/or define the lazy loading query.
Query<T>	fetch(String path, String fetchProperties) Specifies a path to fetch with a specific list properties to include, to load a partial object.
Query<T>	fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig) Additionally specifies a FetchConfig to use a separate query or lazy loading to load this path.
Filter<T>	filter() Creates a filter for sorting and filtering lists of entities locally without going back to the database.
void	findEach(QueryEachConsumer<T> consumer) Execute the query consuming each bean one at a time.
void	findEachWhile(QueryEachWhileConsumer<T> consumer) Execute the query consuming each bean one at a time.
FutureRowCount<T>	findFutureRowCount() Executes a find row count query in a background thread.
List<Object>	findIds() Executes a query and returns the results as a list of IDs.
List<T>	findList() Retrieves all entities of the given type.
Map<?,T>	findMap() Retrieves all entities of the given type as a map of objects.
<K> Map<K,T>	findMap(String keyProperty, Class<K> keyType) Executes the query and returns the results as a map of the objects specifying the map key property.
int	findRowCount() Returns the total number of entities for this type.
Set<T>	findSet() Returns all the entities of the given type as a set.
ExpressionFactory	getExpressionFactory() Returns the ExpressionFactory used by this query.
I	nextId() Returns the next identity value.
Model.Finder<I,T>	on(String server) Creates a Finder for the named EbeanServer.
OrderBy<T>	order() Returns the order by clause so that you can append an ascending or descending property to the order by clause.
Query<T>	order(String orderByClause) Sets the order by clause, replacing the existing order by clause if there is one.
OrderBy<T>	orderBy() Returns the order by clause so that you can append an ascending or descending property to the order by clause.
Query<T>	orderBy(String orderByClause) Set the order by clause replacing the existing order by clause if there is one.
Query<T>	query() Creates a query.
T	ref(I id) Creates an entity reference for this ID.
Query<T>	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>	setAutoTune(boolean autoTune) Create a query with explicit 'AutoTune' use.
Query<T>	setFirstRow(int firstRow) Sets the first row to return for this query.
Query<T>	setForUpdate(boolean forUpdate) Create a query with the select with "for update" specified.
Query<T>	setId(Object id) Sets the ID value to query.
Query<T>	setLoadBeanCache(boolean loadBeanCache) Create a query specifying if the beans should be loaded into the L2 cache.
Query<T>	setMaxRows(int maxRows) Sets the maximum number of rows to return in the query.
Query<T>	setRawSql(RawSql rawSql) Create and return a new query based on the RawSql.
Query<T>	setReadOnly(boolean readOnly) Create a query specifying whether the returned beans will be read-only.
Query<T>	setUseCache(boolean useBeanCache) Create a query specifying if the L2 bean cache should be used.
Query<T>	setUseQueryCache(boolean useQueryCache) Create a query specifying if the L2 query cache should be used.
ExpressionList<T>	where() Adds expressions to the where clause with the ability to chain on the ExpressionList.

Methods inherited from class java.lang.Object

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

Constructor Detail

Find

public Find()

Creates a finder for entity of type T with ID of type I.

Typically you create Find as a public static field on each entity bean as the example below.

Note that Find is an abstract class and hence {} is required. This is done so that the type (class literal) of the entity bean can be derived from the generics parameter.

@Entity
public class Customer extends BaseModel {

  // Note the trailing {} as Find is an abstract class.
  // We do this so that we can derive the type literal Customer.class
  // via reflection
  public static final Find<Long,Customer> find = new Find<Long,Customer>(){};
  ...

This enables you to write code like:

Customer customer = Customer.find.byId(42L);

List<Customer> customers =
    Customer.find
       .select("name, email, dateOfBirth")
       .findList();

Kotlin

In Kotlin you would typically create it as a companion object.

  // kotlin
  companion object : Model.Find<Long, Product>() {}

Find

protected Find(String serverName,
               Class<T> type)

Construct passing the class literal type of the entity type.

Method Detail

db

public EbeanServer db()

Return the underlying 'default' EbeanServer.

This provides full access to the API such as explicit transaction demarcation etc.

db

public EbeanServer db(String server)

Return typically a different EbeanServer to the default.

This is equivilent to Ebean.getServer(String)

Parameters:

server - The name of the EbeanServer. If this is null then the default EbeanServer is returned.

on

public Model.Finder<I,T> on(String server)

Creates a Finder for the named EbeanServer.

Create and return a new Finder for a different server.

deleteById

public void deleteById(I id)

Delete a bean by Id.

Equivalent to EbeanServer.delete(Class, Object)

all

public List<T> all()

Retrieves all entities of the given type.

This is the same as (synonym for) findList()

byId

@Nullable
public T byId(I id)

Retrieves an entity by ID.

Equivalent to EbeanServer.find(Class, Object)

ref

public T ref(I id)

Creates an entity reference for this ID.

Equivalent to EbeanServer.getReference(Class, Object)

filter

public Filter<T> filter()

Creates a filter for sorting and filtering lists of entities locally without going back to the database.

Equivalent to EbeanServer.filter(Class)

query

public Query<T> query()

Creates a query.

Equivalent to EbeanServer.find(Class)

apply

public Query<T> apply(FetchPath fetchPath)

Creates a query applying the path properties to set the select and fetch clauses.

Equivalent to Query.apply(FetchPath)

nextId

public I nextId()

Returns the next identity value.

See Also:

EbeanServer.nextId(Class)

findIds

public List<Object> findIds()

Executes a query and returns the results as a list of IDs.

Equivalent to Query.findIds()

findEach

public void findEach(QueryEachConsumer<T> consumer)

Execute the query consuming each bean one at a time.

This is generally used to process large queries where unlike findList you do not want to hold all the results in memory at once but instead process them one at a time (requiring far less memory).

Equivalent to Query.findEach(QueryEachConsumer)

findEachWhile

public void findEachWhile(QueryEachWhileConsumer<T> consumer)

Execute the query consuming each bean one at a time.

Equivalent to Query.findEachWhile(QueryEachWhileConsumer)

This is similar to #findEach except that you return boolean true to continue processing beans and return false to stop processing early.

This is generally used to process large queries where unlike findList you do not want to hold all the results in memory at once but instead process them one at a time (requiring far less memory).

Equivalent to Query.findEachWhile(QueryEachWhileConsumer)

findList

public List<T> findList()

Retrieves all entities of the given type.

The same as all()

Equivalent to Query.findList()

findSet

public Set<T> findSet()

Returns all the entities of the given type as a set.

Equivalent to Query.findSet()

findMap

public Map<?,T> findMap()

Retrieves all entities of the given type as a map of objects.

Equivalent to Query.findMap()

findMap

public <K> Map<K,T> findMap(String keyProperty,
                            Class<K> keyType)

Executes the query and returns the results as a map of the objects specifying the map key property.

Equivalent to Query.findMap(String, Class)

findFutureRowCount

public FutureRowCount<T> findFutureRowCount()

Executes a find row count query in a background thread.

Equivalent to Query.findFutureRowCount()

findRowCount

public int findRowCount()

Returns the total number of entities for this type. *

Equivalent to Query.findRowCount()

getExpressionFactory

public ExpressionFactory getExpressionFactory()

Returns the ExpressionFactory used by this query.

select

public Query<T> select(String fetchProperties)

Explicitly sets a comma delimited list of the properties to fetch on the 'main' entity bean, to load a partial object.

Equivalent to Query.select(String)

fetch

public Query<T> fetch(String path)

Specifies a path to load including all its properties.

Equivalent to Query.fetch(String)

fetch

public Query<T> fetch(String path,
                      FetchConfig joinConfig)

Additionally specifies a FetchConfig to specify a 'query join' and/or define the lazy loading query.

Equivalent to Query.fetch(String, FetchConfig)

fetch

public Query<T> fetch(String path,
                      String fetchProperties)

Specifies a path to fetch with a specific list properties to include, to load a partial object.

Equivalent to Query.fetch(String, String)

fetch

public Query<T> fetch(String assocProperty,
                      String fetchProperties,
                      FetchConfig fetchConfig)

Additionally specifies a FetchConfig to use a separate query or lazy loading to load this path.

Equivalent to Query.fetch(String, String, FetchConfig)

where

public ExpressionList<T> where()

Adds expressions to the where clause with the ability to chain on the ExpressionList.

Equivalent to Query.where()

order

public OrderBy<T> order()

Returns the order by clause so that you can append an ascending or descending property to the order by clause.

This is exactly the same as orderBy().

Equivalent to Query.order()

order

public Query<T> order(String orderByClause)

Sets the order by clause, replacing the existing order by clause if there is one.

This is exactly the same as orderBy(String).

orderBy

public OrderBy<T> orderBy()

Returns the order by clause so that you can append an ascending or descending property to the order by clause.

This is exactly the same as order().

Equivalent to Query.orderBy()

orderBy

public Query<T> orderBy(String orderByClause)

Set the order by clause replacing the existing order by clause if there is one.

This is exactly the same as order(String).

setFirstRow

public Query<T> setFirstRow(int firstRow)

Sets the first row to return for this query.

Equivalent to Query.setFirstRow(int)

setMaxRows

public Query<T> setMaxRows(int maxRows)

Sets the maximum number of rows to return in the query.

Equivalent to Query.setMaxRows(int)

setId

public Query<T> setId(Object id)

Sets the ID value to query.

Use this to perform a find byId query but with additional control over the query such as using select and fetch to control what parts of the object graph are returned.

Equivalent to Query.setId(Object)

setRawSql

public Query<T> setRawSql(RawSql rawSql)

Create and return a new query based on the RawSql.

Equivalent to Query.setRawSql(RawSql)

setAutoTune

public Query<T> setAutoTune(boolean autoTune)

Create a query with explicit 'AutoTune' use.

setForUpdate

public Query<T> setForUpdate(boolean forUpdate)

Create a query with the select with "for update" specified.

This will typically create row level database locks on the selected rows.

setReadOnly

public Query<T> setReadOnly(boolean readOnly)

Create a query specifying whether the returned beans will be read-only.

setLoadBeanCache

public Query<T> setLoadBeanCache(boolean loadBeanCache)

Create a query specifying if the beans should be loaded into the L2 cache.

setUseCache

public Query<T> setUseCache(boolean useBeanCache)

Create a query specifying if the L2 bean cache should be used.

setUseQueryCache

public Query<T> setUseQueryCache(boolean useQueryCache)

Create a query specifying if the L2 query cache should be used.