Package org.apache.cayenne.query

# Class FluentSelect<T>

java.lang.Object
org.apache.cayenne.query.CacheableQuery
org.apache.cayenne.query.AbstractQuery
org.apache.cayenne.query.FluentSelect<T>

All Implemented Interfaces:
  `Serializable`, `Query`, `Select<T>`

Direct Known Subclasses:
  `ColumnSelect`, `ObjectSelect`

public abstract class FluentSelect<T> extends AbstractQuery implements Select<T>
Base class for `ObjectSelect` and `ColumnSelect`

Since:
  4.0
See Also:
  - Serialized Form

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected String`
  `dbEntityName`
  `protected String`
  `entityName`
  `protected Class<?>`
  `entityType`
  `protected Expression`
  `having`
  `protected Collection<Ordering>`
  `orderings`
  `protected Expression`
  `where`

  ### Fields inherited from class org.apache.cayenne.query.AbstractQuery

  `root`

  ### Fields inherited from class org.apache.cayenne.query.CacheableQuery

  `logger`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `FluentSelect()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `ResultBatchIterator<T>`
  `batchIterator(ObjectContext context, int size)`
  Creates a ResultBatchIterator based on the provided context and batch size.
  `SQLAction`
  `createSQLAction(SQLActionVisitor visitor)`
  A callback method invoked by Cayenne during the final execution phase of the query run.
  `Collection<Property<?>>`
  `getColumns()`
  `String`
  `getDbEntityName()`
  `String`
  `getEntityName()`
  `Class<?>`
  `getEntityType()`
  `Expression`
  `getHaving()`
  Returns a HAVING clause Expression of this query.
  `int`
  `getLimit()`
  `int`
  `getOffset()`
  `Collection<Ordering>`
  `getOrderings()`
  `int`
  `getPageSize()`
  `PrefetchTreeNode`
  `getPrefetches()`
  `int`
  `getQueryTimeout()`
  `int`
  `getStatementFetchSize()`
  `Expression`
  `getWhere()`
  Returns a WHERE clause Expression of this query.
  `void`
  `initWithProperties(Map<String,String> properties)`
  `boolean`
  `isDistinct()`
  `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.
  `protected Object`
  `resolveRoot(EntityResolver resolver)`
  `void`
  `route(QueryRouter router, EntityResolver resolver, Query substitutedQuery)`
  Implements default routing mechanism relying on the EntityResolver to find DataMap based on the query root.
  `protected void`
  `routePrefetches(QueryRouter router, EntityResolver resolver)`
  `List<T>`
  `select(ObjectContext context)`
  Selects objects using provided context.
  `T`
  `selectOne(ObjectContext context)`
  Selects a single object using provided context.

  ### Methods inherited from class org.apache.cayenne.query.AbstractQuery

  `getMetaData, getRoot, setRoot, toString`

  ### Methods inherited from class org.apache.cayenne.query.CacheableQuery

  `getBaseMetaData, getCacheGroup, getCacheStrategy, setCacheGroup, setCacheStrategy, useLocalCache, useLocalCache, useSharedCache, useSharedCache`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

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

  `getMetaData`

  ### Methods inherited from interface org.apache.cayenne.query.Select

  `selectFirst`

- ## Field Details

  - ### entityType

    protected Class<?> entityType

  - ### entityName

    protected String entityName

  - ### dbEntityName

    protected String dbEntityName

  - ### where

    protected Expression where

  - ### having

    protected Expression having

  - ### orderings

    protected Collection<Ordering> orderings

- ## Constructor Details

  - ### FluentSelect

    protected FluentSelect()

- ## Method Details

  - ### resolveRoot

    protected Object resolveRoot(EntityResolver resolver)

  - ### getStatementFetchSize

    public int getStatementFetchSize()

  - ### getQueryTimeout

    public int getQueryTimeout()
    Since:
      4.2

  - ### getPageSize

    public int getPageSize()

  - ### getLimit

    public int getLimit()

  - ### getOffset

    public int getOffset()

  - ### getEntityType

    public Class<?> getEntityType()

  - ### getEntityName

    public String getEntityName()

  - ### getDbEntityName

    public String getDbEntityName()

  - ### getWhere

    public Expression getWhere()
    Returns a WHERE clause Expression of this query.

  - ### getHaving

    public Expression getHaving()
    Returns a HAVING clause Expression of this query.

  - ### getOrderings

    public Collection<Ordering> getOrderings()

  - ### getPrefetches

    public PrefetchTreeNode getPrefetches()

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

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

  - ### createSQLAction

    public SQLAction createSQLAction(SQLActionVisitor visitor)
    Description copied from interface: `Query`
    A callback method invoked by Cayenne during the final execution phase of the query run. A concrete query implementation is given a chance to decide how it should be handled. Implementors can pick an appropriate method of the SQLActionVisitor to handle itself, create a custom SQLAction of its own, or substitute itself with another query that should be used for SQLAction construction.
    Specified by:
      `createSQLAction` in interface `Query`
    Specified by:
      `createSQLAction` in class `AbstractQuery`

  - ### route

    public void route(QueryRouter router, EntityResolver resolver, Query substitutedQuery)
    Description copied from class: `AbstractQuery`
    Implements default routing mechanism relying on the EntityResolver to find DataMap based on the query root. This mechanism should be sufficient for most queries that "know" their root.
    Specified by:
      `route` in interface `Query`
    Overrides:
      `route` in class `AbstractQuery`

  - ### isFetchingDataRows

    public boolean isFetchingDataRows()

  - ### routePrefetches

    protected void routePrefetches(QueryRouter router, EntityResolver resolver)

  - ### getColumns

    public Collection<Property<?>> getColumns()
    Since:
      4.2

  - ### isDistinct

    public boolean isDistinct()
    Since:
      4.2

  - ### initWithProperties

    public void initWithProperties(Map<String,String> properties)
    Since:
      4.2