DefaultExpressionList (avaje-ebeanorm 3.3.1 API)

java.lang.Object
- com.avaje.ebeaninternal.util.DefaultExpressionList<T>

All Implemented Interfaces:

ExpressionList<T>, SpiExpressionList<T>, Serializable

Direct Known Subclasses:

FilterExpressionList
```
public class DefaultExpressionList<T>
extends Object
implements SpiExpressionList<T>
```
Default implementation of ExpressionList.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected ExpressionFactory`	`expr`
`protected List<SpiExpression>`	`list`
`protected ExpressionList<T>`	`parentExprList`
`protected Query<T>`	`query`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`DefaultExpressionList(Query<T> query, ExpressionFactory expr, ExpressionList<T> parentExprList)`
`protected`	`DefaultExpressionList(Query<T> query, ExpressionFactory expr, ExpressionList<T> parentExprList, List<SpiExpression> list)`
	`DefaultExpressionList(Query<T> query, ExpressionList<T> parentExprList)`

Method Summary

Methods
Modifier and Type	Method and Description
`ExpressionList<T>`	`add(Expression expr)` Add an Expression to the list.
`ExpressionList<T>`	`addAll(ExpressionList<T> exprList)` Add a list of Expressions to this ExpressionList.s
`ExpressionList<T>`	`allEq(Map<String,Object> propertyMap)` All Equal - Map containing property names and their values.
`ExpressionList<T>`	`and(Expression expOne, Expression expTwo)` And - join two expressions with a logical and.
`ExpressionList<T>`	`between(String propertyName, Object value1, Object value2)` Between - property between the two given values.
`ExpressionList<T>`	`betweenProperties(String lowProperty, String highProperty, Object value)` Between - value between the two properties.
`ArrayList<Object>`	`buildBindValues(SpiExpressionRequest request)` Combine the expression bind values into a list.
`String`	`buildSql(SpiExpressionRequest request)` Concatenate the expression sql into a String.
`Junction<T>`	`conjunction()` Return a list of expressions that will be joined by AND's.
`ExpressionList<T>`	`contains(String propertyName, String value)` Contains - property like %value%.
`void`	`containsMany(BeanDescriptor<?> desc, ManyWhereJoins whereManyJoins)` Return true if one of the expressions is related to a Many property.
`DefaultExpressionList<T>`	`copy(Query<T> query)` Return a copy of the expression list.
`Junction<T>`	`disjunction()` Return a list of expressions that will be joined by OR's.
`ExpressionList<T>`	`endJunction()` End a Conjunction or Disjunction returning the parent expression list.
`ExpressionList<T>`	`endsWith(String propertyName, String value)` Ends With - property like %value.
`ExpressionList<T>`	`eq(String propertyName, Object value)` Equal To - property is equal to a given value.
`ExpressionList<T>`	`exampleLike(Object example)` A "Query By Example" type of expression.
`ExpressionList<T>`	`filterMany(String prop)`
`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 a list.
`Map<?,T>`	`findMap()` Execute the query returning a map.
`<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 a set.
`T`	`findUnique()` Execute the query returning a single bean.
`void`	`findVisit(QueryResultVisitor<T> visitor)` Execute the query visiting the results.
`ExpressionList<T>`	`ge(String propertyName, Object value)` Greater Than or Equal to - property greater than or equal to the given value.
`List<SpiExpression>`	`getUnderlyingList()` Return the underlying list of expressions.
`ExpressionList<T>`	`gt(String propertyName, Object value)` Greater Than - property greater than the given value.
`ExpressionList<T>`	`having()` Add expressions to the having clause.
`ExpressionList<T>`	`icontains(String propertyName, String value)` Case insensitive Contains - property like %value%.
`ExpressionList<T>`	`idEq(Object value)` Id Equal to - ID property is equal to the value.
`ExpressionList<T>`	`idIn(List<?> idList)` Id IN a list of id values.
`ExpressionList<T>`	`iendsWith(String propertyName, String value)` Case insensitive Ends With - property like %value.
`ExpressionList<T>`	`ieq(String propertyName, String value)` Case Insensitive Equal To - property equal to the given value (typically using a lower() function to make it case insensitive).
`ExpressionList<T>`	`iexampleLike(Object example)` Case insensitive version of `ExpressionList.exampleLike(Object)`
`ExpressionList<T>`	`ilike(String propertyName, String value)` Case insensitive Like - property like value where the value contains the SQL wild card characters % (percentage) and _ (underscore).
`ExpressionList<T>`	`in(String propertyName, Collection<?> values)` In - property has a value in the collection of values.
`ExpressionList<T>`	`in(String propertyName, Object... values)` In - property has a value in the array of values.
`ExpressionList<T>`	`in(String propertyName, Query<?> subQuery)` In - using a subQuery.
`List<SpiExpression>`	`internalList()`
`boolean`	`isEmpty()` Return true if this list is empty.
`ExpressionList<T>`	`isNotNull(String propertyName)` Is Not Null - property is not null.
`ExpressionList<T>`	`isNull(String propertyName)` Is Null - property is null.
`ExpressionList<T>`	`istartsWith(String propertyName, String value)` Case insensitive Starts With - property like value%.
`Query<T>`	`join(String assocProperties)` Specify a property (associated bean) to join and fetch including all its properties.
`Query<T>`	`join(String assocProperty, String assocProperties)` Specify a property (associated bean) to join and fetch with its specific properties to include (aka partial object).
`ExpressionList<T>`	`le(String propertyName, Object value)` Less Than or Equal to - property less than or equal to the given value.
`ExpressionList<T>`	`like(String propertyName, String value)` Like - property like value where the value contains the SQL wild card characters % (percentage) and _ (underscore).
`ExpressionList<T>`	`lt(String propertyName, Object value)` Less Than - property less than the given value.
`ExpressionList<T>`	`ne(String propertyName, Object value)` Not Equal To - property not equal to the given value.
`ExpressionList<T>`	`not(Expression exp)` Negate the expression (prefix it with NOT).
`ExpressionList<T>`	`or(Expression expOne, Expression expTwo)` Or - join two expressions with a logical or.
`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 orderBy)` Add an orderBy clause to the query.
`Query<T>`	`query()` Return the query that owns this expression list.
`void`	`queryAutoFetchHash(HashQueryPlanBuilder builder)` Calculate a hash based on the expressions but excluding the actual bind values.
`int`	`queryBindHash()` Calculate a hash based on the expressions.
`void`	`queryPlanHash(BeanQueryRequest<?> request, HashQueryPlanBuilder builder)` Calculate a hash based on the expressions but excluding the actual bind values.
`ExpressionList<T>`	`raw(String raw)` Add raw expression with no parameters.
`ExpressionList<T>`	`raw(String raw, Object value)` Add raw expression with a single parameter.
`ExpressionList<T>`	`raw(String raw, Object[] values)` Add raw expression with an array of parameters.
`Query<T>`	`select(String fetchProperties)` Specify specific properties to fetch on the main/root bean (aka partial object).
`Query<T>`	`setBackgroundFetchAfter(int backgroundFetchAfter)` Set the number of rows after which the fetching should continue in a background thread.
`void`	`setExpressionFactory(ExpressionFactory expr)` Set the ExpressionFactory.
`Query<T>`	`setFirstRow(int firstRow)` Set the first row to fetch.
`Query<T>`	`setListener(QueryListener<T> queryListener)` Deprecated.
`Query<T>`	`setMapKey(String mapKey)` Set the name of the property which values become the key of a map.
`Query<T>`	`setMaxRows(int maxRows)` Set the maximum number of rows to fetch.
`Query<T>`	`setOrderBy(String orderBy)` Add an orderBy clause to the query.
`Query<T>`	`setUseCache(boolean useCache)` Set to true to use the query for executing this query.
`ExpressionList<T>`	`startsWith(String propertyName, String value)` Starts With - property like value%.
`SpiExpressionList<?>`	`trimPath(int prefixTrim)` Return a copy of the ExpressionList with the path trimmed for filterMany() expressions.
`ExpressionList<T>`	`where()` Add another expression to the where clause.

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

- Field Detail
  - list
```
protected final List<SpiExpression> list
```
  - query
```
protected final Query<T> query
```
  - parentExprList
```
protected final ExpressionList<T> parentExprList
```
  - expr
```
protected transient ExpressionFactory expr
```
- Constructor Detail
  - DefaultExpressionList
```
public DefaultExpressionList(Query<T> query,
                     ExpressionList<T> parentExprList)
