Query (avaje-ebeanorm 3.4.2 API)

Type Parameters:
T - the type of Entity bean this query will fetch.

All Superinterfaces:

Serializable

All Known Subinterfaces:

SpiQuery<T>

All Known Implementing Classes:

DefaultOrmQuery
```
public interface Query<T>
extends Serializable
```
Object relational query for finding a List, Set, Map or single entity bean.
Example: Create the query using the API.
```
 List<Order> orderList = 
   Ebean.find(Order.class)
     .fetch("customer")
     .fetch("details")
     .where()
       .like("customer.name","rob%")
       .gt("orderDate",lastWeek)
     .orderBy("customer.id, id desc")
     .setMaxRows(50)
     .findList();
   
 ...
 
```
Example: The same query using the query language
```
 String oql = 
        "  find  order "
        +" fetch customer "
        +" fetch details "
        +" where customer.name like :custName and orderDate > :minOrderDate "
        +" order by customer.id, id desc "
        +" limit 50 ";
   
 Query<Order> query = Ebean.createQuery(Order.class, oql);
 query.setParameter("custName", "Rob%");
 query.setParameter("minOrderDate", lastWeek);
   
 List<Order> orderList = query.findList();
 ...
 
```
Example: Using a named query called "with.cust.and.details"
```
 Query<Order> query = Ebean.createNamedQuery(Order.class,"with.cust.and.details");
 query.setParameter("custName", "Rob%");
 query.setParameter("minOrderDate", lastWeek);
   
 List<Order> orderList = query.findList();
 ...
 
```
Autofetch

Ebean has built in support for "Autofetch". This is a mechanism where a query can be automatically tuned based on profiling information that is collected.

This is effectively the same as automatically using select() and fetch() to build a query that will fetch all the data required by the application and no more.

It is expected that Autofetch will be the default approach for many queries in a system. It is possibly not as useful where the result of a query is sent to a remote client or where there is some requirement for "Read Consistency" guarantees.

Query Language

Partial Objects

The find and fetch clauses support specifying a list of properties to fetch. This results in objects that are "partially populated". If you try to get a property that was not populated a "lazy loading" query will automatically fire and load the rest of the properties of the bean (This is very similar behaviour as a reference object being "lazy loaded").

Partial objects can be saved just like fully populated objects. If you do this you should remember to include the "Version" property in the initial fetch. If you do not include a version property then optimistic concurrency checking will occur but only include the fetched properties. Refer to "ALL Properties/Columns" mode of Optimistic Concurrency checking.
```
 [ find  {bean type} [ ( * | {fetch properties} ) ] ]
 [ fetch {associated bean} [ ( * | {fetch properties} ) ] ]
 [ where {predicates} ]
 [ order by {order by properties} ]
 [ limit {max rows} [ offset {first row} ] ]
 
```
FIND {bean type} [ ( * | {fetch properties} ) ]

With the find you specify the type of beans to fetch. You can optionally specify a list of properties to fetch. If you do not specify a list of properties ALL the properties for those beans are fetched.

In object graph terms the find clause specifies the type of bean at the root level and the fetch clauses specify the paths of the object graph to populate.

FETCH {associated property} [ ( * | {fetch properties} ) ]

With the fetch you specify the associated property to fetch and populate. The associated property is a OneToOnem, ManyToOne, OneToMany or ManyToMany property. When the query is executed Ebean will fetch the associated data.

For fetch of a path we can optionally specify a list of properties to fetch. If you do not specify a list of properties ALL the properties for that bean type are fetched.

WHERE {list of predicates}

The list of predicates which are joined by AND OR NOT ( and ). They can include named (or positioned) bind parameters. These parameters will need to be bound by setParameter(String, Object).

ORDER BY {order by properties}

The list of properties to order the result. You can include ASC (ascending) and DESC (descending) in the order by clause.

LIMIT {max rows} [ OFFSET {first row} ]

The limit offset specifies the max rows and first row to fetch. The offset is optional.

Examples of Ebean's Query Language

