SelectById (cayenne-server: Cayenne Server 4.0.1 API)

java.lang.Object
- org.apache.cayenne.query.IndirectQuery
- - org.apache.cayenne.query.SelectById<T>

All Implemented Interfaces:

Serializable, Query, Select<T>
```
public class SelectById<T>
extends IndirectQuery
implements Select<T>
```
A query to select single objects by id.

Since:

4.0

See Also:

Serialized Form

Field Summary
- Fields inherited from class org.apache.cayenne.query.IndirectQuery
  dataMap, lastResolver, name, replacementQuery

Constructor Summary

Constructors
Constructor and Description

SelectById()

Constructors
Constructor and Description
`SelectById()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ResultBatchIterator<T>`	`batchIterator(ObjectContext context, int size)` Creates a ResultBatchIterator based on the provided context and batch size.
`SelectById<T>`	`cacheGroup(String cacheGroup)`
`SelectById<T>`	`cacheStrategy(QueryCacheStrategy strategy)`
`SelectById<T>`	`cacheStrategy(QueryCacheStrategy strategy, String cacheGroup)`
`protected Query`	`createReplacementQuery(EntityResolver resolver)` Creates a substitute query.
`static SelectById<DataRow>`	`dataRowQuery(Class<?> entityType, Map<String,Object> id)`
`static SelectById<DataRow>`	`dataRowQuery(Class<?> entityType, Object id)`
`static SelectById<DataRow>`	`dataRowQuery(ObjectId id)`
`String`	`getCacheGroup()`
`QueryCacheStrategy`	`getCacheStrategy()`
`PrefetchTreeNode`	`getPrefetches()`
`boolean`	`isFetchingDataRows()`
`void`	`iterate(ObjectContext context, ResultIteratorCallback<T> callback)` Creates a ResultIterator based on the provided context and passes it to a callback for processing.
`ResultIterator<T>`	`iterator(ObjectContext context)` Creates a ResultIterator based on the provided context.
`SelectById<T>`	`localCache()` Instructs Cayenne to look for query results in the "local" cache when running the query.
`SelectById<T>`	`localCache(String cacheGroup)` Instructs Cayenne to look for query results in the "local" cache when running the query.
`SelectById<T>`	`prefetch(PrefetchTreeNode prefetch)` Merges prefetch into the query prefetch tree.
`SelectById<T>`	`prefetch(String path, int semantics)` Merges a prefetch path with specified semantics into the query prefetch tree.
`static <T> SelectById<T>`	`query(Class<T> entityType, Map<String,?> id)`
`static <T> SelectById<T>`	`query(Class<T> entityType, Object id)`
`static <T> SelectById<T>`	`query(Class<T> entityType, ObjectId id)`
`protected ObjEntity`	`resolveEntity(EntityResolver resolver)`
`protected Map<String,?>`	`resolveId(ObjEntity entity)`
`List<T>`	`select(ObjectContext context)` Selects objects using provided context.
`T`	`selectFirst(ObjectContext context)` Selects a single object using provided context.
`T`	`selectOne(ObjectContext context)` Selects a single object using provided context.
`SelectById<T>`	`sharedCache()` Instructs Cayenne to look for query results in the "shared" cache when running the query.
`SelectById<T>`	`sharedCache(String cacheGroup)` Instructs Cayenne to look for query results in the "shared" cache when running the query.

Methods inherited from class org.apache.cayenne.query.IndirectQuery
createSQLAction, getDataMap, getMetaData, getName, getReplacementQuery, route, setDataMap, setName

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

Methods inherited from interface org.apache.cayenne.query.Query
createSQLAction, getDataMap, getMetaData, getName, route

- Constructor Detail
  - SelectById
```
public SelectById()
```
- Method Detail
  - query
```
public static <T> SelectById<T> query(Class<T> entityType,
                                      Object id)
```
  - query
```
public static <T> SelectById<T> query(Class<T> entityType,
                                      Map<String,?> id)
```
  - query
```
public static <T> SelectById<T> query(Class<T> entityType,
                                      ObjectId id)
```
  - dataRowQuery
```
public static SelectById<DataRow> dataRowQuery(Class<?> entityType,
                                               Object id)
```
  - dataRowQuery
```
public static SelectById<DataRow> dataRowQuery(Class<?> entityType,
                                               Map<String,Object> id)
```
  - dataRowQuery
```
public static SelectById<DataRow> dataRowQuery(ObjectId id)
```
  - select