```
  - DefaultExpressionList
```
public DefaultExpressionList(Query<T> query,
                     ExpressionFactory expr,
                     ExpressionList<T> parentExprList)
```
  - DefaultExpressionList
```
protected DefaultExpressionList(Query<T> query,
                     ExpressionFactory expr,
                     ExpressionList<T> parentExprList,
                     List<SpiExpression> list)
```
- Method Detail
  - trimPath
```
public SpiExpressionList<?> trimPath(int prefixTrim)
```
    Description copied from interface: SpiExpressionList
    
    Return a copy of the ExpressionList with the path trimmed for filterMany() expressions.
    
    Specified by:
    
    trimPath in interface SpiExpressionList<T>
  - internalList
```
public List<SpiExpression> internalList()
```
  - setExpressionFactory
```
public void setExpressionFactory(ExpressionFactory expr)
```
    Set the ExpressionFactory.
    After deserialisation so that it can be further modified.
    
    Specified by:
    
    setExpressionFactory in interface SpiExpressionList<T>
  - copy
```
public DefaultExpressionList<T> copy(Query<T> query)
```
    Return a copy of the expression list.
    Each of the expressions are expected to be immutable and safe to reference.
  - containsMany
```
public void containsMany(BeanDescriptor<?> desc,
                ManyWhereJoins whereManyJoins)