Find orders fetching all its properties
```
 find order
 
```
Find orders fetching all its properties
```
 find order (*)
 
```
Find orders fetching its id, shipDate and status properties. Note that the id property is always fetched even if it is not included in the list of fetch properties.
```
 find order (shipDate, status)
 
```
Find orders with a named bind variable (that will need to be bound via setParameter(String, Object)).
```
 find order
 where customer.name like :custLike
 
```
Find orders and also fetch the customer with a named bind parameter. This will fetch and populate both the order and customer objects.
```
 find  order
 fetch customer
 where customer.id = :custId
 
```
Find orders and also fetch the customer, customer shippingAddress, order details and related product. Note that customer and product objects will be "Partial Objects" with only some of their properties populated. The customer objects will have their id, name and shipping address populated. The product objects (associated with each order detail) will have their id, sku and name populated.
```
 find  order
 fetch customer (name)
 fetch customer.shippingAddress
 fetch details
 fetch details.product (sku, name)
 
```
Early parsing of the Query

When you get a Query object from a named query, the query statement has already been parsed. You can then add to that query (add fetch paths, add to the where clause) or override some of its settings (override the order by clause, first rows, max rows).

The thought is that you can use named queries as a 'starting point' and then modify the query to suit specific needs.

Building the Where clause

You can add to the where clause using Expression objects or a simple String. Note that the ExpressionList has methods to add most of the common expressions that you will need.
- where(String addToWhereClause)
- where().add(Expression expression)
- where().eq(propertyName, value).like(propertyName , value)...
The full WHERE clause is constructed by appending together
original query where clause (Named query or query.setQuery(String oql))
clauses added via query.where(String addToWhereClause)
clauses added by Expression objects

The above is the order that these are clauses are appended to give the full WHERE clause.

Design Goal

This query language is NOT designed to be a replacement for SQL. It is designed to be a simple way to describe the "Object Graph" you want Ebean to build for you. Each find/fetch represents a node in that "Object Graph" which makes it easy to define for each node which properties you want to fetch.

