public class ObjectSelect<T> extends FluentSelect<T>
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);
 
 | Modifier and Type | Field and Description | 
|---|---|
| protected boolean | fetchingDataRows | 
cacheGroup, cacheStrategy, dbEntityName, entityName, entityType, limit, offset, orderings, pageSize, prefetches, statementFetchSize, wheredataMap, lastResolver, name, replacementQuery| Modifier | Constructor and Description | 
|---|---|
| protected  | ObjectSelect() | 
| Modifier and Type | Method and Description | 
|---|---|
| ObjectSelect<T> | and(Collection<Expression> expressions)AND's provided expressions to the existing WHERE clause expression. | 
| ObjectSelect<T> | and(Expression... expressions)AND's provided expressions to the existing WHERE clause expression. | 
| <E> ColumnSelect<E> | avg(Property<E> property)Select average value of property | 
| ObjectSelect<T> | cacheGroup(String cacheGroup) | 
| ObjectSelect<T> | cacheStrategy(QueryCacheStrategy strategy) | 
| ObjectSelect<T> | cacheStrategy(QueryCacheStrategy strategy,
             String cacheGroup) | 
| <E> ColumnSelect<E> | column(Property<E> property)Select one specific property. | 
| static ColumnSelect<Object[]> | columnQuery(Class<?> entityType,
           Property<?> firstColumn,
           Property<?>... otherColumns)Creates a ColumnSelect that will fetch multiple columns of a given  ObjEntity | 
| 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  ObjEntityclass. | 
| ColumnSelect<Object[]> | columns(Property<?> firstProperty,
       Property<?>... properties)Select only specific properties. | 
| ColumnSelect<Long> | count()Select COUNT(*) | 
| ColumnSelect<Long> | count(Property<?> property)Select COUNT(property) | 
| protected Query | createReplacementQuery(EntityResolver resolver)Translates self to a SelectQuery. | 
| static ObjectSelect<DataRow> | dataRowQuery(Class<?> entityType)Creates a ObjectSelect that fetches data for an  ObjEntitydetermined from a provided class. | 
| static ObjectSelect<DataRow> | dataRowQuery(Class<?> entityType,
            Expression expression)Creates a ObjectSelect that fetches data for an  ObjEntitydetermined from a provided class and uses provided expression for its
 qualifier. | 
| ObjectSelect<T> | dbEntityName(String dbEntityName)Sets the  DbEntityname to fetch without changing the return type
 of the query. | 
| static ObjectSelect<DataRow> | dbQuery(String dbEntityName)Creates a ObjectSelect that fetches DataRows for a  DbEntitydetermined from provided "dbEntityName". | 
| static ObjectSelect<DataRow> | dbQuery(String dbEntityName,
       Expression expression)Creates a ObjectSelect that fetches DataRows for a  DbEntitydetermined from provided "dbEntityName" and uses provided expression for
 its qualifier. | 
| ObjectSelect<T> | entityName(String entityName)Sets the  ObjEntityname to fetch without changing the return type
 of the query. | 
| ObjectSelect<T> | entityType(Class<?> entityType)Sets the type of the entity to fetch without changing the return type of
 the query. | 
| ObjectSelect<DataRow> | fetchDataRows()Forces query to fetch DataRows. | 
| boolean | isFetchingDataRows() | 
| 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. | 
| ObjectSelect<T> | localCache()Instructs Cayenne to look for query results in the "local" cache when
 running the query. | 
| ObjectSelect<T> | localCache(String cacheGroup)Instructs Cayenne to look for query results in the "local" cache when
 running the query. | 
| <E> ColumnSelect<E> | max(Property<E> property)Select maximum value of property | 
| <E> ColumnSelect<E> | min(Property<E> property)Select minimum value of property | 
| 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. | 
| ObjectSelect<T> | or(Collection<Expression> expressions)OR's provided expressions to the existing WHERE clause expression. | 
| ObjectSelect<T> | or(Expression... expressions)OR's provided expressions to the existing WHERE clause expression. | 
| ObjectSelect<T> | orderBy(Collection<Ordering> orderings)Adds a list of orderings to this query. | 
| ObjectSelect<T> | orderBy(Ordering... orderings)Add one or more orderings to this query. | 
| ObjectSelect<T> | orderBy(String property)Add an ascending ordering on the given property. | 
| ObjectSelect<T> | orderBy(String property,
       SortOrder sortOrder)Add an ordering on the given property. | 
| ObjectSelect<T> | pageSize(int pageSize)Resets query page size. | 
| ObjectSelect<T> | prefetch(PrefetchTreeNode prefetch)Merges prefetch into the query prefetch tree. | 
| ObjectSelect<T> | prefetch(String path,
        int semantics)Merges a prefetch path with specified semantics into the query prefetch
 tree. | 
| static <T> ObjectSelect<T> | query(Class<T> entityType)Creates a ObjectSelect that selects objects of a given persistent class. | 
| 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. | 
| 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. | 
| static <T> ObjectSelect<T> | query(Class<T> resultType,
     String entityName)Creates a ObjectSelect that fetches data for  ObjEntitydetermined
 from provided "entityName", but fetches the result of a provided type. | 
| long | selectCount(ObjectContext context)Quick way to select count of records | 
| T | selectFirst(ObjectContext context)Selects a single object using provided context. | 
| ObjectSelect<T> | sharedCache()Instructs Cayenne to look for query results in the "shared" cache when
 running the query. | 
| ObjectSelect<T> | sharedCache(String cacheGroup)Instructs Cayenne to look for query results in the "shared" cache when
 running the query. | 