```
public List<T> select(ObjectContext context)
```
    Description copied from interface: Select
    
    Selects objects using provided context.
    Essentially the inversion of "ObjectContext.select(Select)".
    
    Specified by:
    
    select in interface Select<T>
  - selectOne
```
public T selectOne(ObjectContext context)
```
    Description copied from interface: Select
    
    Selects a single object using provided context. The query is expected to match zero or one object. It returns null if no objects were matched. If query matched more than one object, CayenneRuntimeException is thrown.
    Essentially the inversion of "ObjectContext.selectOne(Select)".
    
    Specified by:
    
    selectOne in interface Select<T>
  - 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>
  - iterate
```
public void iterate(ObjectContext context,
                    ResultIteratorCallback<T> callback)
```
    Description copied from interface: Select
    
    Creates a ResultIterator based on the provided context and passes it to a callback for processing. The caller does not need to worry about closing the iterator. This method takes care of it.
    Essentially the inversion of "ObjectContext.iterate(Select, ResultIteratorCallback)".
    
    Specified by:
    
    iterate in interface Select<T>
  - iterator
```
public ResultIterator<T> iterator(ObjectContext context)
```
    Description copied from interface: Select
    
    Creates a ResultIterator based on the provided context. It is usually backed by an open result set and is useful for processing of large data sets, preserving a constant memory footprint. The caller must wrap iteration in try/finally (or try-with-resources for Java 1.7 and higher) and close the ResultIterator explicitly. Or use Select.iterate(ObjectContext, ResultIteratorCallback) as an alternative.
    Essentially the inversion of "ObjectContext.iterator(Select)".
    
    Specified by:
    
    iterator in interface Select<T>
  - batchIterator
```
public ResultBatchIterator<T> batchIterator(ObjectContext context,
                                            int size)
```
    Description copied from interface: Select
    
    Creates a ResultBatchIterator based on the provided context and batch size. It is usually backed by an open result set and is useful for processing of large data sets, preserving a constant memory footprint. The caller must wrap iteration in try/finally (or try-with-resources for Java 1.7 and higher) and close the ResultBatchIterator explicitly.
    
    Specified by:
    
    batchIterator in interface Select<T>
  - localCache
```
public SelectById<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 SelectById<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 SelectById<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 SelectById<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);
 
```
  - getCacheStrategy
```
public QueryCacheStrategy getCacheStrategy()
```
  - cacheStrategy
```
public SelectById<T> cacheStrategy(QueryCacheStrategy strategy)
```
  - cacheStrategy
```
public SelectById<T> cacheStrategy(QueryCacheStrategy strategy,
                                   String cacheGroup)
```
  - getCacheGroup
```
public String getCacheGroup()
```
  - cacheGroup
```
public SelectById<T> cacheGroup(String cacheGroup)
```
  - isFetchingDataRows
```
public boolean isFetchingDataRows()
```
  - prefetch
```
public SelectById<T> prefetch(PrefetchTreeNode prefetch)
```
    Merges prefetch into the query prefetch tree.
    
    Returns:
    
    this object
  - prefetch
```
public SelectById<T> prefetch(String path,
                              int semantics)
```
    Merges a prefetch path with specified semantics into the query prefetch tree.
    
    Returns:
    
    this object
  - getPrefetches
```
public PrefetchTreeNode getPrefetches()
```
  - createReplacementQuery
```
protected Query createReplacementQuery(EntityResolver resolver)
```
    Description copied from class: IndirectQuery
    
    Creates a substitute query. An implementor is free to provide an arbitrary replacement query.
    
    Specified by:
    
    createReplacementQuery in class IndirectQuery
  - resolveId
```
protected Map<String,?> resolveId(ObjEntity entity)
```
  - resolveEntity
```
protected ObjEntity resolveEntity(EntityResolver resolver)
```

Class SelectById<T>

Field Summary

Fields inherited from class org.apache.cayenne.query.IndirectQuery

Constructor Summary

Method Summary

Methods inherited from class org.apache.cayenne.query.IndirectQuery

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.cayenne.query.Query

Constructor Detail

SelectById

Method Detail

query

query

query

dataRowQuery

dataRowQuery

dataRowQuery

select

selectOne

selectFirst

iterate

iterator

batchIterator

localCache

localCache

sharedCache

sharedCache

getCacheStrategy

cacheStrategy

cacheStrategy

getCacheGroup

cacheGroup

isFetchingDataRows

prefetch

prefetch

getPrefetches

createReplacementQuery

resolveId

resolveEntity