Once you hit the limits of this language such as wanting aggregate functions (sum, average, min etc) or recursive queries etc you use SQL. Ebean's goal is to make it as easy as possible to use your own SQL to populate entity beans. Refer to RawSql .

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`cancel()` Cancel the query execution if supported by the underlying database and driver.
`Query<T>`	`copy()` Return a copy of the query.
`Query<T>`	`fetch(String path)` Specify a path to load including all its properties.
`Query<T>`	`fetch(String path, FetchConfig joinConfig)` Additionally specify a JoinConfig to specify a "query join" and or define the lazy loading query.
`Query<T>`	`fetch(String path, String fetchProperties)` Specify a path to fetch with its specific properties to include (aka partial object).
`Query<T>`	`fetch(String assocProperty, String fetchProperties, FetchConfig fetchConfig)` Additionally specify a FetchConfig to use a separate query or lazy loading to load this path.
`ExpressionList<T>`	`filterMany(String propertyName)` 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.
`ExpressionFactory`	`getExpressionFactory()` Return the ExpressionFactory used by this query.
`int`	`getFirstRow()` Return the first row value.
`String`	`getGeneratedSql()` Return the sql that was generated for executing this query.
`int`	`getMaxRows()` Return the max rows for this query.
`RawSql`	`getRawSql()` Return the RawSql that was set to use for this query.
`ExpressionList<T>`	`having()` Add Expressions to the Having clause return the ExpressionList.
`Query<T>`	`having(Expression addExpressionToHaving)` Add an expression to the having clause returning the query.
`Query<T>`	`having(String addToHavingClause)` Add additional clause(s) to the having clause.
`boolean`	`isAutofetchTuned()` Returns true if this query was tuned by autoFetch.
`boolean`	`isForUpdate()` Return true if this query has forUpdate set.
`OrderBy<T>`	`order()` Return the OrderBy so that you can append an ascending or descending property to the order by clause.
`Query<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.
`Query<T>`	`orderBy(String orderByClause)` Set the order by clause replacing the existing order by clause if there is one.
`Query<T>`	`select(String fetchProperties)` Explicitly set a comma delimited list of the properties to fetch on the 'main' entity bean (aka partial object).
`Query<T>`	`setAutofetch(boolean autofetch)` Explicitly specify whether to use Autofetch for this query.
`Query<T>`	`setBufferFetchSizeHint(int fetchSize)` A hint which for JDBC translates to the Statement.fetchSize().
`Query<T>`	`setDistinct(boolean isDistinct)` Set whether this query uses DISTINCT.
`Query<T>`	`setFirstRow(int firstRow)` Set the first row to return for this query.
`Query<T>`	`setForUpdate(boolean forUpdate)` executed the select with "for update" which should lock the record "on read"
`Query<T>`	`setId(Object id)` Set the Id value to query.
`Query<T>`	`setLoadBeanCache(boolean loadBeanCache)` When set to true all the beans from this query are loaded into the bean cache.
`Query<T>`	`setMapKey(String mapKey)` Set the property to use as keys for a map.
`Query<T>`	`setMaxRows(int maxRows)` Set the maximum number of rows to return in the query.
`Query<T>`	`setOrder(OrderBy<T> orderBy)` Set an OrderBy object to replace any existing OrderBy clause.
`Query<T>`	`setOrderBy(OrderBy<T> orderBy)` Set an OrderBy object to replace any existing OrderBy clause.
`Query<T>`	`setParameter(int position, Object value)` Set an ordered bind parameter according to its position.
`Query<T>`	`setParameter(String name, Object value)` Set a named bind parameter.
`Query<T>`	`setRawSql(RawSql rawSql)` Set RawSql to use for this query.
`Query<T>`	`setReadOnly(boolean readOnly)` When set to true when you want the returned beans to be read only.
`Query<T>`	`setTimeout(int secs)` Set a timeout on this query.
`Query<T>`	`setUseCache(boolean useBeanCache)` Set this to true to use the bean cache.
`Query<T>`	`setUseQueryCache(boolean useQueryCache)` Set this to true to use the query cache.
`ExpressionList<T>`	`where()` Add Expressions to the where clause with the ability to chain on the ExpressionList.
`Query<T>`	`where(Expression expression)` Add a single Expression to the where clause returning the query.
`Query<T>`	`where(String addToWhereClause)` Add additional clause(s) to the where clause.

- Method Detail
  - getRawSql
```
RawSql getRawSql()
```
    Return the RawSql that was set to use for this query.
  - setRawSql
```
Query<T> setRawSql(RawSql rawSql)
```
    Set RawSql to use for this query.
  - cancel
```
void cancel()
```
    Cancel the query execution if supported by the underlying database and driver.
    This must be called from a different thread to the query executor.
  - copy
```
Query<T> copy()
```
    Return a copy of the query.
    This is so that you can use a Query as a "prototype" for creating other query instances. You could create a Query with various where expressions and use that as a "prototype" - using this copy() method to create a new instance that you can then add other expressions then execute.
  - getExpressionFactory
```
ExpressionFactory getExpressionFactory()
```
    Return the ExpressionFactory used by this query.
  - isAutofetchTuned
```
boolean isAutofetchTuned()
```
    Returns true if this query was tuned by autoFetch.
  - setAutofetch
```
Query<T> setAutofetch(boolean autofetch)
```
    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.
  - select
```
Query<T> select(String fetchProperties)
```
    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();
 
```
    Parameters:
    fetchProperties - the properties to fetch for this bean (* = all properties).
  - fetch
```
Query<T> fetch(String path,
             String fetchProperties)
```
    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();
 
```
    Parameters:
    path - the path of an associated (1-1,1-M,M-1,M-M) bean.
    fetchProperties - properties of the associated bean that you want to include in the fetch (* means all properties, null also means all properties).
  - fetch
```
Query<T> fetch(String assocProperty,
             String fetchProperties,
             FetchConfig fetchConfig)
```
    Additionally specify a FetchConfig to use a separate query or lazy loading to load this path.
  - fetch
```
Query<T> fetch(String path)
```
    Specify a path to load including all its properties.
    The same as fetch(String, String) with the fetchProperties as "*".
    
    Parameters:
    path - the property of an associated (1-1,1-M,M-1,M-M) bean.
  - fetch
```
Query<T> fetch(String path,
             FetchConfig joinConfig)