| ObjectSelect<T> | statementFetchSize(int size)Sets fetch size of the PreparedStatement generated for this query. | 
| <E extends Number> | sum(Property<E> property)Select sum of values | 
| ObjectSelect<T> | where(Expression expression)Appends a qualifier expression of this query. | 
| ObjectSelect<T> | where(String expressionString,
     Object... parameters)Appends a qualifier expression of this query, using provided expression
 String and an array of position parameters. | 
batchIterator, getCacheGroup, getCacheStrategy, getDbEntityName, getEntityName, getEntityType, getLimit, getOffset, getOrderings, getPageSize, getPrefetches, getStatementFetchSize, getWhere, iterate, iterator, select, selectOnecreateSQLAction, getDataMap, getMetaData, getName, getReplacementQuery, route, setDataMap, setNameclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitcreateSQLAction, getDataMap, getMetaData, getName, routepublic static <T> ObjectSelect<T> query(Class<T> entityType)
public static <T> ObjectSelect<T> query(Class<T> entityType, Expression expression)
public static <T> ObjectSelect<T> query(Class<T> entityType, Expression expression, List<Ordering> orderings)
public static ObjectSelect<DataRow> dataRowQuery(Class<?> entityType)
ObjEntity
 determined from a provided class.public static ObjectSelect<DataRow> dataRowQuery(Class<?> entityType, Expression expression)
ObjEntity
 determined from a provided class and uses provided expression for its
 qualifier.public static <T> ObjectSelect<T> query(Class<T> resultType, String entityName)
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.public static ObjectSelect<DataRow> dbQuery(String dbEntityName)
DbEntity
 determined from provided "dbEntityName".public static ObjectSelect<DataRow> dbQuery(String dbEntityName, Expression expression)
DbEntity
 determined from provided "dbEntityName" and uses provided expression for
 its qualifier.public static <E> ColumnSelect<E> columnQuery(Class<?> entityType, Property<E> column)
ObjEntity class.entityType - base persistent class that will be used as a root for this querycolumn - single column to selectpublic static ColumnSelect<Object[]> columnQuery(Class<?> entityType, Property<?> firstColumn, Property<?>... otherColumns)
ObjEntityentityType - base persistent class that will be used as a root for this queryfirstColumn - column to selectotherColumns - columns to selectprotected Query createReplacementQuery(EntityResolver resolver)
createReplacementQuery in class FluentSelect<T>public ObjectSelect<T> entityType(Class<?> entityType)
public ObjectSelect<T> entityName(String entityName)
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.public ObjectSelect<T> dbEntityName(String dbEntityName)
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.public ObjectSelect<T> where(Expression expression)
and(Expression...) that can be used a syntactic sugar.public ObjectSelect<T> where(String expressionString, Object... parameters)
public ObjectSelect<T> and(Expression... expressions)
public ObjectSelect<T> and(Collection<Expression> expressions)
public ObjectSelect<T> or(Expression... expressions)
public ObjectSelect<T> or(Collection<Expression> expressions)
public ObjectSelect<T> orderBy(String property)
property - the property to sort onpublic ObjectSelect<T> orderBy(String property, SortOrder sortOrder)
property - the property to sort onsortOrder - the direction of the orderingpublic ObjectSelect<T> orderBy(Ordering... orderings)
public ObjectSelect<T> orderBy(Collection<Ordering> orderings)
public ObjectSelect<T> prefetch(PrefetchTreeNode prefetch)
public ObjectSelect<T> prefetch(String path, int semantics)
public ObjectSelect<T> limit(int fetchLimit)
public ObjectSelect<T> offset(int fetchOffset)
public ObjectSelect<T> pageSize(int pageSize)
public ObjectSelect<T> statementFetchSize(int size)
Statement.setFetchSize(int)public ObjectSelect<T> cacheStrategy(QueryCacheStrategy strategy)
public ObjectSelect<T> cacheStrategy(QueryCacheStrategy strategy, String cacheGroup)
public ObjectSelect<T> cacheGroup(String cacheGroup)
public ObjectSelect<T> localCache(String cacheGroup)
query.cacheStrategy(QueryCacheStrategy.LOCAL_CACHE, cacheGroup);
public ObjectSelect<T> localCache()
query.cacheStrategy(QueryCacheStrategy.LOCAL_CACHE);
public ObjectSelect<T> sharedCache(String cacheGroup)
query.cacheStrategy(QueryCacheStrategy.SHARED_CACHE, cacheGroup);
public ObjectSelect<T> sharedCache()
query.cacheStrategy(QueryCacheStrategy.SHARED_CACHE);
public ObjectSelect<DataRow> fetchDataRows()
public ColumnSelect<Object[]> columns(Property<?> firstProperty, 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);
 
 properties - array of properties to selectcolumn(Property)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, Property[]) method.
 
 List<String> names = ObjectSelect.query(Artist.class)
                                  .column(Artist.ARTIST_NAME)
                                  .select(context);
 
 
 property - single property to selectcolumns(Property, Property[])public ColumnSelect<Long> count()
column(Property)public ColumnSelect<Long> count(Property<?> property)
Select COUNT(property)
Can return different result than COUNT(*) as it will count only non null values
count(), 
column(Property)public <E> ColumnSelect<E> min(Property<E> property)
Select minimum value of property
column(Property)public <E> ColumnSelect<E> max(Property<E> property)
Select maximum value of property
column(Property)public <E> ColumnSelect<E> avg(Property<E> property)
Select average value of property
column(Property)public <E extends Number> ColumnSelect<E> sum(Property<E> property)
Select sum of values
column(Property)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);
 
 
 context - to perform querypublic T selectFirst(ObjectContext context)
Select
 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.
public boolean isFetchingDataRows()
Copyright © 2001–2023 Apache Cayenne. All rights reserved.