```
    Return true if one of the expressions is related to a Many property.
    
    Specified by:
    
    containsMany in interface SpiExpressionList<T>
  - endJunction
```
public ExpressionList<T> endJunction()
```
    Description copied from interface: ExpressionList
    
    End a Conjunction or Disjunction returning the parent expression list.
    Alternatively you can always use where() to return the top level expression list.
    
    Specified by:
    
    endJunction in interface ExpressionList<T>
  - query
```
public Query<T> query()
```
    Description copied from interface: ExpressionList
    
    Return the query that owns this expression list.
    This is a convenience method solely to support a fluid API where the methods are chained together. Adding expressions returns this expression list and this method can be used after that to return back the original query so that further things can be added to it.
    
    Specified by:
    
    query in interface ExpressionList<T>
  - where
```
public ExpressionList<T> where()
```
    Description copied from interface: ExpressionList
    
    Add another expression to the where clause.
    
    Specified by:
    
    where in interface ExpressionList<T>
  - order
```
public OrderBy<T> order()
```
    Description copied from interface: ExpressionList
    
    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.
    
    Specified by:
    
    order in interface ExpressionList<T>
  - orderBy
```
public OrderBy<T> orderBy()
```
    Description copied from interface: ExpressionList
    
    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.
    
    Specified by:
    
    orderBy in interface ExpressionList<T>
  - order
```
public Query<T> order(String orderByClause)
```
    Description copied from interface: ExpressionList
    
    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 ExpressionList.orderBy(String).
    
    Specified by:
    
    order in interface ExpressionList<T>
  - orderBy
```
public Query<T> orderBy(String orderBy)
```
    Description copied from interface: ExpressionList
    
    Add an orderBy clause to the query.
    
    Specified by:
    
    orderBy in interface ExpressionList<T>
    
    See Also:
    Query.orderBy(String)
  - setOrderBy
```
public Query<T> setOrderBy(String orderBy)
```
    Description copied from interface: ExpressionList
    
    Add an orderBy clause to the query.
    
    Specified by:
    
    setOrderBy in interface ExpressionList<T>
    
    See Also:
    Query.orderBy(String)
  - findFutureIds
```
public FutureIds<T> findFutureIds()
```
    Description copied from interface: ExpressionList
    
    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 ExpressionList<T>
    
    Returns:
    a Future object for the list of Id's
  - findFutureRowCount
```
public FutureRowCount<T> findFutureRowCount()
```
    Description copied from interface: ExpressionList
    
    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 ExpressionList<T>
    
    Returns:
    a Future object for the row count query
  - findFutureList
```
public FutureList<T> findFutureList()
```
    Description copied from interface: ExpressionList
    
    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 ExpressionList<T>
    
    Returns:
    a Future object for the list result of the query
  - findPagingList
```
public PagingList<T> findPagingList(int pageSize)
```
    Description copied from interface: ExpressionList
    
    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 ExpressionList<T>
    
    Parameters:
    pageSize - the number of beans fetched per Page
  - findRowCount
```
public int findRowCount()
```
    Description copied from interface: ExpressionList
    
    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 ExpressionList<T>
  - findIds
```
public List<Object> findIds()
```
    Description copied from interface: ExpressionList
    
    Execute the query returning the list of Id's.
    
    Specified by:
    
    findIds in interface ExpressionList<T>
    
    See Also:
    Query.findIds()
  - findVisit
```
public void findVisit(QueryResultVisitor<T> visitor)
```
    Description copied from interface: ExpressionList
    
    Execute the query visiting the results.
    
    Specified by:
    
    findVisit in interface ExpressionList<T>
    
    See Also:
    Query.findVisit(QueryResultVisitor)
  - findIterate
```
public QueryIterator<T> findIterate()
```
    Description copied from interface: ExpressionList
    
    Execute the query iterating over the results.
    
    Specified by:
    
    findIterate in interface ExpressionList<T>
    
    See Also:
    Query.findIterate()
  - findList
```
public List<T> findList()
```
    Description copied from interface: ExpressionList
    
    Execute the query returning a list.
    
    Specified by:
    
    findList in interface ExpressionList<T>
    
    See Also:
    Query.findList()
  - findSet
```
public Set<T> findSet()
```
    Description copied from interface: ExpressionList
    
    Execute the query returning a set.
    
    Specified by:
    
    findSet in interface ExpressionList<T>
    
    See Also:
    Query.findSet()
  - findMap
```
public Map<?,T> findMap()
```
    Description copied from interface: ExpressionList
    
    Execute the query returning a map.
    
    Specified by:
    
    findMap in interface ExpressionList<T>
    
    See Also:
    Query.findMap()
  - findMap
```
public <K> Map<K,T> findMap(String keyProperty,
                   Class<K> keyType)