```
    Additionally specify a JoinConfig to specify a "query join" and or define the lazy loading query.
  - findIds
```
List<Object> findIds()
```
    Execute the query returning the list of Id's.
    This query will execute against the EbeanServer that was used to create it.
    
    See Also:
    EbeanServer.findIds(Query, Transaction)
  - findIterate
```
QueryIterator<T> findIterate()
```
    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.
  - findVisit
```
void findVisit(QueryResultVisitor<T> visitor)
```
    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;
   }
 });
 
```
    Parameters:
    visitor - the visitor used to process the queried beans.
  - findList
```
List<T> findList()
```
    Execute the query returning the list of objects.
    This query will execute against the EbeanServer that was used to create it.
    
    See Also:
    EbeanServer.findList(Query, Transaction)
  - findSet
```
Set<T> findSet()
```
    Execute the query returning the set of objects.
    This query will execute against the EbeanServer that was used to create it.
    
    See Also:
    EbeanServer.findSet(Query, Transaction)
  - findMap
```
Map<?,T> findMap()
```
    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();
 
```
    See Also:
    EbeanServer.findMap(Query, Transaction)
  - findMap
```
<K> Map<K,T> findMap(String keyProperty,
                   Class<K> keyType)
```
    Return a typed map specifying the key property and type.
  - findUnique
```
T findUnique()
```
    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();
 ...
 
```
  - findRowCount
```
int findRowCount()
```
    Return the count of entities this query should return.
    This is the number of 'top level' or 'root level' entities.
  - findFutureRowCount
```
FutureRowCount<T> findFutureRowCount()
```
    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).
    
    Returns:
    a Future object for the row count query
  - findFutureIds
```
FutureIds<T> findFutureIds()
```
    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).
    
    Returns:
    a Future object for the list of Id's
  - findFutureList
```
FutureList<T> findFutureList()
```
    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).
    
    Returns:
    a Future object for the list result of the query
  - findPagingList
```
PagingList<T> findPagingList(int pageSize)
```
    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 setFirstRow(int) and and 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.
    
    Parameters:
    pageSize - the number of beans fetched per Page
  - setParameter
```
Query<T> setParameter(String name,
                    Object value)
```
    Set a named bind parameter. Named parameters have a colon to prefix the name.
```
 // a query with a named parameter
 String oql = "find order where status = :orderStatus";
 
 Query<Order> query = Ebean.createQuery(Order.class, oql);
 
 // bind the named parameter
 query.bind("orderStatus", OrderStatus.NEW);
 List<Order> list = query.findList();
 
```
    Parameters:
    name - the parameter name
    value - the parameter value
  - setParameter
```
Query<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.
```
 // a query with a positioned parameter
 String oql = "where status = ? order by id desc";
 
 Query<Order> query = Ebean.createQuery(Order.class, oql);
 
 // bind the parameter
 query.setParameter(1, OrderStatus.NEW);
 
 List<Order> list = query.findList();
 
```
    Parameters:
    position - the parameter bind position starting from 1 (not 0)
    value - the parameter bind value.
  - setId
```
Query<T> setId(Object id)
```
    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();
 ...
 
```
  - where
```
Query<T> where(String addToWhereClause)
```
    Add additional clause(s) to the where clause.
    This typically contains named parameters which will need to be set via 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.
    Parameters:
    addToWhereClause - the clause to append to the where clause which typically contains named parameters.
    
    Returns:
    The query object
  - where
```
Query<T> where(Expression expression)
```
    Add a single Expression to the where clause returning the query.
```
 List<Order> newOrders = 
     Ebean.find(Order.class)
                .where().eq("status", Order.NEW)
                .findList();
 ...
 
```
  - where
```
ExpressionList<T> where()
```
    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%");
 }
 
```
    Returns:
    The ExpressionList for adding expressions to.
    See Also:
    Expr
  - filterMany
```
ExpressionList<T> filterMany(String propertyName)
```
    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.
    Parameters:
    propertyName - 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.
  - having
```
ExpressionList<T> having()
```
    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).
    
    Returns:
    The ExpressionList for adding more expressions to.
    See Also:
    Expr
  - having
```
Query<T> having(String addToHavingClause)
```
    Add additional clause(s) to the having clause.
    This typically contains named parameters which will need to be set via setParameter(String, Object).
```
 Query<ReportOrder> query = Ebean.createQuery(ReportOrder.class);
 ...
 if (...) {
   query.having("score > :min");
   query.setParameter("min", 1);
 }
 
