org.apache.cayenne.query

## Class SelectById<T>

- 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()`

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

Copyright © 2001–2018 Apache Cayenne. All rights reserved.