```
    Description copied from interface: ExpressionList
    
    Return a typed map specifying the key property and type.
    
    Specified by:
    
    findMap in interface ExpressionList<T>
  - findUnique
```
public T findUnique()
```
    Description copied from interface: ExpressionList
    
    Execute the query returning a single bean.
    
    Specified by:
    
    findUnique in interface ExpressionList<T>
    
    See Also:
    Query.findUnique()
  - filterMany
```
public ExpressionList<T> filterMany(String prop)
```
    Specified by:
    
    filterMany in interface ExpressionList<T>
  - select
```
public Query<T> select(String fetchProperties)
```
    Description copied from interface: ExpressionList
    
    Specify specific properties to fetch on the main/root bean (aka partial object).
    
    Specified by:
    
    select in interface ExpressionList<T>
    
    See Also:
    Query.select(String)
  - join
```
public Query<T> join(String assocProperties)
```
    Description copied from interface: ExpressionList
    
    Specify a property (associated bean) to join and fetch including all its properties.
    
    Specified by:
    
    join in interface ExpressionList<T>
    
    See Also:
    Query#join(String)
  - join
```
public Query<T> join(String assocProperty,
            String assocProperties)
```
    Description copied from interface: ExpressionList
    
    Specify a property (associated bean) to join and fetch with its specific properties to include (aka partial object).
    
    Specified by:
    
    join in interface ExpressionList<T>
    
    See Also:
    Query#join(String,String)
  - setFirstRow
```
public Query<T> setFirstRow(int firstRow)
```
    Description copied from interface: ExpressionList
    
    Set the first row to fetch.
    
    Specified by:
    
    setFirstRow in interface ExpressionList<T>
    
    See Also:
    Query.setFirstRow(int)
  - setMaxRows
```
public Query<T> setMaxRows(int maxRows)
```
    Description copied from interface: ExpressionList
    
    Set the maximum number of rows to fetch.
    
    Specified by:
    
    setMaxRows in interface ExpressionList<T>
    
    See Also:
    Query.setMaxRows(int)
  - setBackgroundFetchAfter
```
public Query<T> setBackgroundFetchAfter(int backgroundFetchAfter)
```
    Description copied from interface: ExpressionList
    
    Set the number of rows after which the fetching should continue in a background thread.
    
    Specified by:
    
    setBackgroundFetchAfter in interface ExpressionList<T>
    
    See Also:
    Query.setBackgroundFetchAfter(int)
  - setMapKey
```
public Query<T> setMapKey(String mapKey)
```
    Description copied from interface: ExpressionList
    
    Set the name of the property which values become the key of a map.
    
    Specified by:
    
    setMapKey in interface ExpressionList<T>
    
    See Also:
    Query.setMapKey(String)
  - setListener
```
@Deprecated
public Query<T> setListener(QueryListener<T> queryListener)
```
    Deprecated.
    
    Description copied from interface: ExpressionList
    
    Please migrate to using ExpressionList.findIterate() or ExpressionList.findVisit(QueryResultVisitor). Set a QueryListener for bean by bean processing.
    
    Specified by:
    
    setListener in interface ExpressionList<T>
    
    See Also:
    Query.setListener(QueryListener)
  - setUseCache
```
public Query<T> setUseCache(boolean useCache)
```
    Description copied from interface: ExpressionList
    
    Set to true to use the query for executing this query.
    
    Specified by:
    
    setUseCache in interface ExpressionList<T>
    
    See Also:
    Query.setUseCache(boolean)
  - having
```
public ExpressionList<T> having()
```
    Description copied from interface: ExpressionList
    
    Add expressions to the having clause.
    The having clause is only used for queries based on raw sql (via SqlSelect annotation etc).
    
    Specified by:
    
    having in interface ExpressionList<T>
  - add
```
public ExpressionList<T> add(Expression expr)
```
    Description copied from interface: ExpressionList
    Add an Expression to the list.
    This returns the list so that add() can be chained.
```
 Query<Customer> query = Ebean.createQuery(Customer.class);
 query.where()
     .like("name","Rob%")
     .eq("status", Customer.ACTIVE);
 List<Customer> list = query.findList();
 ...
 