```
    Parameters:
    addToHavingClause - the clause to append to the having clause which typically contains named parameters.
    
    Returns:
    The query object
  - having
```
Query<T> having(Expression addExpressionToHaving)
```
    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 having() except it returns the query rather than the ExpressionList. This is useful when you want to further specify something on the query.
    
    Parameters:
    addExpressionToHaving - the expression to add to the having clause.
    
    Returns:
    the Query object
  - orderBy
```
Query<T> orderBy(String orderByClause)
```
    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 order(String).
  - order
```
Query<T> order(String orderByClause)
```
    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 orderBy(String).
  - order
```
OrderBy<T> order()
```
    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 orderBy().
  - orderBy
```
OrderBy<T> orderBy()
```
    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 order().
  - setOrder
```
Query<T> setOrder(OrderBy<T> orderBy)
```
    Set an OrderBy object to replace any existing OrderBy clause.
    This is EXACTLY the same as setOrderBy(OrderBy).
  - setOrderBy
```
Query<T> setOrderBy(OrderBy<T> orderBy)
```
    Set an OrderBy object to replace any existing OrderBy clause.
    This is EXACTLY the same as setOrder(OrderBy).
  - setDistinct
```
Query<T> setDistinct(boolean isDistinct)
```
    Set whether this query uses DISTINCT.
  - getFirstRow
```
int getFirstRow()
```
    Return the first row value.
  - setFirstRow
```
Query<T> setFirstRow(int firstRow)
```
    Set the first row to return for this query.
    
    Parameters:
    firstRow -
  - getMaxRows
```
int getMaxRows()
```
    Return the max rows for this query.
  - setMaxRows
```
Query<T> setMaxRows(int maxRows)
```
    Set the maximum number of rows to return in the query.
    
    Parameters:
    maxRows - the maximum number of rows to return in the query.
  - setMapKey
```
Query<T> setMapKey(String mapKey)
```
    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();
 ...
 
```
    Parameters:
    mapKey - the property to use as keys for a map.
  - setUseCache
```
Query<T> setUseCache(boolean useBeanCache)
```
    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.
  - setUseQueryCache
```
Query<T> setUseQueryCache(boolean useQueryCache)
```
    Set this to true to use the query cache.
  - setReadOnly
```
Query<T> setReadOnly(boolean readOnly)
```
    When set to true when you want the returned beans to be read only.
  - setLoadBeanCache
```
Query<T> setLoadBeanCache(boolean loadBeanCache)
```
    When set to true all the beans from this query are loaded into the bean cache.
  - setTimeout
```
Query<T> setTimeout(int secs)
```
    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.
    
    Parameters:
    secs - the query timeout limit in seconds. Zero means there is no limit.
  - setBufferFetchSizeHint
```
Query<T> setBufferFetchSizeHint(int fetchSize)
```
    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.
  - getGeneratedSql
```
String getGeneratedSql()
```
    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.
  - setForUpdate
```
Query<T> setForUpdate(boolean forUpdate)
```
    executed the select with "for update" which should lock the record "on read"
  - isForUpdate
```
boolean isForUpdate()
```
    Return true if this query has forUpdate set.

Interface Query<T>

Autofetch

Query Language

Examples of Ebean's Query Language

Early parsing of the Query

Building the Where clause

Design Goal

Method Summary

Method Detail

getRawSql

setRawSql

cancel

copy

getExpressionFactory

isAutofetchTuned

setAutofetch

select

fetch

fetch

fetch

fetch

findIds

findIterate

findVisit

findList

findSet

findMap

findMap

findUnique

findRowCount

findFutureRowCount

findFutureIds

findFutureList

findPagingList

setParameter

setParameter

setId

where

where

where

filterMany

having

having

having

orderBy

order

order

orderBy

setOrder

setOrderBy

setDistinct

getFirstRow

setFirstRow

getMaxRows

setMaxRows

setMapKey

setUseCache

setUseQueryCache

setReadOnly

setLoadBeanCache

setTimeout

setBufferFetchSizeHint

getGeneratedSql

setForUpdate

isForUpdate