Query (Axelor Development Kit 5.2.14-SNAPSHOT API)

java.lang.Object
- com.axelor.db.Query<T>

Direct Known Subclasses:

MetaJsonRecordRepository.MetaJsonRecordQuery
```
public class Query<T extends Model>
extends Object
```
The Query class allows filtering and fetching records quickly.
It also provides update(Map) and delete() method to perform mass update and delete operation on matched records.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class Query.Selector
A helper class to select specific field values.

Nested Classes
Modifier and Type	Class and Description
`class`	`Query.Selector` A helper class to select specific field values.

Constructor Summary

Constructors
Constructor and Description

Query(Class<T> beanClass)
Create a new instance of Query with given bean class.

Constructors
Constructor and Description
`Query(Class<T> beanClass)` Create a new instance of `Query` with given bean class.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Query<T>`	`autoFlush(boolean auto)`
`Query<T>`	`bind(Map<String,Object> params)` Bind the named parameters of the query with the given values.
`protected QueryBinder`	`bind(Query query)`
`Query<T>`	`bind(String name, Object value)` Bind the given named parameter of the query with the given value.
`Query<T>`	`cacheable()` Set the query result cacheable.
`long`	`count()` Returns the number of total records matched.
`protected String`	`countQuery()`
`int`	`delete()` Bulk delete all the matched records.
`protected String`	`deleteQuery(String filter)`
`protected EntityManager`	`em()`
`List<T>`	`fetch()` Fetch all the matched records.
`List<T>`	`fetch(int limit)` Fetch the matched records with the given limit.
`List<T>`	`fetch(int limit, int offset)` Fetch the matched records within the given range.
`T`	`fetchOne()` Fetch the first matched record.
`T`	`fetchOne(int offset)` Fetch a matched record at the given offset.
`java.util.stream.Stream<T>`	`fetchSteam()` Deprecated. Use `fetchStream()`.
`java.util.stream.Stream<T>`	`fetchSteam(int limit)` Deprecated. Use `fetchStream(int)`.
`java.util.stream.Stream<T>`	`fetchSteam(int limit, int offset)` Deprecated. Use `fetchStream(int, int)`.
`java.util.stream.Stream<T>`	`fetchStream()` Fetch all the matched records as `Stream`.
`java.util.stream.Stream<T>`	`fetchStream(int limit)` Fetch the matched records as `Stream` with the given limit.
`java.util.stream.Stream<T>`	`fetchStream(int limit, int offset)` Fetch the matched records as `Stream` within the given range.
`Query<T>`	`filter(String filter)`
`Query<T>`	`filter(String filter, Object... params)` A convenient method to filter the query using JPQL's where clause.
`static <T extends Model> Query<T>`	`of(Class<T> klass)`
`Query<T>`	`order(String spec)` Set order by clause for the query.
`Query<T>`	`readOnly()` Set the query readonly.
`long`	`remove()` Remove all the matched records.
`Query.Selector`	`select(String... names)` Return a selector to select records with specific fields only.
`protected String`	`selectQuery()`
`protected String`	`selectQuery(boolean update)`
`String`	`toString()`
`int`	`update(Map<String,Object> values)` Perform mass update on the matched records with the given values.
`int`	`update(Map<String,Object> values, User updatedBy)` Perform mass update on matched records with the given values.
`int`	`update(String name, Object value)` This is similar to `update(Map)` but updates only single field.
`int`	`update(String name, Object value, User updatedBy)` This is similar to `update(Map, User)` but updates only single field.
`protected String`	`updateQuery()`
`protected String`	`updateQuery(Map<String,Object> values, boolean versioned, String filter)`

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

- Constructor Detail
  - Query
```
public Query(Class<T> beanClass)
```
    Create a new instance of Query with given bean class.
    
    Parameters:
    
    beanClass - model bean class
- Method Detail
  - of
```
public static <T extends Model> Query<T> of(Class<T> klass)
```
  - em
```
protected EntityManager em()
```
  - filter
```
public Query<T> filter(String filter,
                       Object... params)