```
    Specified by:
    
    add in interface ExpressionList<T>
  - addAll
```
public ExpressionList<T> addAll(ExpressionList<T> exprList)
```
    Description copied from interface: ExpressionList
    
    Add a list of Expressions to this ExpressionList.s
    
    Specified by:
    
    addAll in interface ExpressionList<T>
  - getUnderlyingList
```
public List<SpiExpression> getUnderlyingList()
```
    Description copied from interface: SpiExpressionList
    
    Return the underlying list of expressions.
    
    Specified by:
    
    getUnderlyingList in interface SpiExpressionList<T>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: SpiExpressionList
    
    Return true if this list is empty.
    
    Specified by:
    
    isEmpty in interface SpiExpressionList<T>
  - buildSql
```
public String buildSql(SpiExpressionRequest request)
```
    Description copied from interface: SpiExpressionList
    
    Concatenate the expression sql into a String.
    The list of expressions are evaluated in order building a sql statement with bind parameters.
    
    Specified by:
    
    buildSql in interface SpiExpressionList<T>
  - buildBindValues
```
public ArrayList<Object> buildBindValues(SpiExpressionRequest request)
```
    Description copied from interface: SpiExpressionList
    
    Combine the expression bind values into a list.
    Expressions are evaluated in order and all the resulting bind values are returned as a List.
    
    Specified by:
    
    buildBindValues in interface SpiExpressionList<T>
    
    Returns:
    the list of all the bind values in order.
  - queryAutoFetchHash
```
public void queryAutoFetchHash(HashQueryPlanBuilder builder)
```
    Calculate a hash based on the expressions but excluding the actual bind values.
  - queryPlanHash
```
public void queryPlanHash(BeanQueryRequest<?> request,
                 HashQueryPlanBuilder builder)
