Package com.axelor.db

Class Query<T extends Model>

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.

  • Constructor Details

    • Query

      public Query(Class<T> beanClass)
      Create a new instance of Query with given bean class.
      Parameters:
      beanClass - model bean class

  • Method Details

    • of

      public static <T extends Model> Query<T> of(Class<T> klass)

    • em

      protected jakarta.persistence.EntityManager em()

    • getJoinHelper

      protected Query.JoinHelper getJoinHelper()

    • getFilter

      protected String getFilter()

    • setFilter

      protected void setFilter(String filter)

    • getParams

      protected Object[] getParams()

    • setParams

      protected void setParams(Object[] params)

    • getNamedParams

      protected Map<String,Object> getNamedParams()

    • setNamedParams

      protected void setNamedParams(Map<String,Object> namedParams)

    • 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)

    • fixPlaceholders

      protected String fixPlaceholders(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.

    • translate

      public Query<T> translate(boolean translate)
      Set whether to use translation join.
      Parameters:
      translate -
      Returns:

    • translate

      public Query<T> translate()
      Use translation join.
      Returns:
      the same query instance.

    • autoFlush

      public Query<T> autoFlush(boolean auto)

    • fetchStream

      public 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

      public 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

      public 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

    • 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, or null if there are no results.

    • 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, or null if there are no results.

    • count

      public long count()
      Returns the number of total records matched.
      Returns:
      total number

    • select

      public Query<T>.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<T extends Model>.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

      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:

    • 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(jakarta.persistence.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