```
    A convenient method to filter the query using JPQL's where clause.
    The filter string should refer the field names with self. prefix and values should not be embedded into the filter string but should be passed by parameters and ? placeholder should be used to mark parameter substitutions.
    Here is an example:
```
 Query<Person> query = Query.of(Person);
 query = query.filter("self.name = ? AND self.age >= ?", "some", 20);

 List<Person> matched = query.fetch();
 
```
    This is equivalent to:
```
 SELECT self from Person self WHERE (self.name = ?1) AND (self.age >= ?2)
 
```
    The params passed will be added as positional parameters to the JPA query object before performing fetch().
    Parameters:
    
    filter - the filter string
    
    params - the parameters
    
    Returns:
    
    the same instance
  - filter
```
public Query<T> filter(String filter)
```
  - order
```
public Query<T> order(String spec)
```
    Set order by clause for the query. This method can be chained to provide multiple fields.
    The spec is just a field name for ASC or should be prefixed with - for DESC clause.
    For example:
```
 Query<Person> query = Query.of(Person);
 query = query.filter("name =", "some").filter("age >=", 20)
        .filter("lang in", "en", "hi");

 query = query.order("name").order("-age");
 
```
    This is equivalent to:
```
 SELECT p from Person p WHERE (p.name = ?1) AND (p.age >= ?2) AND (lang IN (?3, ?4)) ORDER BY p.name, p.age DESC
 
```
    Parameters:
    
    spec - order spec
    
    Returns:
    
    the same query instance
  - cacheable
```
public Query<T> cacheable()
```
    Set the query result cacheable.
    
    Returns:
    
    the same query instance
  - readOnly
```
public Query<T> readOnly()
```
    Set the query readonly.
    
    Returns:
    
    the same query instance.
  - autoFlush
```
public Query<T> autoFlush(boolean auto)
```
  - fetchStream
```
public java.util.stream.Stream<T> fetchStream()
```
    Fetch all the matched records as Stream.
    Recommended only when dealing with large data, for example, batch processing. For normal use cases, the fetch() is more appropriate.
    Also configure hibernate.jdbc.fetch_size (default is 20) to fine tune the fetch size.
    
    Returns:
    
    stream of matched records.
    
    See Also:
    
    fetchStream(int), fetchStream(int, int)
  - fetchSteam
```
@Deprecated
public java.util.stream.Stream<T> fetchSteam()
```
    Deprecated. Use fetchStream().
  - fetchStream
```
public java.util.stream.Stream<T> fetchStream(int limit)
```
    Fetch the matched records as Stream with the given limit.
    Recommended only when dealing with large data, for example, batch processing. For normal use cases, the fetch() is more appropriate.
    Also configure hibernate.jdbc.fetch_size (default is 20) to fine tune the fetch size.
    
    Parameters:
    
    limit - the limit
    
    Returns:
    
    stream of matched records within the limit
    
    See Also:
    
    fetchStream(int, int)
  - fetchSteam
```
@Deprecated
public java.util.stream.Stream<T> fetchSteam(int limit)
```
    Deprecated. Use fetchStream(int).
  - fetchStream
```
public java.util.stream.Stream<T> fetchStream(int limit,
                                              int offset)
```
    Fetch the matched records as Stream within the given range.
    Recommended only when dealing with large data, for example, batch processing. For normal use cases, the fetch() is more appropriate.
    Also configure hibernate.jdbc.fetch_size (default is 20) to fine tune the fetch size.
    
    Parameters:
    
    limit - the limit
    
    offset - the offset
    
    Returns:
    
    stream of matched records within the range
  - fetchSteam
```
@Deprecated
public java.util.stream.Stream<T> fetchSteam(int limit,
                                                         int offset)
```
    Deprecated. Use fetchStream(int, int).
  - fetch
```
public List<T> fetch()
```
    Fetch all the matched records.
    
    Returns:
    
    list of all the matched records.
  - fetch
```
public List<T> fetch(int limit)
```
    Fetch the matched records with the given limit.
    
    Parameters:
    
    limit - the limit
    
    Returns:
    
    matched records within the limit
  - fetch
```
public List<T> fetch(int limit,
                     int offset)