```
    Calculate a hash based on the expressions but excluding the actual bind values.
    
    Specified by:
    
    queryPlanHash in interface SpiExpressionList<T>
  - queryBindHash
```
public int queryBindHash()
```
    Calculate a hash based on the expressions.
  - eq
```
public ExpressionList<T> eq(String propertyName,
                   Object value)
```
    Description copied from interface: ExpressionList
    
    Equal To - property is equal to a given value.
    
    Specified by:
    
    eq in interface ExpressionList<T>
  - ieq
```
public ExpressionList<T> ieq(String propertyName,
                    String value)
```
    Description copied from interface: ExpressionList
    
    Case Insensitive Equal To - property equal to the given value (typically using a lower() function to make it case insensitive).
    
    Specified by:
    
    ieq in interface ExpressionList<T>
  - ne
```
public ExpressionList<T> ne(String propertyName,
                   Object value)
```
    Description copied from interface: ExpressionList
    
    Not Equal To - property not equal to the given value.
    
    Specified by:
    
    ne in interface ExpressionList<T>
  - allEq
```
public ExpressionList<T> allEq(Map<String,Object> propertyMap)
```
    Description copied from interface: ExpressionList
    
    All Equal - Map containing property names and their values.
    Expression where all the property names in the map are equal to the corresponding value.
    
    Specified by:
    
    allEq in interface ExpressionList<T>
    
    Parameters:
    propertyMap - a map keyed by property names.
  - and
```
public ExpressionList<T> and(Expression expOne,
                    Expression expTwo)
```
    Description copied from interface: ExpressionList
    
    And - join two expressions with a logical and.
    
    Specified by:
    
    and in interface ExpressionList<T>
  - between
```
public ExpressionList<T> between(String propertyName,
                        Object value1,
                        Object value2)
```
    Description copied from interface: ExpressionList
    
    Between - property between the two given values.
    
    Specified by:
    
    between in interface ExpressionList<T>
  - betweenProperties
```
public ExpressionList<T> betweenProperties(String lowProperty,
                                  String highProperty,
                                  Object value)
```
    Description copied from interface: ExpressionList
    
    Between - value between the two properties.
    
    Specified by:
    
    betweenProperties in interface ExpressionList<T>
  - conjunction
```
public Junction<T> conjunction()
```
    Description copied from interface: ExpressionList
    
    Return a list of expressions that will be joined by AND's.
    
    Specified by:
    
    conjunction in interface ExpressionList<T>
  - contains
```
public ExpressionList<T> contains(String propertyName,
                         String value)
```
    Description copied from interface: ExpressionList
    
    Contains - property like %value%.
    
    Specified by:
    
    contains in interface ExpressionList<T>
  - disjunction
```
public Junction<T> disjunction()
```
    Description copied from interface: ExpressionList
    
    Return a list of expressions that will be joined by OR's.
    
    Specified by:
    
    disjunction in interface ExpressionList<T>
  - endsWith
```
public ExpressionList<T> endsWith(String propertyName,
                         String value)
```
    Description copied from interface: ExpressionList
    
    Ends With - property like %value.
    
    Specified by:
    
    endsWith in interface ExpressionList<T>
  - ge
```
public ExpressionList<T> ge(String propertyName,
                   Object value)
```
    Description copied from interface: ExpressionList
    
    Greater Than or Equal to - property greater than or equal to the given value.
    
    Specified by:
    
    ge in interface ExpressionList<T>
  - gt
```
public ExpressionList<T> gt(String propertyName,
                   Object value)
```
    Description copied from interface: ExpressionList
    
    Greater Than - property greater than the given value.
    
    Specified by:
    
    gt in interface ExpressionList<T>
  - icontains
```
public ExpressionList<T> icontains(String propertyName,
                          String value)
