Package org.apache.cayenne.query

Class ObjectSelect<T>

java.lang.Object
org.apache.cayenne.query.CacheableQuery
org.apache.cayenne.query.AbstractQuery
org.apache.cayenne.query.FluentSelect<T>
org.apache.cayenne.query.ObjectSelect<T>
All Implemented Interfaces:
Serializable, ParameterizedQuery, Query, Select<T>
Direct Known Subclasses:
PrefetchSelectQuery
public class ObjectSelect<T> extends FluentSelect<T> implements ParameterizedQuery
A selecting query providing chainable API. This is an alternative to SelectQuery when you want to use a fluent API. For example, the following is a convenient way to return a record: 
 
 Artist a = ObjectSelect
      .query(Artist.class)
      .where(Artist.NAME.eq("Picasso"))
      .selectOne(context);
Since:
4.0
See Also:

  • Field Details

    • metaData

      protected org.apache.cayenne.query.ObjectSelectMetadata metaData

  • Constructor Details

    • ObjectSelect

      protected ObjectSelect()

  • Method Details

    • query

      public static <T> ObjectSelect<T> query(Class<T> entityType)
      Creates a ObjectSelect that selects objects of a given persistent class.

    • query

      public static <T> ObjectSelect<T> query(Class<T> entityType, Expression expression)
      Creates a ObjectSelect that selects objects of a given persistent class and uses provided expression for its qualifier.

    • query

      public static <T> ObjectSelect<T> query(Class<T> entityType, Expression expression, List<Ordering> orderings)
      Creates a ObjectSelect that selects objects of a given persistent class and uses provided expression for its qualifier.

    • dataRowQuery

      public static ObjectSelect<DataRow> dataRowQuery(Class<?> entityType)
      Creates a ObjectSelect that fetches data for an ObjEntity determined from a provided class.

    • dataRowQuery

      public static ObjectSelect<DataRow> dataRowQuery(Class<?> entityType, Expression expression)
      Creates a ObjectSelect that fetches data for an ObjEntity determined from a provided class and uses provided expression for its qualifier.

    • query

      public static <T> ObjectSelect<T> query(Class<T> resultType, String entityName)
      Creates a ObjectSelect that fetches data for ObjEntity determined from provided "entityName", but fetches the result of a provided type. This factory method is most often used with generic classes that by themselves are not enough to resolve the entity to fetch.

    • dbQuery

      public static ObjectSelect<DataRow> dbQuery(String dbEntityName)
      Creates a ObjectSelect that fetches DataRows for a DbEntity determined from provided "dbEntityName".

    • dbQuery

      public static ObjectSelect<DataRow> dbQuery(String dbEntityName, Expression expression)
      Creates a ObjectSelect that fetches DataRows for a DbEntity determined from provided "dbEntityName" and uses provided expression for its qualifier.
      Returns:
      this object

    • columnQuery

      public static <E> ColumnSelect<E> columnQuery(Class<?> entityType, Property<E> column)
      Creates a ColumnSelect that will fetch single property that can be resolved against a given ObjEntity class.
      Parameters:
      entityType - base persistent class that will be used as a root for this query
      column - single column to select

    • columnQuery

      public static ColumnSelect<Object[]> columnQuery(Class<?> entityType, Property<?>... columns)
      Creates a ColumnSelect that will fetch multiple columns of a given ObjEntity
      Parameters:
      entityType - base persistent class that will be used as a root for this query
      columns - columns to select

    • entityType

      public ObjectSelect<T> entityType(Class<?> entityType)
      Sets the type of the entity to fetch without changing the return type of the query.
      Returns:
      this object

    • entityName

      public ObjectSelect<T> entityName(String entityName)
      Sets the ObjEntity name to fetch without changing the return type of the query. This form is most often used for generic entities that don't map to a distinct class.
      Returns:
      this object

    • dbEntityName

      public ObjectSelect<T> dbEntityName(String dbEntityName)
      Sets the DbEntity name to fetch without changing the return type of the query. This form is most often used for generic entities that don't map to a distinct class.
      Returns:
      this object

    • where

      public ObjectSelect<T> where(Expression expression)
      Appends a qualifier expression of this query. An equivalent to and(Expression...) that can be used a syntactic sugar.
      Returns:
      this object

    • where

      public ObjectSelect<T> where(String expressionString, Object... parameters)
      Appends a qualifier expression of this query, using provided expression String and an array of position parameters. This is an equivalent to calling "and".
      Returns:
      this object

    • having

      public ObjectSelect<T> having(Expression expression)
      Appends a having qualifier expression of this query. An equivalent to and(Expression...) that can be used a syntactic sugar.
      Returns:
      this object
      Since:
      4.2

    • having

      public ObjectSelect<T> having(String expressionString, Object... parameters)
      Appends a having qualifier expression of this query, using provided expression String and an array of position parameters. This is an equivalent to calling "and".
      Returns:
      this object
      Since:
      4.2

    • and

      public ObjectSelect<T> and(Expression... expressions)
      AND's provided expressions to the existing WHERE clause expression.
      Returns:
      this object

    • and

      public ObjectSelect<T> and(Collection<Expression> expressions)
      AND's provided expressions to the existing WHERE clause expression.
      Returns:
      this object

    • or

      public ObjectSelect<T> or(Expression... expressions)
      OR's provided expressions to the existing WHERE clause expression.
      Returns:
      this object

    • or

      public ObjectSelect<T> or(Collection<Expression> expressions)
      OR's provided expressions to the existing WHERE clause expression.
      Returns:
      this object

    • orderBy

      public ObjectSelect<T> orderBy(String property)
      Add an ascending ordering on the given property. If there is already an ordering on this query then add this ordering with a lower priority.
      Parameters:
      property - the property to sort on
      Returns:
      this object

    • orderBy

      public ObjectSelect<T> orderBy(String property, SortOrder sortOrder)
      Add an ordering on the given property. If there is already an ordering on this query then add this ordering with a lower priority.
      Parameters:
      property - the property to sort on
      sortOrder - the direction of the ordering
      Returns:
      this object

    • orderBy

      public ObjectSelect<T> orderBy(Ordering... orderings)
      Add one or more orderings to this query.
      Returns:
      this object

    • orderBy

      public ObjectSelect<T> orderBy(Collection<Ordering> orderings)
      Adds a list of orderings to this query.
      Returns:
      this object

    • prefetch

      public ObjectSelect<T> prefetch(PrefetchTreeNode prefetch)
      Merges prefetch into the query prefetch tree.
      Returns:
      this object

    • prefetch

      public ObjectSelect<T> prefetch(String path, int semantics)
      Merges a prefetch path with specified semantics into the query prefetch tree.
      Returns:
      this object

    • limit

      public ObjectSelect<T> limit(int fetchLimit)
      Resets query fetch limit - a parameter that defines max number of objects that should be ever be fetched from the database.

    • offset

      public ObjectSelect<T> offset(int fetchOffset)
      Resets query fetch offset - a parameter that defines how many objects should be skipped when reading data from the database.

    • pageSize

      public ObjectSelect<T> pageSize(int pageSize)
      Resets query page size. A non-negative page size enables query result pagination that saves memory and processing time for large lists if only parts of the result are ever going to be accessed.

    • statementFetchSize

      public ObjectSelect<T> statementFetchSize(int size)
      Sets fetch size of the PreparedStatement generated for this query. Only non-negative values would change the default size.
      See Also:

    • queryTimeout

      public ObjectSelect<T> queryTimeout(int timeout)
      Sets query timeout for PreparedStatement generated for this query.
      Since:
      4.2
      See Also:

    • cacheStrategy

      public ObjectSelect<T> cacheStrategy(QueryCacheStrategy strategy)

    • cacheStrategy

      public ObjectSelect<T> cacheStrategy(QueryCacheStrategy strategy, String cacheGroup)

    • cacheGroup

      public ObjectSelect<T> cacheGroup(String cacheGroup)

    • localCache

      public ObjectSelect<T> localCache(String cacheGroup)
      Instructs Cayenne to look for query results in the "local" cache when running the query. This is a short-hand notation for: 

       query.cacheStrategy(QueryCacheStrategy.LOCAL_CACHE, cacheGroup);

    • localCache

      public ObjectSelect<T> localCache()
      Instructs Cayenne to look for query results in the "local" cache when running the query. This is a short-hand notation for: 

       query.cacheStrategy(QueryCacheStrategy.LOCAL_CACHE);

    • sharedCache

      public ObjectSelect<T> sharedCache(String cacheGroup)
      Instructs Cayenne to look for query results in the "shared" cache when running the query. This is a short-hand notation for: 

       query.cacheStrategy(QueryCacheStrategy.SHARED_CACHE, cacheGroup);

    • sharedCache

      public ObjectSelect<T> sharedCache()
      Instructs Cayenne to look for query results in the "shared" cache when running the query. This is a short-hand notation for: 

       query.cacheStrategy(QueryCacheStrategy.SHARED_CACHE);

    • fetchDataRows

      public ObjectSelect<DataRow> fetchDataRows()
      Forces query to fetch DataRows. This automatically changes whatever result type was set previously to "DataRow".
      Returns:
      this object

    • columns

      public ColumnSelect<Object[]> columns(Property<?>... properties)

      Select only specific properties.

      Can be any properties that can be resolved against root entity type (root entity's properties, function call expressions, properties of relationships, etc).

       
 List<Object[]> columns = ObjectSelect.query(Artist.class)
                                    .columns(Artist.ARTIST_NAME, Artist.DATE_OF_BIRTH)
                                    .select(context);
      Parameters:
      properties - array of properties to select
      See Also:

    • column

      public <E> ColumnSelect<E> column(Property<E> property)

      Select one specific property.

      Can be any property that can be resolved against root entity type (root entity's property, function call expression, property of relationships, etc)

      If you need several columns use columns(Property[]) method.

       
 List<String> names = ObjectSelect.query(Artist.class)
                                  .column(Artist.ARTIST_NAME)
                                  .select(context);

      Parameters:
      property - single property to select
      See Also:

    • count

      public ColumnSelect<Long> count()
      Select COUNT(*)
      See Also:

    • count

      public ColumnSelect<Long> count(BaseProperty<?> property)

      Select COUNT(property)

      Can return different result than COUNT(*) as it will count only non null values

      See Also:

    • min

      public <E> ColumnSelect<E> min(ComparableProperty<E> property)

      Select minimum value of property

      See Also:

    • min

      public <E extends Number> ColumnSelect<E> min(NumericProperty<E> property)

      Select minimum value of property

      See Also:

    • max

      public <E> ColumnSelect<E> max(ComparableProperty<E> property)

      Select maximum value of property

      See Also:

    • max

      public <E extends Number> ColumnSelect<E> max(NumericProperty<E> property)

      Select maximum value of property

      See Also:

    • avg

      @Deprecated public <E> ColumnSelect<E> avg(Property<E> property)
      Deprecated.
      since 4.2 use avg(NumericProperty)

      Select average value of property

      See Also:

    • avg

      public <E extends Number> ColumnSelect<E> avg(NumericProperty<E> property)

      Select average value of property

      See Also:

    • sum

      @Deprecated public <E extends Number> ColumnSelect<E> sum(Property<E> property)
      Deprecated.
      since 4.2 use sum(NumericProperty)

      Select sum of values

      See Also:

    • sum

      public <E extends Number> ColumnSelect<E> sum(NumericProperty<E> property)

      Select sum of values

      See Also:

    • distinct

      public ObjectSelect<T> distinct()
      Returns:
      this
      Since:
      4.2

    • selectCount

      public long selectCount(ObjectContext context)

      Quick way to select count of records

      Usage: 

       
     long count = ObjectSelect.query(Artist.class)
                      .where(Artist.ARTIST_NAME.like("a%"))
                      .selectCount(context);

      Parameters:
      context - to perform query
      Returns:
      count of rows

    • selectFirst

      public T selectFirst(ObjectContext context)
      Description copied from interface: Select
      Selects a single object using provided context. The query itself can match any number of objects, but will return only the first one. It returns null if no objects were matched.

      If it matched more than one object, the first object from the list is returned. This makes 'selectFirst' different from Select.selectOne(ObjectContext), which would throw in this situation. 'selectFirst' is useful e.g. when the query is ordered and we only want to see the first object (e.g. "most recent news article"), etc.

      Selecting the first object via "Select.selectFirst(ObjectContext)" is more comprehensible than selecting via "ObjectContext.selectFirst(Select)", because implementations of "Select" set fetch size limit to one.

      Specified by:
      selectFirst in interface Select<T>

    • isFetchingDataRows

      public boolean isFetchingDataRows()
      Overrides:
      isFetchingDataRows in class FluentSelect<T>

    • getMetaData

      public QueryMetadata getMetaData(EntityResolver resolver)
      Description copied from class: AbstractQuery
      Returns default select parameters.
      Specified by:
      getMetaData in interface Query
      Overrides:
      getMetaData in class AbstractQuery

    • getBaseMetaData

      protected org.apache.cayenne.query.BaseQueryMetadata getBaseMetaData()
      Specified by:
      getBaseMetaData in class CacheableQuery

    • createQuery

      public Query createQuery(Map<String,?> parameters)
      This method is intended for internal use in a MappedSelect.
      Specified by:
      createQuery in interface ParameterizedQuery
      Parameters:
      parameters - to apply
      Returns:
      this query with parameters applied to the where qualifier
      Since:
      4.2