```
    Fetch the matched records within the given range.
    
    Parameters:
    
    limit - the limit
    
    offset - the offset
    
    Returns:
    
    list of matched records within the range
  - fetchOne
```
public T fetchOne()
```
    Fetch the first matched record.
    
    Returns:
    
    the first matched record.
  - fetchOne
```
public T fetchOne(int offset)
```
    Fetch a matched record at the given offset.
    
    Parameters:
    
    offset - the offset
    
    Returns:
    
    the matched record at given offset
  - count
```
public long count()
```
    Returns the number of total records matched.
    
    Returns:
    
    total number
  - select
```
public Query.Selector select(String... names)
```
    Return a selector to select records with specific fields only.
    
    Parameters:
    
    names - field names to select
    
    Returns:
    
    a new instance of Query.Selector
  - update
```
public int update(Map<String,Object> values)
```
    Perform mass update on the matched records with the given values.
    
    Parameters:
    
    values - the key value map
    
    Returns:
    
    total number of records updated
  - update
```
public int update(String name,
                  Object value)
```
    This is similar to update(Map) but updates only single field.
    
    Parameters:
    
    name - the field name whose value needs to be changed
    
    value - the new value
    
    Returns:
    
    total number of records updated
  - update
```
public int update(Map<String,Object> values,
                  User updatedBy)
```
    Perform mass update on matched records with the given values.
    If updatedBy user is null, perform non-versioned update otherwise performed versioned update.
    
    Parameters:
    
    values - the key value map
    
    updatedBy - the user to set "updatedBy" field
    
    Returns:
    
    total number of records updated
  - update
```
public int update(String name,
                  Object value,
                  User updatedBy)
```
    This is similar to update(Map, User) but updates only single field.
    
    Parameters:
    
    name - the field name whose value needs to be changed
    
    value - the new value
    
    updatedBy - the user to set "updatedBy" field
    
    Returns:
    
    total number of records updated
  - delete
```
public int delete()
```
    Bulk delete all the matched records.
    
    This method uses DELETE query and performs Query.executeUpdate().
    
    Returns:
    
    total number of records affected.
    
    See Also:
    
    remove()
  - remove
```
public long remove()
```
    Remove all the matched records.
    
    In contrast to the delete() method, it performs EntityManager.remove(Object) operation by fetching objects in pages (100 at a time).
    
    Returns:
    
    total number of records removed.
    
    See Also:
    
    delete()
  - selectQuery
```
protected String selectQuery(boolean update)
```
  - selectQuery
```
protected String selectQuery()
```
  - updateQuery
```
protected String updateQuery()
```
  - countQuery
```
protected String countQuery()
```
  - updateQuery
```
protected String updateQuery(Map<String,Object> values,
                             boolean versioned,
                             String filter)
```
  - deleteQuery
```
protected String deleteQuery(String filter)
```
  - bind
```
protected QueryBinder bind(Query query)
```
  - bind
```
public Query<T> bind(Map<String,Object> params)
```
    Bind the named parameters of the query with the given values. Named parameter must me set after query is filtered.
    
    Parameters:
    
    params - mapping for named params.
    
    Returns:
    
    the same instance
  - bind
```
public Query<T> bind(String name,
                     Object value)
```
    Bind the given named parameter of the query with the given value.
    
    Parameters:
    
    name - the named parameter to bind
    
    value - the parameter value
    
    Returns:
    
    the same instance
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class Query<T extends Model>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Query

Method Detail

of

em

filter

filter

order

cacheable

readOnly

autoFlush

fetchStream

fetchSteam

fetchStream

fetchSteam

fetchStream

fetchSteam

fetch

fetch

fetch

fetchOne

fetchOne

count

select

update

update

update

update

delete

remove

selectQuery

selectQuery

updateQuery

countQuery

updateQuery

deleteQuery

bind

bind

bind

toString