```
    Description copied from interface: ExpressionList
    
    Case insensitive Contains - property like %value%. Typically uses a lower() function to make the expression case insensitive.
    
    Specified by:
    
    icontains in interface ExpressionList<T>
  - idIn
```
public ExpressionList<T> idIn(List<?> idList)
```
    Description copied from interface: ExpressionList
    
    Id IN a list of id values.
    
    Specified by:
    
    idIn in interface ExpressionList<T>
  - idEq
```
public ExpressionList<T> idEq(Object value)
```
    Description copied from interface: ExpressionList
    
    Id Equal to - ID property is equal to the value.
    
    Specified by:
    
    idEq in interface ExpressionList<T>
  - iendsWith
```
public ExpressionList<T> iendsWith(String propertyName,
                          String value)
```
    Description copied from interface: ExpressionList
    
    Case insensitive Ends With - property like %value. Typically uses a lower() function to make the expression case insensitive.
    
    Specified by:
    
    iendsWith in interface ExpressionList<T>
  - ilike
```
public ExpressionList<T> ilike(String propertyName,
                      String value)
```
    Description copied from interface: ExpressionList
    
    Case insensitive Like - property like value where the value contains the SQL wild card characters % (percentage) and _ (underscore). Typically uses a lower() function to make the expression case insensitive.
    
    Specified by:
    
    ilike in interface ExpressionList<T>
  - in
```
public ExpressionList<T> in(String propertyName,
                   Query<?> subQuery)
```
    Description copied from interface: ExpressionList
    
    In - using a subQuery.
    
    Specified by:
    
    in in interface ExpressionList<T>
  - in
```
public ExpressionList<T> in(String propertyName,
                   Collection<?> values)
```
    Description copied from interface: ExpressionList
    
    In - property has a value in the collection of values.
    
    Specified by:
    
    in in interface ExpressionList<T>
  - in
```
public ExpressionList<T> in(String propertyName,
                   Object... values)
```
    Description copied from interface: ExpressionList
    
    In - property has a value in the array of values.
    
    Specified by:
    
    in in interface ExpressionList<T>
  - isNotNull
```
public ExpressionList<T> isNotNull(String propertyName)
```
    Description copied from interface: ExpressionList
    
    Is Not Null - property is not null.
    
    Specified by:
    
    isNotNull in interface ExpressionList<T>
  - isNull
```
public ExpressionList<T> isNull(String propertyName)
```
    Description copied from interface: ExpressionList
    
    Is Null - property is null.
    
    Specified by:
    
    isNull in interface ExpressionList<T>
  - istartsWith
```
public ExpressionList<T> istartsWith(String propertyName,
                            String value)
```
    Description copied from interface: ExpressionList
    
    Case insensitive Starts With - property like value%. Typically uses a lower() function to make the expression case insensitive.
    
    Specified by:
    
    istartsWith in interface ExpressionList<T>
  - le
```
public ExpressionList<T> le(String propertyName,
                   Object value)
```
    Description copied from interface: ExpressionList
    
    Less Than or Equal to - property less than or equal to the given value.
    
    Specified by:
    
    le in interface ExpressionList<T>
  - exampleLike
```
public ExpressionList<T> exampleLike(Object example)
```
    Description copied from interface: ExpressionList
    A "Query By Example" type of expression.
    Pass in an example entity and for each non-null scalar properties an expression is added.
    
    By Default this case sensitive, will ignore numeric zero values and will use a Like for string values (you must put in your own wildcards).
    
    To get control over the options you can create an ExampleExpression and set those options such as case insensitive etc.
```
 // create an example bean and set the properties
 // with the query parameters you want
 Customer example = new Customer();
 example.setName("Rob%");
 example.setNotes("%something%");
 
 List<Customer> list = Ebean.find(Customer.class).where()
     // pass the bean into the where() clause
     .exampleLike(example)
     // you can add other expressions to the same query
     .gt("id", 2).findList();
 
 
```
    Similarly you can create an ExampleExpression
```
 Customer example = new Customer();
 example.setName("Rob%");
 example.setNotes("%something%");
 
 // create a ExampleExpression with more control
 ExampleExpression qbe = new ExampleExpression(example, true, LikeType.EQUAL_TO).includeZeros();
 
 List<Customer> list = Ebean.find(Customer.class).where().add(qbe).findList();
 
```
    Specified by:
    
    exampleLike in interface ExpressionList<T>
  - iexampleLike
```
public ExpressionList<T> iexampleLike(Object example)
```
    Description copied from interface: ExpressionList
    
    Case insensitive version of ExpressionList.exampleLike(Object)
    
    Specified by:
    
    iexampleLike in interface ExpressionList<T>
  - like
```
public ExpressionList<T> like(String propertyName,
                     String value)
```
    Description copied from interface: ExpressionList
    
    Like - property like value where the value contains the SQL wild card characters % (percentage) and _ (underscore).
    
    Specified by:
    
    like in interface ExpressionList<T>
  - lt
```
public ExpressionList<T> lt(String propertyName,
                   Object value)
```
    Description copied from interface: ExpressionList
    
    Less Than - property less than the given value.
    
    Specified by:
    
    lt in interface ExpressionList<T>
  - not
```
public ExpressionList<T> not(Expression exp)
```
    Description copied from interface: ExpressionList
    
    Negate the expression (prefix it with NOT).
    
    Specified by:
    
    not in interface ExpressionList<T>
  - or
```
public ExpressionList<T> or(Expression expOne,
                   Expression expTwo)
```
    Description copied from interface: ExpressionList
    
    Or - join two expressions with a logical or.
    
    Specified by:
    
    or in interface ExpressionList<T>
  - raw
```
public ExpressionList<T> raw(String raw,
                    Object value)
```
    Description copied from interface: ExpressionList
    
    Add raw expression with a single parameter.
    The raw expression should contain a single ? at the location of the parameter.
    
    When properties in the clause are fully qualified as table-column names then they are not translated. logical property name names (not fully qualified) will still be translated to their physical name.
    
    Specified by:
    
    raw in interface ExpressionList<T>
  - raw
```
public ExpressionList<T> raw(String raw,
                    Object[] values)
```
    Description copied from interface: ExpressionList
    
    Add raw expression with an array of parameters.
    The raw expression should contain the same number of ? as there are parameters.
    
    When properties in the clause are fully qualified as table-column names then they are not translated. logical property name names (not fully qualified) will still be translated to their physical name.
    
    Specified by:
    
    raw in interface ExpressionList<T>
  - raw
```
public ExpressionList<T> raw(String raw)
```
    Description copied from interface: ExpressionList
    
    Add raw expression with no parameters.
    When properties in the clause are fully qualified as table-column names then they are not translated. logical property name names (not fully qualified) will still be translated to their physical name.
    
    Specified by:
    
    raw in interface ExpressionList<T>
  - startsWith
```
public ExpressionList<T> startsWith(String propertyName,
                           String value)
```
    Description copied from interface: ExpressionList
    
    Starts With - property like value%.
    
    Specified by:
    
    startsWith in interface ExpressionList<T>

Class DefaultExpressionList<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

list

query

parentExprList

expr

Constructor Detail

DefaultExpressionList

DefaultExpressionList

DefaultExpressionList

Method Detail

trimPath

internalList

setExpressionFactory

copy

containsMany

endJunction

query

where

order

orderBy

order

orderBy

setOrderBy

findFutureIds

findFutureRowCount

findFutureList

findPagingList

findRowCount

findIds

findVisit

findIterate

findList

findSet

findMap

findMap

findUnique

filterMany

select

join

join

setFirstRow

setMaxRows

setBackgroundFetchAfter

setMapKey

setListener

setUseCache

having

add

addAll

getUnderlyingList

isEmpty

buildSql

buildBindValues

queryAutoFetchHash

queryPlanHash

queryBindHash

eq

ieq

ne

allEq

and

between

betweenProperties

conjunction

contains

disjunction

endsWith

ge

gt

icontains

idIn

idEq

iendsWith

ilike

in