PreselectQuery (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.persist.AbstractQuery
- - com.goldencode.p2j.persist.PreselectQuery

All Implemented Interfaces:

BufferCollection, RecordChangeListener, SessionListener, IndexInformation, Joinable, P2JQuery, QueryConstants, Scrollable, Finalizable, Openable

Direct Known Subclasses:

AdaptiveQuery, PresortQuery
```
public class PreselectQuery
extends AbstractQuery
implements Joinable, RecordChangeListener, QueryConstants, Finalizable, SessionListener
```
Query which issues an FQL query to the database server and uses a scrollable database cursor to navigate over the set of results. This query is used to back converted Progress queries which either explicitly or implicitly cause a result list to be preselected. Both single- and multi-table queries are supported. Because this class implements the Joinable interface, instances may be added as components of a CompoundQuery.
The query is lazily executed the first time a record retrieval/navigation method is invoked. Only the database identifiers (i.e., primary keys) of the records are retrieved by the initial query. On each subsequent fetch, a row in this result list is retrieved, where each column contains the primary key for the record associated with the corresponding query component. The record for each primary key is retrieved and stored in its associated buffer.
At this time, outer joins are not supported. Furthermore, components may only specify NEXT as their iteration type at this time. FIRST and LAST currently are not supported.
When used to represent a Progress query (created with DEFINE or OPEN QUERY), lenient-off-end must be enabled at construction. This mode suppresses end condition exceptions for next and previous commands which run off the end of the query's results.
This query may be integrated with a client-side where clause expression, by passing a non-null Supplier<logical> argument to one of the single-table constructor variants. Note that additional components may not be added to an instance so created, since this type of query must act against no more than one record buffer. If a multi-table preselect query is called for, CompoundQuery must be used, though its components may be instances of this class.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class PreselectQuery.TemplateResults
Special Results implementation for template records.
- Nested classes/interfaces inherited from interface com.goldencode.p2j.persist.P2JQuery
  P2JQuery.Parameter, P2JQuery.ParamResolver, P2JQuery.QueryEventListener, P2JQuery.QueryOpenedListener
- Nested classes/interfaces inherited from interface com.goldencode.p2j.persist.event.SessionListener
  SessionListener.Event, SessionListener.Scope

Nested Classes
Modifier and Type	Class and Description
`private static class`	`PreselectQuery.TemplateResults` Special `Results` implementation for template records.

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`betweenRows` Has query been repositioned between result rows?
`private Finalizable`	`cleaner` Cleaner executed when this query's block is exit.
`protected java.util.ArrayList<QueryComponent>`	`components` Components of the query; at least 1 is required
`protected boolean`	`currentRowDeleted` Determines if the current row was deleted by DELETE-RESULT-LIST-ENTRY.
`private java.util.List<java.lang.String>`	`dynamicSorts` The list of sorting criteria added dynamically, at runtime.
`private static java.util.ArrayList<SortCriterion>`	`EMPTY_ARRAY` Empty array instance.
`private boolean`	`forceOnlyId` Force the query to retrieve only the ids
`private java.lang.String`	`fql` FQL query string to retrieve primary key ID arrays
`private boolean`	`fullRecords` Force query to retrieve full records, rather than primary keys only
`private static CentralLogger`	`LOG` Logger
`private static boolean`	`LOG_FINE` Test whether the log messages with FINE priority are allowed.
`protected OffEnd`	`offEnd` Has the query run off either end of its result set?
`private Persistence`	`persistence` Persistence object which this query's components use
`private static NanoTimer`	`QUERY_ASSEMBLE` Instrumentation for `assembleFQL()`.
`private boolean`	`regCleaner` Has query been registered for resource cleanup?
`private boolean`	`regWithSession` Is query registered for session event notification?
`private RepositionCache`	`repoCache` Cache of primary key lists to result set row numbers
`private boolean`	`resolvableArgs` Does this query have any arguments which are runtime resolvable?
`private Results`	`results` Result set for this query
`private int`	`rowCount` Number of total results returned
`private boolean`	`scrolling` Flag indicating results must be scrollable
`protected java.lang.String`	`sort` FQL order by clause used across all query components
`protected boolean`	`sortTranslated` Flag indicating if the `sort` has been translated.
`private boolean`	`thisFinalizable` Flag indicating that this instance was registered as a finalizable.
`protected boolean`	`unregisterOnCleanup` Determines if this will be unregistered from ChangeBroker on cleanup.
`private java.util.List<java.util.function.Supplier<logical>>`	`whereExprList` List of client-side where clause expressions
`private boolean`	`whereTranslated` Flag indicated if the WHERE clause has been translated.

Fields inherited from class com.goldencode.p2j.persist.AbstractQuery
closed, dynamicPredicate, errorHelper, excluded, included, indexedReposition, inverseSorting, lenientOffEnd, outer, parameterFilter

Fields inherited from interface com.goldencode.p2j.persist.QueryConstants
CURRENT, FIRST, ITERATE, LAST, NEXT, NONE, PREVIOUS, RETRIEVE_MODES, UNIQUE

Constructor Summary

Constructors
Constructor and Description

PreselectQuery()
Default constructor.

Constructors
Constructor and Description
`PreselectQuery()` Default constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`_isOffEnd()` Indicate whether the query has run off either end of its result set, due to scrolling beyond the last record or before the first record.
`void`	`addComponent(DataModelObject dmo, java.lang.String where)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, DataModelObject inverse)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, DataModelObject inverse, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, DataModelObject inverse, java.lang.Object[] args)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, DataModelObject inverse, java.lang.Object[] args, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, DataModelObject inverse, java.lang.Object[] args, LockType lockType, int iteration, boolean outer)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.Object[] args)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.Object[] args, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.Object[] args, LockType lockType, int iteration, boolean outer)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, DataModelObject inverse)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, DataModelObject inverse, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, DataModelObject inverse, java.lang.Object[] args)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, DataModelObject inverse, java.lang.Object[] args, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, DataModelObject inverse, java.lang.Object[] args, LockType lockType, int iteration, boolean outer)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, java.lang.Object[] args)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, java.lang.Object[] args, LockType lockType)` Add a component to the query.
`void`	`addComponent(DataModelObject dmo, java.lang.String where, java.lang.String indexInfo, java.lang.Object[] args, LockType lockType, int iteration, boolean outer)` Add a component to the query.
`protected void`	`addComponent(QueryComponent comp)` Add a component to the query.
`boolean`	`addDynamicFilter(FieldReference fr, BaseDataType val, java.lang.String format)` Adds a new constraint term to the where predicate of this query, effectively filtering out any rows whose referenced field does not match the requested value.
`(package private) void`	`addDynamicSortCriterion(FieldReference fr, boolean asc)` Adds a new sorting criterion as the strongest criterion for sorting the result of this query.
`P2JQuery`	`addExternalBuffers(DataModelObject... dmos)` Add one or more buffers to the list of those which this query references externally.
`void`	`addWhereExpression(java.util.function.Supplier<logical> whereExpr)` Add a client-side where expression to this query.
`protected boolean`	`anyBoundBufferInComponent()` Check if any query component (added until the current call) has bound buffers.
`private java.lang.String`	`assembleFQL()` Assemble the FQL which is submitted to Hibernate in order to execute the database query underlying this object.
`private void`	`assembleFQLImpl(java.lang.StringBuilder buf)` Assemble the FQL which is submitted to Hibernate in order to execute the database query underlying this object.
`protected FQLExpression`	`assembleFromAndWhereClauses(java.util.ArrayList<SortCriterion> sortCriteria)` Assemble the from and the where clause for an FQL query.
`protected java.util.ArrayList<SortCriterion>`	`assembleOrderByClause()` Assemble the `order by` clause for an FQL query.
`protected java.util.ArrayList<SortCriterion>`	`assembleOrderByClause(java.util.List<SortCriterion> sortCriteria)` Assemble the `order by` clause for an FQL query.
`protected java.util.List<SortCriterion>`	`assembleOrderByClause(java.lang.String sort)` Assemble the `order by` clause for an FQL query.
`protected void`	`assembleSelectClause(java.lang.StringBuilder buf)` Assemble the select clause for an FQL projection query, where the only field retrieved for each buffer is the primary key.
`protected void`	`assembleWhereClause(java.util.ArrayList<SortCriterion> sortCriteria, int indices, FQLExpression whereClause, FQLExpression onClause, boolean isOn)` Assemble the restriction (i.e., where) clause for an FQL query.
`boolean`	`backward(int rows)` Move the current cursor position backward by the specified number of rows.
`boolean`	`backward(NumberType rows)` Move the current cursor position backward by the specified number of rows.
`protected java.util.ArrayList<SortCriterion>`	`buildSortCriteria(java.lang.String sort)` Returns a list `SortCriterion` objects build from the given sort clause.
`protected Results`	`cacheResults(Results target)` Attempt to cache all results from the specified target result set into a `Results` instance.
`void`	`cleanup()` Clean up query resources when this query's scope ends.
`void`	`clearDynamicFilters()` Clears any dynamically filters added at runtime.
`(package private) void`	`clearDynamicSortCriteria()` Clears any dynamically sort criteria added at runtime.
`protected void`	`clearRepoCache()` Clear the reposition cache of visited, virtual composite rows.
`void`	`close()` Explicitly close the query.
`void`	`close(boolean inResource)` Explicitly close the prepared query.
`protected java.util.ArrayList<QueryComponent>`	`components()` Get the query components.
`protected boolean`	`coreFetch(java.lang.Object[] data, LockType lockType, boolean errorIfNull, boolean silentIfNullId)` Fetch all records for a given result row into their backing buffers, given an array of data which contains one primary key or DMO per query component.
`logical`	`createResultListEntry()` Creates an entry in the result list for the current row.
`protected Results`	`createResults(Results results)` Optionally wrapper the result set created for the query with a filtering `Results` implementation (for client-side where processing).
`boolean`	`current()` Reload the current composite row of results for the query.
`boolean`	`current(LockType lockType)` Reload the current composite row of results for the query, overriding the lock type to apply to each record.
`integer`	`currentRow()` Progress-compatible function that returns the 1-based index of the current row in the result set.
`integer`	`currentRowImpl()` Get the 1-based index of the current row in the result set.
`void`	`deleted()` Provides a notification that the external program scope in which the object is registered is is being deleted and the object's reference will be lost after this method is called.
`logical`	`deleteResultListEntry(boolean allowBetweenRows)` Deletes the current row of a query's result list.
`void`	`deregisteredSessionListener()` Invoked when this session listener is removed from the list of registered session listeners.
`protected boolean`	`execute()` Compose an FQL query statement to represent the combination of all query components, execute it, and store the scrollable results.
`protected Results`	`executeQuery(Persistence persistence, java.lang.String fql, java.lang.Object[] args)` Execute the query to create a first level result set.
`protected <T> ScrollableResults<T>`	`executeScroll(Persistence persistence, java.lang.String fql, java.lang.Object[] args)` Execute the query to create a `ScrollableResults` result set.
`protected void`	`fetch(boolean available, LockType lockType, boolean errorIfNull)` Fetch all records for a given result row into their backing buffers.
`private QueryComponent`	`findComponent(RecordBuffer buffer)` Find the query component associated with the given record buffer.
`void`	`finished()` Provides a notification that the scope in which this query was created is ending.
`boolean`	`first()` Retrieve the first composite row of results for the query.
`boolean`	`first(LockType lockType)` Retrieve the first composite row of results for the query.
`void`	`forceDynamicOperation()` Force this query to operate in dynamic retrieval mode, if it supports this mode.
`boolean`	`forward(int rows)` Advance the current cursor position forward by the specified number of rows.
`boolean`	`forward(NumberType rows)` Advance the current cursor position forward by the specified number of rows.
`private void`	`generateOrderBy(java.util.ArrayList<SortCriterion> sortCriteria, java.lang.StringBuilder buf)` Generates the `order by` clause starting from the list of criteria, including the "order by" keyword.
`java.lang.Object[]`	`getArgs()` Get the query substitution arguments associated with this query, if any.
`protected java.lang.String[]`	`getEntities()` Collect the names of the entities (DMO types) associated with this query.
`RecordBuffer[]`	`getExternalBuffers()` Get the external buffers, if any, associated with this query.
`protected java.lang.String`	`getHQL()` Get the FQL query which was executed to produce this query's results.
`AbstractJoin`	`getJoin()` Get the legacy natural join, if any, associated with this query.
`OffEnd`	`getOffEnd()` Get the off-end status of this query, which indicates whether the query has run off either end of its results.
`java.util.ArrayList<QueryOffEndListener>`	`getOffEndListeners()` Get all the off-end listeners associated with this query.
`java.lang.String`	`getOriginalWhere()` Get the original, FQL where clause associated with this query.
`protected Persistence`	`getPersistence()` Get the persistence service object used by this query.
`RecordBuffer[]`	`getRecordBuffers()` Access the record buffers manipulated by this query, in order from left-most (outermost) table of the query's join (if any) to right-most (innermost) table.
`protected Results`	`getResults()` Access the current `Results` object for this query.
`java.lang.Object[]`	`getRow()` Assemble an array of primary key IDs for the current record(s) in the buffers underlying this query, from left-most to right-most (in the sense of how the query joins the associated tables).
`java.lang.String`	`getSortPhrase()` Get the sort phrase associated with this query.
`int`	`getTableCount()` Get the number of tables joined by this query.
`protected java.lang.Long`	`getTemplateQueryRowid(java.lang.Object[] args)` Checks if this is a template query.
`protected java.util.List<java.util.function.Supplier<logical>>`	`getWhereExpressions()` Get this query's client-side where expressions.
`protected void`	`handleMissingJoinRecord()` Respond to the condition that a component with a non-null JOIN has a missing inverse on which to perform the join.
`boolean`	`hasWhereExpression()` Indicate whether this query has a client-side where clause expression associated with it.
`character`	`indexInformation(NumberType n)` Conversion of INDEX-INFORMATION attribute (KW_IDX_INFO).
`PreselectQuery`	`initialize(boolean lenientOffEnd, java.lang.String sort)` Initializer logic which is typically used for a multi-table query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, DataModelObject inverse)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, DataModelObject inverse, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, DataModelObject inverse, java.lang.Object[] args)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, DataModelObject inverse, java.lang.Object[] args, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.Object[] args)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.Object[] args, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, DataModelObject inverse)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, DataModelObject inverse, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, DataModelObject inverse, java.lang.Object[] args)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, DataModelObject inverse, java.lang.Object[] args, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, java.lang.Object[] args)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(DataModelObject dmo, java.lang.String where, java.util.function.Supplier<logical> whereExpr, java.lang.String sort, java.lang.String indexInfo, java.lang.Object[] args, LockType lockType)` Initializer logic designed for a single-table preselect query.
`PreselectQuery`	`initialize(java.lang.String sort)` Initializer logic which is typically used for a multi-table query.
`protected boolean`	`isClientWhere()` Indicate whether this query requires initial results to be filtered through a client-side where clause expression.
`boolean`	`isFullRecords()` Indicate whether the query will retrieve full records, rather than primary keys only.
`protected boolean`	`isLenientOffEnd()` Indicate whether this query will throw a `QueryOffEndException` when it runs off the end of its results.
`boolean`	`isNativelyPreselect()` Indicate whether this query is a preselect query by its nature.
`protected boolean`	`isNativelyScrolling()` Indicate whether this query type is scrolling by its nature.
`private boolean`	`isOrderByRequired()` Function for deciding whether the ORDER BY clause is required in the FQL.
`boolean`	`isPreselect()` Indicate whether this query preselects all of its results.
`private boolean`	`isResultSetCached()` Indicate whether the full result set for this query has been cached.
`boolean`	`isScrolling()` Indicate whether this query's `scrolling` flag has been set.
`protected boolean`	`isTopLevelCleanup()` Indicate whether results resources should be cleaned up upon exiting the global scope or upon exiting the nearest enclosing scope in which the results were created.
`void`	`iterate()` Provides a notification that the block whose scope in which the object is registered is about to iterate and attempt another pass.
`boolean`	`last()` Retrieve the last composite row of results for the query.
`boolean`	`last(LockType lockType)` Retrieve the last composite row of results for the query.
`void`	`load(java.lang.Object[] data, LockType lockType, boolean silentIfNullId)` Load one or more records into their associated buffers, given an array of primary key ID values, or the actual DMOs themselves.
`AdaptiveComponent`	`makeAdaptiveServerJoinComponent(java.util.List<AdaptiveComponent> joinList, AdaptiveQuery query, int iteration, boolean outer, CompoundComponent fallback)` Create an adaptive query component based on the information in this query (which is presumed to be a single-table query), and given a list of adaptive query components which represent outer, nested query loops, which will perform a server-side join to the innermost, nested query component.
`QueryComponent`	`makePreselectServerJoinComponent(java.util.List<QueryComponent> joinList, int iteration, boolean outer)` Create a preselect query component based on the information in this query (which is presumed to be a single-table query), and given a list of preselect query components which represent outer, nested query loops, which will perform a server-side join to the innermost, nested query component.
`boolean`	`next()` Retrieve the next composite row of results for the query.
`boolean`	`next(LockType lockType)` Retrieve the next composite row of results for the query.
`void`	`open()` Open the prepared query and reposition it to the first result if the query is being browsed.
`java.lang.Object[]`	`peekFirst()` Fetch the array of primary key IDs associated with the first result in this query's result list.
`java.lang.Object[]`	`peekLast()` Fetch the array of primary key IDs associated with the last result in this query's result list.
`java.lang.Object[]`	`peekNext()` Fetch the array of primary key IDs associated with the next result in this query's result list.
`java.lang.Object[]`	`peekPrevious()` Fetch the array of primary key IDs associated with the previous result in this query's result list.
`protected void`	`prepareParameters(java.util.List<java.lang.Object> args)` Prepare query substitution parameters for this query.
`protected void`	`prepareReposition()` Prepare to process a reposition request by releasing the current records, if any, in each buffer managed by the query.
`protected boolean`	`preserveBuffersOnEmptyResults(Results results)` Indicate whether the record buffer(s) current record(s) should be preserved, in the event the query does not find any results.
`boolean`	`previous()` Retrieve the previous composite row of results for the query.
`boolean`	`previous(LockType lockType)` Retrieve the previous composite row of results for the query.
`protected AbstractJoin`	`processJoin(BufferReference primary, BufferReference inverse)` Given a primary DMO buffer and an inverse DMO buffer which together define a natural join, create the `AbstractJoin` helper object which is used to implement the join.
`java.util.Iterator<RecordBuffer>`	`recordBuffers()` Report the record buffers for whose changes this object is interested in listening.
`protected void`	`registerCleaner()` Register a `Finalizable` with the transaction manager for resource cleanup when this query's scope ends.
`void`	`registerRecordChangeListeners(java.lang.Integer scope)` Register all `RecordChangeListener`s associated with this query (if any), with the context-local `ChangeBroker` at the indicated scope.
`void`	`releaseBuffers()` Release all buffers.
`void`	`reposition(int row)` Reposition the query to the specified row in the result set.
`void`	`reposition(NumberType row)` Reposition the cursor to the specified row in the result set.
`boolean`	`repositionByID(java.lang.Long... joinIDs)` Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified array of primary key IDs.
`protected boolean`	`repositionByID(java.lang.Long[] ids, boolean forceFetch)` Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified array of primary key IDs.
`void`	`repositionByID(recid id)` Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified primary key ID.
`void`	`repositionByID(rowid id1, rowid... joinIDs)` Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified array of primary key IDs.
`void`	`reset(boolean resolveArgs, boolean forceOrigArgs)` Reset the query by clearing its state to a known default.
`protected void`	`resetResults()` Discard the current result set, clear the reposition cache, and reset result-related state to default values.
`void`	`retry()` Provides a notification that the block whose scope in which the object is registered is about to retry the same iteration (all loop control data is unchanged).
`boolean`	`sessionEvent(SessionListener.Event event)` Respond to a clean (i.e., transaction commit) session event by caching all preselected results and using that cache to back the query's results for all future fetches.
`protected void`	`setEmptyBuffersUnknown()` Walk through each component and set its backing buffer to unknown mode, such that the invocation of any of its DMO-backed methods returns unknown value.
`void`	`setFullRecords()` Force the query to retrieve full records, rather than primary keys only.
`void`	`setIterationType(int iteration)` Set the iteration type for the most recently added query component.
`void`	`setIterationType(int iteration, java.lang.String sort)` Set the iteration type for the most recently added query component.
`void`	`setLenientOffEnd(boolean lenientOffEnd)` Set the behavior of this query as a record retrieval request moves off the end of its results.
`void`	`setNonScrolling()` Disable results list scrolling/repositioning (if it was enabled by default).
`void`	`setResults(Results results)` Set the given results object into this query.
`void`	`setScrolling()` Override parent's no-op implementation to track whether client code has set this as a scrollable query.
`void`	`setUnknownRecord()` Set each buffer backing a query component to unknown mode.
`boolean`	`shouldRegisterRecordChangeListeners()` Check if this type of query should register record change listeners.
`protected boolean`	`shouldUpdateAnyLock(LockType lockType)` Check if the lock should be updated for any component when fetching.
`integer`	`size()` Return the number of results found for this query.
`void`	`stateChanged(RecordChangeEvent event)` Respond to a `RecordChangeEvent`.
`protected boolean`	`supportsArbitraryIteration()` Does this query support non-NEXT iteration components?
`java.lang.String`	`toString()` Create a string representation of this object's state, primarily for debug purposes.
`void`	`translateWhere()` Translate the WHERE clause for all `components`.
`protected boolean`	`treatPreviousAsLast()` Indicate whether a call to move to the previous record in the result list should be treated as a call to move to the last record in the list.
`boolean`	`unique()` Retrieve a unique record (only valid for a single-table query).
`boolean`	`unique(LockType lockType)` Retrieve a unique record (only valid for a single-table query), overriding the default lock type of the underlying query component.
`private boolean`	`validateReposition(NumberType value)` Validate a numeric value provided to a reposition request to ensure that it does not represent the unknown value.
`private boolean`	`validateRepositionByID(recid value)` Validate a record identifier provided to a reposition request to ensure that it does not represent the unknown value.
`private boolean`	`validateRepositionByID(rowid value)` Validate a row identifier provided to a reposition request to ensure that it does not represent the unknown value.
`private boolean`	`validateRepositionImpl(BaseDataType value, int errorNum, java.lang.String errorMsg)` Validate a numeric value provided to a reposition request to ensure that it does not represent the unknown value.
`protected boolean`	`verifyJoins()` Invoked just before query execution, this method checks whether all components with a non-null JOIN have a valid inverse on which to perform the join.
`protected java.util.Iterator<java.util.function.Supplier<logical>>`	`whereExpressions()` Get an iterator on this query's client-side where expressions.

Methods inherited from class com.goldencode.p2j.persist.AbstractQuery
_getNext, _isSkipDeletedRecord, accumulate, addAccumulator, addAccumulator, addBuffer, addBuffer, addQueryEventListener, addRepositionListener, afterReposition, afterReposition, afterReposition, bufferHandle, bufferHandle, bufferHandle, bufferHandle, bufferHandle, buffersMatch, changeForwardOnly, changeForwardOnly, deleteResultListEntry, exclude, forwardOnly, getCache, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getDataRelation, getDefaultLock, getErrorHelper, getExternalBuffersDefs, getFirst, getFirst, getFirst, getFirst, getFirst, getFirst, getFirst, getFirst, getLast, getLast, getLast, getLast, getLast, getLast, getLast, getLast, getNext, getNext, getNext, getNext, getNext, getNext, getNext, getNumResults, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getReferencedBuffers, hasAccumulators, hasAny, hasAny, hasAny, hasAny, hasOne, hasOne, hasOne, hasOne, include, indexInformation, indexInformation, isBrowsed, isDynamicPredicate, isErrorIfNull, isFatalError, isFetchOnReposition, isFillingBrowseRows, isIndexedReposition, isIterating, isLastOfBreakGroup, isNewBreakGroup, isOffEnd, isOmitAlias, isOpen, isPresort, isRepositionNotificationActive, isSkipDeletedRecord, isStandalone, loadRowAtCursor, notifyQueryCloseListeners, notifyQueryOpenListeners, notifyRepositionListeners, numBuffers, numResults, numResults, prepare, prepare, prepareFetch, prepareString, preprocessSubstitutionArguments, queryBackward, queryBackward, queryClose, queryForward, queryForward, queryOpen, queryReposition, queryReposition, queryRepositionByID, removeRepositionListener, setBrowsed, setBuffers, setBuffers, setCache, setCache, setDataRelation, setDynamicPredicate, setErrorIfNull, setFatalError, setFetchOnReposition, setFillingBrowseRows, setIndexedReposition, setIterating, setOmitAlias, setOuter, setParameterFilter, setPresort, setSkipDeletedRecord, setStandalone, silentCurrent, silentCurrent, silentFirst, silentFirst, silentLast, silentLast, silentNext, silentNext, silentPrevious, silentPrevious, silentUnique, silentUnique, translateSort, translateSort, translateWhere

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

Methods inherited from interface com.goldencode.p2j.persist.Joinable
clearResults, getReferencedBuffers, setErrorIfNull, setOuter

Methods inherited from interface com.goldencode.p2j.persist.P2JQuery
_getNext, addAccumulator, addAccumulator, addQueryEventListener, addRepositionListener, changeForwardOnly, changeForwardOnly, deleteResultListEntry, exclude, forwardOnly, getBasicLogging, getCache, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getCurrent, getDataRelation, getFirst, getFirst, getFirst, getFirst, getFirst, getFirst, getFirst, getFirst, getLast, getLast, getLast, getLast, getLast, getLast, getLast, getLast, getNext, getNext, getNext, getNext, getNext, getNext, getNext, getNext, getNumResults, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, getPrevious, hasAny, hasAny, hasAny, hasAny, hasOne, hasOne, hasOne, hasOne, hintFullResults, include, indexInformation, indexInformation, isBrowsed, isDynamicPredicate, isFetchOnReposition, isFillingBrowseRows, isFindByRowid, isFirstOfGroup, isFirstOfGroup, isIndexedReposition, isIterating, isLastOfGroup, isLastOfGroup, isOffEnd, isPresort, isSkipDeletedRecord, isStandalone, notifyQueryCloseListeners, notifyQueryOpenListeners, notifyRepositionListeners, prepare, prepare, prepareString, queryBackward, queryBackward, queryClose, queryForward, queryForward, queryOpen, queryReposition, queryReposition, queryRepositionByID, queryRepositionByID, removeRepositionListener, resetQuery, setBasicLogging, setBasicLogging, setBrowsed, setCache, setCache, setDataRelation, setDynamicPredicate, setFetchOnReposition, setFillingBrowseRows, setIndexedReposition, setIterating, setParameterFilter, setPresort, setSkipDeletedRecord, setStandalone

Methods inherited from interface com.goldencode.p2j.persist.BufferCollection
addBuffer, addBuffer, addBuffer, addBuffer, bufferHandle, bufferHandle, bufferHandle, bufferHandle, bufferHandle, numBuffers, setBuffers, setBuffers, setBuffers

Methods inherited from interface com.goldencode.p2j.util.Openable
isOpen

Methods inherited from interface com.goldencode.p2j.util.Finalizable
entry, initFailure, weight

- Field Detail
  - EMPTY_ARRAY
```
private static final java.util.ArrayList<SortCriterion> EMPTY_ARRAY
```
    Empty array instance.
  - LOG
```
private static final CentralLogger LOG
```
    Logger
  - QUERY_ASSEMBLE
```
private static final NanoTimer QUERY_ASSEMBLE
```
    Instrumentation for assembleFQL().
  - betweenRows
```
protected boolean betweenRows
```
    Has query been repositioned between result rows?
  - offEnd
```
protected OffEnd offEnd
```
    Has the query run off either end of its result set?
  - sort
```
protected java.lang.String sort
```
    FQL order by clause used across all query components
  - components
```
protected java.util.ArrayList<QueryComponent> components
```
    Components of the query; at least 1 is required
  - currentRowDeleted
```
protected boolean currentRowDeleted
```
    Determines if the current row was deleted by DELETE-RESULT-LIST-ENTRY. Note that if the query is off-end, it also can be "deleted".
  - sortTranslated
```
protected boolean sortTranslated
```
    Flag indicating if the sort has been translated.
  - whereExprList
```
private java.util.List<java.util.function.Supplier<logical>> whereExprList
```
    List of client-side where clause expressions
  - persistence
```
private Persistence persistence
```
    Persistence object which this query's components use
  - scrolling
```
private boolean scrolling
```
    Flag indicating results must be scrollable
  - repoCache
```
private final RepositionCache repoCache
```
    Cache of primary key lists to result set row numbers
  - fql
```
private java.lang.String fql
```
    FQL query string to retrieve primary key ID arrays
  - results
```
private Results results
```
    Result set for this query
  - resolvableArgs
```
private boolean resolvableArgs
```
    Does this query have any arguments which are runtime resolvable?
  - rowCount
```
private int rowCount
```
    Number of total results returned
  - regWithSession
```
private boolean regWithSession
```
    Is query registered for session event notification?
  - regCleaner
```
private boolean regCleaner
```
    Has query been registered for resource cleanup?
  - unregisterOnCleanup
```
protected boolean unregisterOnCleanup
```
    Determines if this will be unregistered from ChangeBroker on cleanup.
  - cleaner
```
private final Finalizable cleaner
```
    Cleaner executed when this query's block is exit.
  - thisFinalizable
```
private boolean thisFinalizable
```
    Flag indicating that this instance was registered as a finalizable.
  - fullRecords
```
private boolean fullRecords
```
    Force query to retrieve full records, rather than primary keys only
  - forceOnlyId
```
private boolean forceOnlyId
```
    Force the query to retrieve only the ids
  - dynamicSorts
```
private java.util.List<java.lang.String> dynamicSorts
```
    The list of sorting criteria added dynamically, at runtime.
  - whereTranslated
```
private boolean whereTranslated
```
    Flag indicated if the WHERE clause has been translated.
  - LOG_FINE
```
private static final boolean LOG_FINE
```
    Test whether the log messages with FINE priority are allowed.
- Constructor Detail
  - PreselectQuery
```
public PreselectQuery()
```
    Default constructor. Initialization is deferred until initialize() is called.
- Method Detail
  - initialize
```
public PreselectQuery initialize(java.lang.String sort)
```
    Initializer logic which is typically used for a multi-table query. Details specific to each table component of the query are added via one of the addComponent method variants.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    sort - FQL order by clause to be applied across all components of the query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(boolean lenientOffEnd,
                                 java.lang.String sort)
```
    Initializer logic which is typically used for a multi-table query. Details specific to each table component of the query are added via one of the addComponent method variants.
    This variant is used by code which is converted from an OPEN QUERY statement, which permits advancing off the end of a result set without raising a QueryOffEndException.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    lenientOffEnd - true if advancing past either end of the result set should NOT raise a QueryOffEndException; false if doing so should raise the exception.
    
    sort - FQL order by clause to be applied across all components of the query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 DataModelObject inverse)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 DataModelObject inverse)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.Object[] args)
```
    Initializer logic designed for a single-table preselect query. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 java.lang.Object[] args)
```
    Initializer logic designed for a single-table preselect query. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 DataModelObject inverse,
                                 java.lang.Object[] args)
```
    Initializer logic designed for a single-table preselect query. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 DataModelObject inverse,
                                 java.lang.Object[] args)
```
    Initializer logic designed for a single-table preselect query. A share lock will be applied to retrieved records.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 DataModelObject inverse,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 DataModelObject inverse,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query. The where clause must expect no substitution parameters.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.Object[] args,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 java.lang.Object[] args,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 DataModelObject inverse,
                                 java.lang.Object[] args,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this query.
    
    Returns:
    
    This query instance.
  - initialize
```
public PreselectQuery initialize(DataModelObject dmo,
                                 java.lang.String where,
                                 java.util.function.Supplier<logical> whereExpr,
                                 java.lang.String sort,
                                 java.lang.String indexInfo,
                                 DataModelObject inverse,
                                 java.lang.Object[] args,
                                 LockType lockType)
```
    Initializer logic designed for a single-table preselect query.
    This code is intentionally separated from the constructor. The purpose of this separation is to allow construction to occur in the prior scope while initialization can still occur within a method or lambda that is inside the next block's scope.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    whereExpr - Client-side where clause expression. May be null.
    
    sort - FQL order by clause.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this query. If null, the default lock level is assumed.
    
    Returns:
    
    This query instance.
  - translateWhere
```
public void translateWhere()
```
    Translate the WHERE clause for all components.
    
    Specified by:
    
    translateWhere in interface Joinable
  - setLenientOffEnd
```
public void setLenientOffEnd(boolean lenientOffEnd)
```
    Set the behavior of this query as a record retrieval request moves off the end of its results. If set to lenient mode, invocations of next and previous which do not find a record do not raise a QueryOffEndException. By default, this would normally raise the exception.
    
    Specified by:
    
    setLenientOffEnd in interface P2JQuery
    
    Overrides:
    
    setLenientOffEnd in class AbstractQuery
    
    Parameters:
    
    lenientOffEnd - true to suppress QueryOffEndException for next and previous requests; false to permit these exceptions.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - share lock
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - share lock
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         DataModelObject inverse)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - share lock
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         DataModelObject inverse)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - share lock
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.Object[] args)
```
    Add a component to the query. The following defaults are used:
    - share lock
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         java.lang.Object[] args)
```
    Add a component to the query. The following defaults are used:
    - share lock
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         DataModelObject inverse,
                         java.lang.Object[] args)
```
    Add a component to the query. The following defaults are used:
    - share lock
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         DataModelObject inverse,
                         java.lang.Object[] args)
```
    Add a component to the query. The following defaults are used:
    - share lock
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         DataModelObject inverse,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         DataModelObject inverse,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - no substitution parameters
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.Object[] args,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         java.lang.Object[] args,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - inner join
    - NEXT iteration type
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         DataModelObject inverse,
                         java.lang.Object[] args,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         DataModelObject inverse,
                         java.lang.Object[] args,
                         LockType lockType)
```
    Add a component to the query. The following defaults are used:
    - inner join
    - NEXT iteration type
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.Object[] args,
                         LockType lockType,
                         int iteration,
                         boolean outer)
```
    Add a component to the query. The following defaults are used:
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
    
    iteration - Iteration/retrieval mode for this component of the query. At this time, only NEXT is supported. Future support for FIRST, LAST, and UNIQUE is expected.
    
    outer - true if an outer join is required. At this time, only inner joins are supported. Future support for outer joins is expected.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if outer is true (temporary); if iteration is not NEXT (temporary); if dmo's associated database is different than that of a previously added component's database (cross-database preselect joins are not possible).
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         java.lang.Object[] args,
                         LockType lockType,
                         int iteration,
                         boolean outer)
```
    Add a component to the query. The following defaults are used:
    - no inverse join DMO
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
    
    iteration - Iteration/retrieval mode for this component of the query. At this time, only NEXT is supported. Future support for FIRST, LAST, and UNIQUE is expected.
    
    outer - true if an outer join is required. At this time, only inner joins are supported. Future support for outer joins is expected.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if outer is true (temporary); if iteration is not NEXT (temporary); if dmo's associated database is different than that of a previously added component's database (cross-database preselect joins are not possible).
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         DataModelObject inverse,
                         java.lang.Object[] args,
                         LockType lockType,
                         int iteration,
                         boolean outer)
```
    Add a component to the query.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
    
    iteration - Iteration/retrieval mode for this component of the query. At this time, only NEXT is supported. Future support for FIRST, LAST, and UNIQUE is expected.
    
    outer - true if an outer join is required. At this time, only inner joins are supported. Future support for outer joins is expected.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if outer is true (temporary); if iteration is not NEXT (temporary); if dmo's associated database is different than that of a previously added component's database (cross-database preselect joins are not possible).
  - addComponent
```
public void addComponent(DataModelObject dmo,
                         java.lang.String where,
                         java.lang.String indexInfo,
                         DataModelObject inverse,
                         java.lang.Object[] args,
                         LockType lockType,
                         int iteration,
                         boolean outer)
```
    Add a component to the query.
    
    Parameters:
    
    dmo - DMO proxy which defines buffer and record type.
    
    where - FQL where clause. May be null.
    
    indexInfo - Index information string as it is returned by INDEX-INFORMATION. May be null if it is not an OPEN QUERY case or if you don't need debug information about selected indexes.
    
    inverse - DMO to which this query should join via a foreign relation. May be null.
    
    args - Substitution parameters to be inserted into placeholders within the where clause.
    
    lockType - Lock type to apply to records retrieved by this component of the query.
    
    iteration - Iteration/retrieval mode for this component of the query. At this time, only NEXT is supported. Future support for FIRST, LAST, and UNIQUE is expected.
    
    outer - true if an outer join is required. At this time, only inner joins are supported. Future support for outer joins is expected.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if outer is true (temporary); if iteration is not NEXT (temporary); if dmo's associated database is different than that of a previously added component's database (cross-database preselect joins are not possible).
  - getExternalBuffers
```
public RecordBuffer[] getExternalBuffers()
```
    Get the external buffers, if any, associated with this query.
    
    Specified by:
    
    getExternalBuffers in interface Joinable
    
    Overrides:
    
    getExternalBuffers in class AbstractQuery
    
    Returns:
    
    Array of external buffers or null.
  - shouldRegisterRecordChangeListeners
```
public boolean shouldRegisterRecordChangeListeners()
```
    Check if this type of query should register record change listeners. Use this to avoid computing any scope for registration and end up with a no registration behavior.
    
    Specified by:
    
    shouldRegisterRecordChangeListeners in interface Joinable
    
    Returns:
    
    true if we should invest time into computing the scope in order to call registerRecordChangeListeners(java.lang.Integer) or false if we can skip doing any work to honor registerRecordChangeListeners(java.lang.Integer).
  - registerRecordChangeListeners
```
public void registerRecordChangeListeners(java.lang.Integer scope)
```
    Register all RecordChangeListeners associated with this query (if any), with the context-local ChangeBroker at the indicated scope.
    This implementation does nothing.
    
    Specified by:
    
    registerRecordChangeListeners in interface Joinable
    
    Parameters:
    
    scope - Scope at which listeners should be registered with the change broker.
  - recordBuffers
```
public java.util.Iterator<RecordBuffer> recordBuffers()
```
    Report the record buffers for whose changes this object is interested in listening. This listener will be registered with the ChangeBroker to receive notifications of any change to DMOs whose interface types match those returned by the RecordBuffer.getDMOInterface() methods of the returned buffers.
    
    Specified by:
    
    recordBuffers in interface RecordChangeListener
    
    Returns:
    
    An iterator on the record buffers stored in each of this query's components.
  - stateChanged
```
public void stateChanged(RecordChangeEvent event)
                  throws PersistenceException
```
    Respond to a RecordChangeEvent.
    
    Specified by:
    
    stateChanged in interface RecordChangeListener
    
    Parameters:
    
    event - Event which describes the DMO state change.
    
    Throws:
    
    PersistenceException - if any error occurs while processing the state change event.
  - sessionEvent
```
public boolean sessionEvent(SessionListener.Event event)
                     throws PersistenceException
```
    Respond to a clean (i.e., transaction commit) session event by caching all preselected results and using that cache to back the query's results for all future fetches. If all results already are cached, do nothing.
    Respond to a session closing event by clearing all results, unless they were just cached as described above.
    
    Specified by:
    
    sessionEvent in interface SessionListener
    
    Parameters:
    
    event - Session event type.
    
    Returns:
    
    true, indicating this query should be deregistered as a session listener after this method returns; else false.
    
    Throws:
    
    PersistenceException - if there is an error caching results.
  - deregisteredSessionListener
```
public void deregisteredSessionListener()
```
    Invoked when this session listener is removed from the list of registered session listeners.
    
    Specified by:
    
    deregisteredSessionListener in interface SessionListener
  - finished
```
public void finished()
```
    Provides a notification that the scope in which this query was created is ending. This is a no-op implementation required by the interface.
    
    Specified by:
    
    finished in interface Finalizable
  - deleted
```
public void deleted()
```
    Provides a notification that the external program scope in which the object is registered is is being deleted and the object's reference will be lost after this method is called.
    This is a no-op implementation required by the interface.
    
    Specified by:
    
    deleted in interface Finalizable
  - iterate
```
public void iterate()
```
    Provides a notification that the block whose scope in which the object is registered is about to iterate and attempt another pass. This is a no-op implementation required by the interface.
    
    Specified by:
    
    iterate in interface Finalizable
  - retry
```
public void retry()
```
    Provides a notification that the block whose scope in which the object is registered is about to retry the same iteration (all loop control data is unchanged). This implementation sets the state of the query as if a reposition to the current row has just occurred. This will keep the subsequent call to next() at the top of the block body from advancing to the next row.
    This implementation retries the current record only if the query is associated with a FOR block (see BlockType).
    
    Specified by:
    
    retry in interface Finalizable
  - toString
```
public java.lang.String toString()
```
    Create a string representation of this object's state, primarily for debug purposes.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    String representation of this object.
  - addWhereExpression
```
public void addWhereExpression(java.util.function.Supplier<logical> whereExpr)
```
    Add a client-side where expression to this query. Each initial query result found by the server must be accepted by this expression before becoming a part of the query's final result set.
    
    Parameters:
    
    whereExpr - Client-side where clause expression. May not be null.
    
    Throws:
    
    java.lang.NullPointerException - if whereExpr is null.
  - setIterationType
```
public void setIterationType(int iteration)
```
    Set the iteration type for the most recently added query component.
    
    Parameters:
    
    iteration - Retrieval mode from QueryConstants. Must not be FIRST or LAST (use setIterationType(int, String) instead for these types.
    
    Throws:
    
    java.lang.IllegalStateException - If no component has yet been added.
    
    java.lang.IllegalArgumentException - If iteration type is FIRST or LAST.
  - setIterationType
```
public void setIterationType(int iteration,
                             java.lang.String sort)
```
    Set the iteration type for the most recently added query component.
    
    Parameters:
    
    iteration - Retrieval mode from QueryConstants.
    
    sort - Order by clause which should be associated with the most recently added query component. Must be non-null for iteration types FIRST and LAST.
    
    Throws:
    
    java.lang.IllegalStateException - If no component has yet been added.
    
    java.lang.IllegalArgumentException - If iteration type is FIRST or LAST, but sort is null, or if sort represents an invalid FQL order by expression.
  - first
```
public boolean first()
```
    Retrieve the first composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    first in interface P2JQuery
    
    Returns:
    
    true if query could retrieve the first record sucefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - first
```
public boolean first(LockType lockType)
```
    Retrieve the first composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    first in interface P2JQuery
    
    Parameters:
    
    lockType - Lock type to apply to records retrieved (overrides default lock type set for each query component).
    
    Returns:
    
    true if query could retrive the first record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - last
```
public boolean last()
```
    Retrieve the last composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    last in interface P2JQuery
    
    Returns:
    
    true if query could retrive the last record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - last
```
public boolean last(LockType lockType)
```
    Retrieve the last composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    last in interface P2JQuery
    
    Parameters:
    
    lockType - Lock type to apply to records retrieved (overrides default lock type set for each query component).
    
    Returns:
    
    true if query could retrive the last record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - next
```
public boolean next()
```
    Retrieve the next composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    next in interface P2JQuery
    
    Returns:
    
    true if query could retrive the next record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - next
```
public boolean next(LockType lockType)
```
    Retrieve the next composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    next in interface P2JQuery
    
    Parameters:
    
    lockType - Lock type to apply to records retrieved (overrides default lock type set for each query component).
    
    Returns:
    
    true if query could retrive the next record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - previous
```
public boolean previous()
```
    Retrieve the previous composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    previous in interface P2JQuery
    
    Returns:
    
    true if query could retrive the previous record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - previous
```
public boolean previous(LockType lockType)
```
    Retrieve the previous composite row of results for the query. The underlying buffer for each query component is updated with the appropriate record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    previous in interface P2JQuery
    
    Parameters:
    
    lockType - Lock type to apply to records retrieved (overrides default lock type set for each query component).
    
    Returns:
    
    true if query could retrive the previous record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query or the fetch of any record fails, or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - unique
```
public boolean unique()
```
    Retrieve a unique record (only valid for a single-table query).
    
    Specified by:
    
    unique in interface P2JQuery
    
    Returns:
    
    true if query could retrive the unique record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query fails or if more than one result is found which matches the query criteria.
    
    java.lang.UnsupportedOperationException - if this method is invoked on a multi-table query.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - unique
```
public boolean unique(LockType lockType)
```
    Retrieve a unique record (only valid for a single-table query), overriding the default lock type of the underlying query component.
    
    Specified by:
    
    unique in interface P2JQuery
    
    Parameters:
    
    lockType - Lock type which should override that of the query component.
    
    Returns:
    
    true if query could retrive the unique record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the query fails or if more than one result is found which matches the query criteria.
    
    java.lang.UnsupportedOperationException - if this method is invoked on a multi-table query.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - current
```
public boolean current()
```
    Reload the current composite row of results for the query.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    current in interface P2JQuery
    
    Returns:
    
    true if query could retrive the current record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the reload triggers an error.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - current
```
public boolean current(LockType lockType)
```
    Reload the current composite row of results for the query, overriding the lock type to apply to each record.
    If the query involves outer joins, some of the underlying buffers may be empty when this method returns.
    
    Specified by:
    
    current in interface P2JQuery
    
    Parameters:
    
    lockType - Lock type which should override that of any query component.
    
    Returns:
    
    true if query could retrive the current record succefully; false if unsuccessful and lenientOffEnd is set on true.
    
    Throws:
    
    ErrorConditionException - if the reload triggers an error.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - load
```
public void load(java.lang.Object[] data,
                 LockType lockType,
                 boolean silentIfNullId)
          throws PersistenceException
```
    Load one or more records into their associated buffers, given an array of primary key ID values, or the actual DMOs themselves. The IDs/DMOs are arranged to coincide with the tables underlying the query, from left-most to right-most (in the sense of how they are joined by the query).
    In the event an expected value cannot be loaded (e.g., the record has been deleted or is otherwise no longer available), this method throws MissingRecordException, after setting the associated buffer(s) into unknown mode. Note that a record being locked by another session does not constitute a "missing" record. Note also that this exception is not thrown until all the elements of data have been processed to the extent possible.
    If the QueryComponent is not the first component in components() and the query attached to it is an OUTER-JOIN, we set the buffer into unknown mode otherwise the buffer is released and the method returns immediately.
    
    Specified by:
    
    load in interface Joinable
    
    Parameters:
    
    data - Array of primary key IDs or DMOs, one per table involved in the query.
    
    lockType - Lock type which should by used. Set to null to allow query to use its current lock type.
    
    silentIfNullId - Do not raise MissingRecordException if some of the provided IDs are null. null IDs are valid for queries with OUTER join.
    
    Throws:
    
    MissingRecordException - if any record cannot be loaded, because it is no longer available (e.g., deleted, etc.).
    
    PersistenceException - if there is an error loading data.
    
    See Also:
    
    Joinable.getRow()
  - getOffEndListeners
```
public java.util.ArrayList<QueryOffEndListener> getOffEndListeners()
```
    Get all the off-end listeners associated with this query.
    
    Specified by:
    
    getOffEndListeners in interface P2JQuery
    
    Returns:
    
    the off-end listeners associated with this query.
  - getRow
```
public java.lang.Object[] getRow()
```
    Assemble an array of primary key IDs for the current record(s) in the buffers underlying this query, from left-most to right-most (in the sense of how the query joins the associated tables). This method essentially takes a lightweight snapshot of the currently loaded record(s), so that this may be restored later.
    
    Specified by:
    
    getRow in interface Joinable
    
    Returns:
    
    Array of primary key IDs, one per table involved in the query.
    
    See Also:
    
    load(Object[], LockType, boolean)
  - repositionByID
```
public void repositionByID(recid id)
```
    Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified primary key ID. A request to retrieve the previous result will retrieve the result immediately previous to this, if any, in the results list.
    
    Specified by:
    
    repositionByID in interface P2JQuery
    
    Parameters:
    
    id - A primary key ID, representing the target record (in the case of a join, this ID is associated with the left-most record in the join).
    
    Throws:
    
    ErrorConditionException - if the specified ID represents the unknown value.
  - repositionByID
```
public void repositionByID(rowid id1,
                           rowid... joinIDs)
```
    Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified array of primary key IDs. A request to retrieve the previous result will retrieve the result immediately previous to this, if any, in the results list.
    
    Specified by:
    
    repositionByID in interface P2JQuery
    
    Parameters:
    
    id1 - A primary key ID, representing the target record (in the case of a join, this ID is associated with the left-most record in the join).
    
    joinIDs - All remaining primary key IDs, if any, arranged from left to right to coincide with the records being joined by the underlying query.
    
    Throws:
    
    ErrorConditionException - if any of the specified IDs represents the unknown value.
  - repositionByID
```
public boolean repositionByID(java.lang.Long... joinIDs)
```
    Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified array of primary key IDs. A request to retrieve the previous result will retrieve the result immediately previous to this, if any, in the results list. Note: This is not public API.
    
    Specified by:
    
    repositionByID in interface P2JQuery
    
    Parameters:
    
    joinIDs - A set of primary key IDs, arranged from left to right to coincide with the records being joined by the underlying query.
    
    Returns:
    
    true on success.
    
    Throws:
    
    ErrorConditionException - if any of the specified IDs represents the unknown value.
  - reposition
```
public void reposition(NumberType row)
```
    Reposition the cursor to the specified row in the result set. The row indicates the position between two results, such that a call to retrieve the next record will get the result at the specified row, and a call to retrieve the previous result will get the result before the new position.
    
    Specified by:
    
    reposition in interface P2JQuery
    
    Parameters:
    
    row - 1-based index of the target position.
    
    Throws:
    
    ErrorConditionException - if row represents unknown value.
  - reposition
```
public void reposition(int row)
```
    Reposition the query to the specified row in the result set. The row indicates the position between two results, such that a call to retrieve the next record will get the record after the new position, and a call to retrieve the previous record will get the record before the new position.
    
    Specified by:
    
    reposition in interface P2JQuery
    
    Parameters:
    
    row - 1-based index of the target position.
    
    Throws:
    
    ErrorConditionException - if there is an error repositioning the cursor.
  - forward
```
public boolean forward(NumberType rows)
```
    Advance the current cursor position forward by the specified number of rows. This will always leave the cursor between two results. For example, given a request to move 1 row forward:
    - if the cursor currently is positioned directly on a result, this would move it ahead one and a half positions, to just beyond the following result;
    - if the cursor currently is positioned between two results, this would move it ahead one position, to just beyond the following result.
    Specified by:
    
    forward in interface P2JQuery
    
    Parameters:
    
    rows - Number of rows to scroll the cursor forward.
    
    Returns:
    
    true if operation was successful and the cursor was moved the exact amount of rows as specified by the parameter. If false is returned then it is possible that cursor's position was moved but not with rows rows.
    
    Throws:
    
    ErrorConditionException - if rows represents the unknown value; if there is an error repositioning the cursor.
  - forward
```
public boolean forward(int rows)
```
    Advance the current cursor position forward by the specified number of rows. This will always leave the cursor between two results. For example, given a request to move 1 row forward:
    - if the cursor currently is positioned directly on a result, this would move it ahead one and a half positions, to just beyond the following result;
    - if the cursor currently is positioned between two results, this would move it ahead one position, to just beyond the following result.
    Specified by:
    
    forward in interface P2JQuery
    
    Parameters:
    
    rows - Number of rows to scroll the cursor forward.
    
    Returns:
    
    true if operation was successful and the cursor was moved the exact amount of rows as specified by the parameter. If false is returned then it is possible that cursor's position was moved but not with rows rows.
    
    Throws:
    
    ErrorConditionException - if there is an error repositioning the cursor.
  - backward
```
public boolean backward(NumberType rows)
```
    Move the current cursor position backward by the specified number of rows. This will always leave the cursor between two results. For example, given a request to move 1 row backward:
    - if the cursor currently is positioned directly on a result, this would move it back one half position, to just before the current result;
    - if the cursor currently is positioned between two results, this would move it back one position, to just before the current result.
    Specified by:
    
    backward in interface P2JQuery
    
    Parameters:
    
    rows - Number of rows to scroll the cursor backward.
    
    Returns:
    
    true if operation was successful and the cursor was moved the exact amount of rows as specified by the parameter. If false is returned then it is possible that cursor's position was moved but not with rows rows.
    
    Throws:
    
    ErrorConditionException - if rows represents the unknown value; if there is an error repositioning the cursor.
  - backward
```
public boolean backward(int rows)
```
    Move the current cursor position backward by the specified number of rows. This will always leave the cursor between two results. For example, given a request to move 1 row backward:
    - if the cursor currently is positioned directly on a result, this would move it back one half position, to just before the current result;
    - if the cursor currently is positioned between two results, this would move it back one position, to just before the current result.
    Specified by:
    
    backward in interface P2JQuery
    
    Parameters:
    
    rows - Number of rows to scroll the cursor backward.
    
    Returns:
    
    true if operation was successful and the cursor was moved the exact amount of rows as specified by the parameter. If false is returned then it is possible that cursor's position was moved but not with rows rows.
    
    Throws:
    
    ErrorConditionException - if there is an error repositioning the cursor.
  - size
```
public integer size()
```
    Return the number of results found for this query.
    Note that the first time this method is invoked, the database server may have to scroll to the end of the result set, which may be a time-consuming process for a large result set.
    
    Specified by:
    
    size in interface P2JQuery
    
    Returns:
    
    Size of result set or value if the query is not open.
  - currentRow
```
public integer currentRow()
```
    Progress-compatible function that returns the 1-based index of the current row in the result set.
    
    Specified by:
    
    currentRow in interface P2JQuery
    
    Returns:
    
    Unknown value if the query is not open or result set is empty. 1 if the query is positioned before the first record. A value 1 greater than the number of rows in the query result set if the query is positioned beyond the last record. Otherwise returns the number of rows in the query result set.
  - currentRowImpl
```
public integer currentRowImpl()
```
    Get the 1-based index of the current row in the result set.
    
    Specified by:
    
    currentRowImpl in interface P2JQuery
    
    Returns:
    
    Current row or the unknown value if the query has not yet executed.
  - _isOffEnd
```
public boolean _isOffEnd()
```
    Indicate whether the query has run off either end of its result set, due to scrolling beyond the last record or before the first record.
    
    Specified by:
    
    _isOffEnd in interface P2JQuery
    
    Returns:
    
    true if no record can be retrieved at the cursor's current position; otherwise false.
  - isFullRecords
```
public boolean isFullRecords()
```
    Indicate whether the query will retrieve full records, rather than primary keys only.
    
    Returns:
    
    true to return full records; false to return primary keys only.
  - setFullRecords
```
public void setFullRecords()
```
    Force the query to retrieve full records, rather than primary keys only.
    
    Specified by:
    
    setFullRecords in interface Joinable
  - reset
```
public void reset(boolean resolveArgs,
                  boolean forceOrigArgs)
```
    Reset the query by clearing its state to a known default. This is used to ensure that subsequent requests for FIRST and LAST record retrievals operate on a known query/buffer state.
    This implementation nulls out the current result set, so that the next record retrieval request triggers a new server-side query. Optionally, it also resets resolvable substitution arguments and triggers where expression arguments to be resolved, if a client-side where cause expression is defined.
    
    Specified by:
    
    reset in interface Joinable
    
    Parameters:
    
    resolveArgs - true if query substitution arguments should be resolved/reset as part of the reset; false if existing argument values should be used for the next query execution.
    
    forceOrigArgs - Flag indicating that the original arguments used at the construction of the query must be re-calculated.
  - setUnknownRecord
```
public void setUnknownRecord()
```
    Set each buffer backing a query component to unknown mode.
    
    Specified by:
    
    setUnknownRecord in interface Joinable
    
    See Also:
    
    RecordBuffer.setUnknownMode()
  - getTableCount
```
public int getTableCount()
```
    Get the number of tables joined by this query.
    
    Specified by:
    
    getTableCount in interface P2JQuery
    
    Returns:
    
    Number of joined tables.
  - peekFirst
```
public java.lang.Object[] peekFirst()
```
    Fetch the array of primary key IDs associated with the first result in this query's result list.
    
    Specified by:
    
    peekFirst in interface Joinable
    
    Returns:
    
    Array of record IDs reflecting the first query result, or null if there is no such result.
  - peekLast
```
public java.lang.Object[] peekLast()
```
    Fetch the array of primary key IDs associated with the last result in this query's result list.
    
    Specified by:
    
    peekLast in interface Joinable
    
    Returns:
    
    Array of record IDs reflecting the last query result, or null if there is no such result.
  - peekNext
```
public java.lang.Object[] peekNext()
```
    Fetch the array of primary key IDs associated with the next result in this query's result list.
    
    Specified by:
    
    peekNext in interface Scrollable
    
    Returns:
    
    Array of record IDs reflecting the next query result, or null if there is no such result.
  - peekPrevious
```
public java.lang.Object[] peekPrevious()
```
    Fetch the array of primary key IDs associated with the previous result in this query's result list.
    
    Specified by:
    
    peekPrevious in interface Scrollable
    
    Returns:
    
    Array of record IDs reflecting the previous query result, or null if there is no such result.
  - isPreselect
```
public boolean isPreselect()
```
    Indicate whether this query preselects all of its results.
    
    Specified by:
    
    isPreselect in interface P2JQuery
    
    Returns:
    
    true.
  - setResults
```
public void setResults(Results results)
```
    Set the given results object into this query.
    
    Specified by:
    
    setResults in interface Joinable
    
    Parameters:
    
    results - New result set for this query.
  - getRecordBuffers
```
public RecordBuffer[] getRecordBuffers()
```
    Access the record buffers manipulated by this query, in order from left-most (outermost) table of the query's join (if any) to right-most (innermost) table.
    
    Specified by:
    
    getRecordBuffers in interface P2JQuery
    
    Returns:
    
    Array of one or more record buffers.
  - getArgs
```
public java.lang.Object[] getArgs()
```
    Get the query substitution arguments associated with this query, if any.
    
    Specified by:
    
    getArgs in interface Joinable
    
    Returns:
    
    Substitution arguments, in order, or null if there are none.
  - getOriginalWhere
```
public java.lang.String getOriginalWhere()
```
    Get the original, FQL where clause associated with this query.
    
    Specified by:
    
    getOriginalWhere in interface Joinable
    
    Returns:
    
    Original where clause, or null if there is none.
  - getJoin
```
public AbstractJoin getJoin()
```
    Get the legacy natural join, if any, associated with this query.
    
    Specified by:
    
    getJoin in interface P2JQuery
    
    Returns:
    
    Legacy join object, or null if none.
  - forceDynamicOperation
```
public void forceDynamicOperation()
```
    Force this query to operate in dynamic retrieval mode, if it supports this mode.
    
    Specified by:
    
    forceDynamicOperation in interface Joinable
    
    Throws:
    
    java.lang.UnsupportedOperationException - always; this query type does not support dynamic retrieval.
  - getSortPhrase
```
public java.lang.String getSortPhrase()
```
    Get the sort phrase associated with this query.
    
    Specified by:
    
    getSortPhrase in interface Joinable
    
    Returns:
    
    Sort phrase.
  - makeAdaptiveServerJoinComponent
```
public AdaptiveComponent makeAdaptiveServerJoinComponent(java.util.List<AdaptiveComponent> joinList,
                                                         AdaptiveQuery query,
                                                         int iteration,
                                                         boolean outer,
                                                         CompoundComponent fallback)
```
    Create an adaptive query component based on the information in this query (which is presumed to be a single-table query), and given a list of adaptive query components which represent outer, nested query loops, which will perform a server-side join to the innermost, nested query component.
    
    Specified by:
    
    makeAdaptiveServerJoinComponent in interface Joinable
    
    Parameters:
    
    joinList - List of adaptive components representing nested query loops which will contain the adaptive query component returned by this method. The last component in the list represents the nested query loop immediately containing the returned query component, with which the join will be made.
    
    query - Adaptive query which will manage the server-side join of joinList and the returned query component.
    
    iteration - Iteration type: FIRST, LAST, or NEXT.
    
    outer - true if the join should be a left outer join. This type of join is not supported at the time of this writing, so this parameter should always be false. It is here to support a planned, future enhancement.
    
    fallback - A compound query component to use in the event the multi-table adaptive query switches from preselect to dynamic retrieval mode.
    
    Returns:
    
    An adaptive query component suitable for a server-side join, based on the information in this query.
  - makePreselectServerJoinComponent
```
public QueryComponent makePreselectServerJoinComponent(java.util.List<QueryComponent> joinList,
                                                       int iteration,
                                                       boolean outer)
```
    Create a preselect query component based on the information in this query (which is presumed to be a single-table query), and given a list of preselect query components which represent outer, nested query loops, which will perform a server-side join to the innermost, nested query component.
    
    Specified by:
    
    makePreselectServerJoinComponent in interface Joinable
    
    Parameters:
    
    joinList - List of preselect components representing nested query loops which will contain the preselect query component returned by this method. The last component in the list represents the nested query loop immediately containing the returned query component, with which the join will be made.
    
    iteration - Iteration type: FIRST, LAST, or NEXT.
    
    outer - true if the join should be a left outer join. This type of join is not supported at the time of this writing, so this parameter should always be false. It is here to support a planned, future enhancement.
    
    Returns:
    
    A preselect query component suitable for a server-side join, based on the information in this query.
  - hasWhereExpression
```
public boolean hasWhereExpression()
```
    Indicate whether this query has a client-side where clause expression associated with it.
    
    Specified by:
    
    hasWhereExpression in interface Joinable
    
    Returns:
    
    true if there is a where expression; else false.
  - cleanup
```
public void cleanup()
```
    Clean up query resources when this query's scope ends. This implementation cleans up any open results and deregisters this session listener.
    
    Specified by:
    
    cleanup in interface P2JQuery
    
    Overrides:
    
    cleanup in class AbstractQuery
    
    See Also:
    
    P2JQuery.cleanup()
  - open
```
public void open()
```
    Open the prepared query and reposition it to the first result if the query is being browsed.
    
    Specified by:
    
    open in interface P2JQuery
    
    Overrides:
    
    open in class AbstractQuery
  - close
```
public void close()
```
    Explicitly close the query.
    This will remove any registered finalizable.
    
    Specified by:
    
    close in interface P2JQuery
    
    Overrides:
    
    close in class AbstractQuery
  - close
```
public void close(boolean inResource)
```
    Explicitly close the prepared query.
    
    Specified by:
    
    close in interface P2JQuery
    
    Parameters:
    
    inResource - Flag indicating this query is used in a QUERY legacy resource.
  - setScrolling
```
public void setScrolling()
```
    Override parent's no-op implementation to track whether client code has set this as a scrollable query. While this setting does not explicitly affect this query's ability to respond to reposition requests (this implementation is inherently scrollable), it does provide a hint to the implementation regarding the use and scope of this query. This method must be invoked before any results are retrieved.
    
    Specified by:
    
    setScrolling in interface P2JQuery
    
    Overrides:
    
    setScrolling in class AbstractQuery
  - setNonScrolling
```
public void setNonScrolling()
```
    Disable results list scrolling/repositioning (if it was enabled by default). This method must be invoked before any results are retrieved.
  - getOffEnd
```
public OffEnd getOffEnd()
```
    Get the off-end status of this query, which indicates whether the query has run off either end of its results.
    
    Specified by:
    
    getOffEnd in interface P2JQuery
    
    Returns:
    
    One of the OffEnd constants NONE, FRONT, or BACK.
  - releaseBuffers
```
public void releaseBuffers()
```
    Release all buffers. The position of the query is not affected.
    
    Specified by:
    
    releaseBuffers in interface P2JQuery
    
    Overrides:
    
    releaseBuffers in class AbstractQuery
  - addDynamicFilter
```
public boolean addDynamicFilter(FieldReference fr,
                                BaseDataType val,
                                java.lang.String format)
```
    Adds a new constraint term to the where predicate of this query, effectively filtering out any rows whose referenced field does not match the requested value. Semantically, the query will select rows that match
    new-where := (fr = val) AND (old-query).
    Note: The constraints are exclusive meaning that if constraints will be added for same field of same buffer, the query will return an empty result because the field cannot be at the same time equals to two different values.
    Use clearDynamicFilters() to clean all dynamically added criteria and restore the sorting order of the query to its original form.
    
    Specified by:
    
    addDynamicFilter in interface P2JQuery
    
    Parameters:
    
    fr - A reference to field used as filtering criterion. Only the rows that matches the specified value for this field will be selected. Must not be null.
    
    val - The filtering value for this constraint. Can be null or unknown, in which case the SQL null value will be assumed. In this case the predicate will look like:
    new-where := (fr IS NULL) AND (old-query)
    
    format - The format to be used when comparing values. The reason for this parameter is that for some datatype (ex: decimal) the on-screen value can be different from the database (because of rounding).
    
    Returns:
    
    true if the filtering constraint was successfully added. If the field reference is not related to the buffer(s) of this query, false is returned.
  - clearDynamicFilters
```
public void clearDynamicFilters()
```
    Clears any dynamically filters added at runtime. The query predicate will be restored to its form from generated at conversion time.
    
    Specified by:
    
    clearDynamicFilters in interface P2JQuery
  - addDynamicSortCriterion
```
void addDynamicSortCriterion(FieldReference fr,
                             boolean asc)
```
    Adds a new sorting criterion as the strongest criterion for sorting the result of this query. The other criteria remain queued, but with lower priority.
    Use clearDynamicSortCriteria() to clean all dynamically added criteria and restore the sorting order of the query to its original form.
    
    Parameters:
    
    fr - A reference to field used as new strongest criterion. The current criteria will be kept, but with lower priority.
    
    asc - The direction of sorting for this criterion. Use true for ascending sort and false for descending sorting.
  - clearDynamicSortCriteria
```
void clearDynamicSortCriteria()
```
    Clears any dynamically sort criteria added at runtime. The query sort order will be restored to its form from generated at conversion time.
  - indexInformation
```
public character indexInformation(NumberType n)
```
    Conversion of INDEX-INFORMATION attribute (KW_IDX_INFO).
    Getter of INDEX-INFORMATION attribute
    
    Specified by:
    
    indexInformation in interface IndexInformation
    
    Specified by:
    
    indexInformation in interface P2JQuery
    
    Overrides:
    
    indexInformation in class AbstractQuery
    
    Parameters:
    
    n - An integer expression that evaluates to the level of join for which you want index information.
    
    Returns:
    
    A character string consisting of a comma-separated list of the index or indexes the query uses at the level of join specified.
  - isNativelyPreselect
```
public boolean isNativelyPreselect()
```
    Indicate whether this query is a preselect query by its nature.
    
    Specified by:
    
    isNativelyPreselect in interface P2JQuery
    
    Returns:
    
    true.
  - createResultListEntry
```
public logical createResultListEntry()
```
    Creates an entry in the result list for the current row. Implements the 4GL CREATE-RESULT-LIST-ENTRY() method. Created entry contains id(s) of the record(s) currently located in the backing buffer(s).
    
    Specified by:
    
    createResultListEntry in interface P2JQuery
    
    Overrides:
    
    createResultListEntry in class AbstractQuery
    
    Returns:
    
    true on success.
  - deleteResultListEntry
```
public logical deleteResultListEntry(boolean allowBetweenRows)
```
    Deletes the current row of a query's result list. Implements the 4GL DELETE-RESULT-LIST-ENTRY() method.
    
    Specified by:
    
    deleteResultListEntry in interface P2JQuery
    
    Overrides:
    
    deleteResultListEntry in class AbstractQuery
    
    Parameters:
    
    allowBetweenRows - If true then the cursor can be positioned between rows (the next row will be deleted). false for conventional DELETE-RESULT-LIST-ENTRY() mode where the cursor should be positioned on a row (otherwise false is returned).
    
    Returns:
    
    true on success.
  - isScrolling
```
public boolean isScrolling()
```
    Indicate whether this query's scrolling flag has been set.
    
    Specified by:
    
    isScrolling in interface P2JQuery
    
    Returns:
    
    true if this is a scrolling query; else false.
  - isNativelyScrolling
```
protected boolean isNativelyScrolling()
```
    Indicate whether this query type is scrolling by its nature.
    Subclasses which are not natively scrolling should override this method.
    
    Returns:
    
    true.
  - addExternalBuffers
```
public P2JQuery addExternalBuffers(DataModelObject... dmos)
```
    Add one or more buffers to the list of those which this query references externally. These typically will be buffers referenced by converted CAN-FIND expressions embedded in the query's FQL expression, which are not the primary buffers associated with the query.
    If the bound buffer differs from the definition buffer (see AbstractQuery.buffersMatch(com.goldencode.p2j.persist.RecordBuffer, com.goldencode.p2j.persist.RecordBuffer)) for any of the external buffers, then all components() will have the translateWhere() enabled (if not already enabled).
    
    Specified by:
    
    addExternalBuffers in interface P2JQuery
    
    Overrides:
    
    addExternalBuffers in class AbstractQuery
    
    Parameters:
    
    dmos - One or more external buffers.
    
    Returns:
    
    This query instance.
  - resetResults
```
protected void resetResults()
```
    Discard the current result set, clear the reposition cache, and reset result-related state to default values.
  - components
```
protected java.util.ArrayList<QueryComponent> components()
```
    Get the query components.
    
    Returns:
    
    Query components.
  - isLenientOffEnd
```
protected boolean isLenientOffEnd()
```
    Indicate whether this query will throw a QueryOffEndException when it runs off the end of its results.
    
    Overrides:
    
    isLenientOffEnd in class AbstractQuery
    
    Returns:
    
    true if an exception will be thrown, else false.
  - treatPreviousAsLast
```
protected boolean treatPreviousAsLast()
```
    Indicate whether a call to move to the previous record in the result list should be treated as a call to move to the last record in the list. This will be the case if either there are no results available, or if the query is not off the front end of its results, but the row number is -1 (indicating no results have yet been retrieved).
    
    Returns:
    
    true to treat a previous request as a request to move to the last record in the list; else false.
  - setEmptyBuffersUnknown
```
protected void setEmptyBuffersUnknown()
```
    Walk through each component and set its backing buffer to unknown mode, such that the invocation of any of its DMO-backed methods returns unknown value.
  - processJoin
```
protected AbstractJoin processJoin(BufferReference primary,
                                   BufferReference inverse)
```
    Given a primary DMO buffer and an inverse DMO buffer which together define a natural join, create the AbstractJoin helper object which is used to implement the join.
    It is intended that this method be called when adding a query component. If no previous components have been added, a DynamicJoin is created, and it is assumed that the inverse DMO is provided as a query substitution parameter. If a component previously has been added, a ServerJoin is created, and it is assumed that the inverse DMO will be resolved by a server-side join, rather than being provided as a query substitution parameter.
    If no inverse buffer is provided, no join is created.
    
    Parameters:
    
    primary - Buffer reference to the primary DMO.
    
    inverse - Buffer reference to the joined DMO, or null if no join is required.
    
    Returns:
    
    A join helper object, or null if no natural join is required.
  - assembleSelectClause
```
protected void assembleSelectClause(java.lang.StringBuilder buf)
```
    Assemble the select clause for an FQL projection query, where the only field retrieved for each buffer is the primary key. This uses the Hibernate reserved keyword "id" to represent the primary key. Form of the clause is:
```
    select {buffer0.id} [, {buffer1.id} [...]]
 
```
    Parameters:
    
    buf - String buffer into which clause is assembled.
  - assembleFromAndWhereClauses
```
protected FQLExpression assembleFromAndWhereClauses(java.util.ArrayList<SortCriterion> sortCriteria)
                                             throws PersistenceException
```
    Assemble the from and the where clause for an FQL query. Now this method is capable of creating the OUTER-JOIN clause as well. The class name of each DMO is decapitalized to produce an alias for that object. Form of the clause is:
```
    from {Buffer0} as {buffer0} 
    [[left outer] join {Buffer1} as {buffer1} on {JoinCondition1} [and {JoinCondition1_1}] [...]
    [, {Buffer2} as buffer2 [...]]
    [[left outer] join {Buffer3} as {buffer3} on {JoinCondition2} [and {JoinCondition2_1}] [...]]]
    [, {Buffer4} as buffer4 [...]]
    [where {WhereCondition1} [and {WhereCondition2}] [...]]]
 
```
    The FQL is creating by adding first the "from" KEYWORD, followed by: 1) possible one or more different types of joins, each with one or more join conditions. 2) not joined buffers. At the end, the complete where clause is appended at the end of the FQL.
    Parameters:
    
    sortCriteria - All known sort criteria. If a JOIN term is detected in the preprocessed query this list is simplified to allow a cleaner ORDER BY clause and let the query planner chose a better plan.
    
    Returns:
    
    FqlExpression The fql expression that contains both the from and where clause.
    
    Throws:
    
    PersistenceException - if there is an error creating the FQLPreprocessor from which the composite join data are gathered.
  - assembleWhereClause
```
protected void assembleWhereClause(java.util.ArrayList<SortCriterion> sortCriteria,
                                   int indices,
                                   FQLExpression whereClause,
                                   FQLExpression onClause,
                                   boolean isOn)
                            throws PersistenceException
```
    Assemble the restriction (i.e., where) clause for an FQL query. If more than one component contains a where clause, they are combined with a logical "and". Form of the clause is:
```
    where ({component0_clause})
     [and ({component1_clause})
     [...]]
 
```
    Parameters:
    
    sortCriteria - List of SortCriterion objects which describe the sort behavior for this query.
    
    indices - int which represents the position of the component we generate the where clause for.
    
    whereClause - FQLExpression which represents the variable where the "where" clause is going to be saved.
    
    onClause - FQLExpression which represents the variable where the "on" clause is going to be saved.
    
    isOn - boolean that will help to distinguish between "where" and "and" and "on".
    
    Throws:
    
    PersistenceException - if there is an error creating the FQLPreprocessor from which the preprocessed where clause is retrieved for each query component.
  - assembleOrderByClause
```
protected java.util.ArrayList<SortCriterion> assembleOrderByClause()
                                                            throws PersistenceException
```
    Assemble the order by clause for an FQL query.
    Any text-based sort criteria are augmented with the necessary upper() and rtrim() functions.
    
    Returns:
    
    List of SortCriterion objects which describe the sort behavior for this query.
    
    Throws:
    
    PersistenceException - if the raw sort clause provided at construction contains any unqualified property names; if the raw sort clause contains a reference to an unrecognized record buffer.
  - generateOrderBy
```
private void generateOrderBy(java.util.ArrayList<SortCriterion> sortCriteria,
                             java.lang.StringBuilder buf)
```
    Generates the order by clause starting from the list of criteria, including the "order by" keyword. Uses the form:
```
   order by {{dmo.property} {asc/desc}} [, ...]
 
```
    Parameters:
    
    sortCriteria - The list of criteria to be added.
    
    buf - The string builder to add the result.
  - assembleOrderByClause
```
protected java.util.List<SortCriterion> assembleOrderByClause(java.lang.String sort)
                                                       throws PersistenceException
```
    Assemble the order by clause for an FQL query.
    Any text-based sort criteria are augmented with the necessary upper() and rtrim() functions.
    
    Parameters:
    
    sort - Raw sort clause to parse and augment if necessary.
    
    Returns:
    
    List of SortCriterion objects which describe the sort behavior for this query.
    
    Throws:
    
    PersistenceException - if sort contains any unqualified property names; if sort clause contains a reference to an unrecognized record buffer.
  - buildSortCriteria
```
protected java.util.ArrayList<SortCriterion> buildSortCriteria(java.lang.String sort)
                                                        throws PersistenceException
```
    Returns a list SortCriterion objects build from the given sort clause.
    
    Parameters:
    
    sort - Raw sort clause to parse and augment if necessary.
    
    Returns:
    
    List of SortCriterion objects which describe the sort behavior for this query.
    
    Throws:
    
    PersistenceException - if sort contains any unqualified property names; if sort clause contains a reference to an unrecognized record buffer.
  - assembleOrderByClause
```
protected java.util.ArrayList<SortCriterion> assembleOrderByClause(java.util.List<SortCriterion> sortCriteria)
```
    Assemble the order by clause for an FQL query.
    Any text-based sort criteria are augmented with the necessary upper() and rtrim() functions.
    
    Parameters:
    
    sortCriteria - A list of SortCriterion objects which describe the sorting to be applied.
    
    Returns:
    
    List of SortCriterion objects which describe the sort behavior for this query.
  - getWhereExpressions
```
protected java.util.List<java.util.function.Supplier<logical>> getWhereExpressions()
```
    Get this query's client-side where expressions.
    
    Returns:
    
    Unmodifiable where expression list.
  - whereExpressions
```
protected java.util.Iterator<java.util.function.Supplier<logical>> whereExpressions()
```
    Get an iterator on this query's client-side where expressions.
    
    Returns:
    
    Where expression iterator.
  - execute
```
protected boolean execute()
```
    Compose an FQL query statement to represent the combination of all query components, execute it, and store the scrollable results. If query has been executed previously and we already have a result set, simply return.
    
    Returns:
    
    true if query was executed for the first time; false if query was executed previously and we already have a result set.
    
    Throws:
    
    ErrorConditionException - if an error occurs executing the query.
    
    java.lang.IllegalStateException - if no query component has been added to this query.
  - isTopLevelCleanup
```
protected boolean isTopLevelCleanup()
```
    Indicate whether results resources should be cleaned up upon exiting the global scope or upon exiting the nearest enclosing scope in which the results were created.
    This default implementation returns false, indicating results should be cleaned up at the nearest enclosing scope. Subclasses which require different behavior must override this method.
    
    Returns:
    
    false.
  - verifyJoins
```
protected boolean verifyJoins()
```
    Invoked just before query execution, this method checks whether all components with a non-null JOIN have a valid inverse on which to perform the join. If not, set the query's results to an empty result set and indicate failure.
    
    Returns:
    
    true if verification succeeded and query execution should continue; else false
  - handleMissingJoinRecord
```
protected void handleMissingJoinRecord()
```
    Respond to the condition that a component with a non-null JOIN has a missing inverse on which to perform the join.
    This implementation creates an empty result set.
  - cacheResults
```
protected Results cacheResults(Results target)
```
    Attempt to cache all results from the specified target result set into a Results instance. If this is a scrolling query, this will cache all results in the target result set, including those already visited. Otherwise, only the current result and all remaining, unvisited results are cached.
    
    Parameters:
    
    target - Result set which is to be cached, presumably because it will be invalid momentarily. If results previously were cached, target is simply returned.
    
    Returns:
    
    Results from target, if any, cached in a Results object. If there were no results available to cache, an empty result set is returned. If any of the record buffers backing this query have been closed, null is returned.
  - prepareParameters
```
protected void prepareParameters(java.util.List<java.lang.Object> args)
                          throws PersistenceException
```
    Prepare query substitution parameters for this query. One argument must be added to args list for each ? placeholder in the FQL query string for this query.
    
    Parameters:
    
    args - Argument list to be populated.
    
    Throws:
    
    PersistenceException - if there is an error creating an FQLPreprocessor during the gathering of query substitution parameters.
  - getEntities
```
protected java.lang.String[] getEntities()
```
    Collect the names of the entities (DMO types) associated with this query.
    
    Returns:
    
    Array of entity names.
  - getTemplateQueryRowid
```
protected java.lang.Long getTemplateQueryRowid(java.lang.Object[] args)
```
    Checks if this is a template query. A template query is a rowid query that looks for a special template record that is not found in database. The template record is a record having all fields set to default values. The id of such record is in P2J, by convention negative. In case this is a simple template query, this method returns the rowid of the template for current buffer from the single.
    Note:
    The current implementation identifies only simple queries for template records:
    1. this PreselectQuery has a single component;
    2. the where predicate directly test whether the rowid/recid is equal to a value (this is done by the FQLPreprocessor of the component);
    3. the value (constant or passed in as query SUBST parameter) is negative (as noted above).
    Although this kind of queries are sufficient for standard template record load according to P4GL idiom, more complex queries can be issued, with predicates that basically match the pattern but add supplementary AND/OR clauses. This kind of queries are not always of common sense and the result in 4GL is not always as expected.
    For example:
    FOR EACH book WHERE RECID(book) = templateId OR book.isbn NE ?
    will iterate only books that have the isbn not null, but will not contain the template record in the result returned.
    On the other hand, it does not make much sense to:
    - iterate over the the template records of a table since there will always be at most one such record;
    - add additional OR/AND clauses in WHERE predicate since, if the template record exists, it is well defined by it rowid, configured in database schema and immutable.
    Parameters:
    
    args - The actual parameters of the query.
    
    Returns:
    
    if this query looks for the template record of the component the rowid is returned and null otherwise.
  - executeQuery
```
protected Results executeQuery(Persistence persistence,
                               java.lang.String fql,
                               java.lang.Object[] args)
                        throws PersistenceException
```
    Execute the query to create a first level result set.
    This default implementation returns an object which is a thin wrapper around ScrollableResults. Subclasses may override this method if they need a Results implementation other than ScrollingResults.
    In case when the fql represents a valid template record query (a test on recid / rowid of the record against the unique _file._template for current record of the single QueryComponent), a special Results object is returned with a single element that is the template record for the buffer of the component.
    
    Parameters:
    
    persistence - Object which is used to execute the query.
    
    fql - FQL query string.
    
    args - Substitution parameters to be inserted into placeholders within the FQL query string.
    
    Returns:
    
    An instance of ScrollingResults which wrappers the ScrollableResults object returned by the execution of the query.
    
    Throws:
    
    PersistenceException - if there is an error executing the query.
  - executeScroll
```
protected <T> ScrollableResults<T> executeScroll(Persistence persistence,
                                                 java.lang.String fql,
                                                 java.lang.Object[] args)
                                          throws PersistenceException
```
    Execute the query to create a ScrollableResults result set.
    
    Parameters:
    
    persistence - Object which is used to execute the query.
    
    fql - FQL query string.
    
    args - Substitution parameters to be inserted into placeholders within within the FQL query string.
    
    Returns:
    
    The ScrollableResults object returned by the execution of the query.
    
    Throws:
    
    PersistenceException - if there is an error executing the query.
  - createResults
```
protected Results createResults(Results results)
                         throws PersistenceException
```
    Optionally wrapper the result set created for the query with a filtering Results implementation (for client-side where processing). It is this object which actually will be used to retrieve the primary key values of records to be loaded from the database.
    If no filtering is necessary, simply return the results object which was passed in.
    Subclasses may override this method to insert their own layers into result set processing.
    
    Parameters:
    
    results - An object which manipulates the database result set returned from execution of the query.
    
    Returns:
    
    Results object.
    
    Throws:
    
    PersistenceException - if there is any error creating results.
  - fetch
```
protected void fetch(boolean available,
                     LockType lockType,
                     boolean errorIfNull)
              throws MissingRecordException
```
    Fetch all records for a given result row into their backing buffers. Each result row contains one column per query component. Each column contains the unique ID of the record to be fetched or the record itself. If the latter, the record is refetched in case it has changed since the record was first retrieved. If the scrollable cursor backing this query currently is at a position where no retrieval is possible, the backing buffers will have their current records released.
    As particular case when the query looks for the template record of the buffer of the single QueryComponent, the buffer is not populated with a record fetched from backing database, instead the template record for the buffer is automatically created in-memory. This results object has only one element to iterate on and attempting to iterate on this object will throw QueryOffEndException and release the buffer.
    
    Parameters:
    
    available - true if the most recent scrollable cursor move left the cursor at an available result row; false if the cursor cannot read a result at its current position.
    
    lockType - Overriding lock type to apply to fetched records. If null, default lock types are applied.
    
    errorIfNull - true if failed retrievals should raise error.
    
    Throws:
    
    MissingRecordException - if the record was expected to be available, but wasn't. This typically indicates the record was deleted between the time it initially was found by the query and the time it was to be fetched to store in the record buffer.
    
    ErrorConditionException - if the fetch of any record fails or if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
  - coreFetch
```
protected final boolean coreFetch(java.lang.Object[] data,
                                  LockType lockType,
                                  boolean errorIfNull,
                                  boolean silentIfNullId)
                           throws PersistenceException
```
    Fetch all records for a given result row into their backing buffers, given an array of data which contains one primary key or DMO per query component.
    
    Parameters:
    
    data - An array of primary key IDs or DMOs representing records to be fetched for the composite row.
    
    lockType - Overriding lock type to apply to fetched records. If null, default lock types are applied.
    
    errorIfNull - true if failed retrievals should raise error.
    
    silentIfNullId - If true, do not raise QueryOffEndException if some of the provided IDs are null.null IDs are valid for queries with OUTER join.
    
    Returns:
    
    true if data was fetched and is available and false is the fetch failed and no error was raised (when errorIfNull is false).
    
    Throws:
    
    MissingRecordException - if the record was expected to be available, but wasn't. This typically indicates the record was deleted between the time it initially was found by the query and the time it was to be fetched to store in the record buffer.
    
    PersistenceException - if the fetch of any record fails.
    
    ErrorConditionException - if no records are available and the query is set to fail in this case.
    
    QueryOffEndException - if no records are available and the query is set not to fail in this case.
  - isClientWhere
```
protected final boolean isClientWhere()
```
    Indicate whether this query requires initial results to be filtered through a client-side where clause expression.
    
    Returns:
    
    true if client-side filter is required, else false.
  - getResults
```
protected Results getResults()
```
    Access the current Results object for this query.
    
    Returns:
    
    Results object.
  - addComponent
```
protected void addComponent(QueryComponent comp)
```
    Add a component to the query.
    
    Parameters:
    
    comp - Query component to be added.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if attempting an outer join (temporary); if iteration type is not NEXT (temporary); if the component's DMO's associated database is different than that of a previously added component's database (cross-database preselect joins are not possible).
  - supportsArbitraryIteration
```
protected boolean supportsArbitraryIteration()
```
    Does this query support non-NEXT iteration components?
    
    Returns:
    
    false
  - preserveBuffersOnEmptyResults
```
protected boolean preserveBuffersOnEmptyResults(Results results)
```
    Indicate whether the record buffer(s) current record(s) should be preserved, in the event the query does not find any results.
    This implementation always returns false. Subclasses should override this behavior if needed.
    
    Parameters:
    
    results - The results instance to decide if they are truly empty. The results are not visible in some sub-classes, so let them be passed by parameter.
    
    Returns:
    
    false.
  - clearRepoCache
```
protected void clearRepoCache()
```
    Clear the reposition cache of visited, virtual composite rows.
  - getHQL
```
protected java.lang.String getHQL()
```
    Get the FQL query which was executed to produce this query's results.
    
    Returns:
    
    FQL query or null if the query has not yet been executed.
  - getPersistence
```
protected Persistence getPersistence()
```
    Get the persistence service object used by this query.
    
    Returns:
    
    Persistence object.
  - registerCleaner
```
protected void registerCleaner()
```
    Register a Finalizable with the transaction manager for resource cleanup when this query's scope ends.
  - repositionByID
```
protected boolean repositionByID(java.lang.Long[] ids,
                                 boolean forceFetch)
```
    Reposition the cursor such that a request to retrieve the next result will retrieve the result which matches the specified array of primary key IDs. A request to retrieve the previous result will retrieve the result immediately previous to this, if any, in the results list.
    
    Parameters:
    
    ids - Array of primary key IDs, arranged from left to right to coincide with the records being joined by the underlying query.
    
    forceFetch - true to override the current fetch-on-reposition setting to true, in case the underlying Results implementation attempts to fetch the record during repositioning; false to honor the current setting.
    
    Returns:
    
    true if reposition was successful; false if unsuccessful.
    
    Throws:
    
    ErrorConditionException - if there is an error repositioning the cursor.
  - prepareReposition
```
protected void prepareReposition()
```
    Prepare to process a reposition request by releasing the current records, if any, in each buffer managed by the query. This occurs in Progress unconditionally, even if the reposition does not actually move the cursor from its current position.
  - anyBoundBufferInComponent
```
protected boolean anyBoundBufferInComponent()
```
    Check if any query component (added until the current call) has bound buffers.
    
    Returns:
    
    See above.
  - shouldUpdateAnyLock
```
protected boolean shouldUpdateAnyLock(LockType lockType)
```
    Check if the lock should be updated for any component when fetching. This is used to detect if we can bypass fetching to satisfy locks. If the provided lock type is LockType.NONE, no lock update should happen. If the component specific lock mode is used, ensure that there is no particular (SHARE or EXCLUSIVE) lock request for any component, which may trigger fetching.
    
    Parameters:
    
    lockType - The lock mode for the records after query execution.
    
    Returns:
    
    true if one of the components has a record which should be fetched with another lock type.
  - findComponent
```
private QueryComponent findComponent(RecordBuffer buffer)
```
    Find the query component associated with the given record buffer.
    
    Parameters:
    
    buffer - Record buffer.
    
    Returns:
    
    Associated query component, or null if not found.
  - assembleFQL
```
private java.lang.String assembleFQL()
                              throws PersistenceException
```
    Assemble the FQL which is submitted to Hibernate in order to execute the database query underlying this object. The FQL generated uses the theta join style and includes a select clause, a from clause, an optional where clause, and an order by clause (mandatory in all cases except a unique find).
    
    Returns:
    
    String A formatted FQL statement.
    
    Throws:
    
    PersistenceException - if the sort criteria reference unqualified or unrecognized buffer names.
  - assembleFQLImpl
```
private void assembleFQLImpl(java.lang.StringBuilder buf)
                      throws PersistenceException
```
    Assemble the FQL which is submitted to Hibernate in order to execute the database query underlying this object. The FQL generated uses the theta join style and includes a select clause, a from clause, an optional where clause, and an order by clause (mandatory in all cases except a unique find).
    
    Throws:
    
    PersistenceException - if the sort criteria reference unqualified or unrecognized buffer names.
  - isOrderByRequired
```
private boolean isOrderByRequired()
                           throws PersistenceException
```
    Function for deciding whether the ORDER BY clause is required in the FQL. For the moment, the ORDER BY clause can be skipped if this query will retrieve zero or one records. In other words, if this query will retrieve a unique finding, no ORDER BY is necessary.
    
    Returns:
    
    true if the ORDER BY clause is necessary for the query, false otherwise.
    
    Throws:
    
    PersistenceException
  - validateRepositionByID
```
private boolean validateRepositionByID(rowid value)
```
    Validate a row identifier provided to a reposition request to ensure that it does not represent the unknown value.
    
    Parameters:
    
    value - ID to be validated.
    
    Returns:
    
    true if the number is valid; false if it is invalid, but we are in silent error mode.
    
    Throws:
    
    ErrorConditionException - if the number is invalid and we are not in silent error mode.
  - validateRepositionByID
```
private boolean validateRepositionByID(recid value)
```
    Validate a record identifier provided to a reposition request to ensure that it does not represent the unknown value.
    
    Parameters:
    
    value - ID to be validated.
    
    Returns:
    
    true if the number is valid; false if it is invalid, but we are in silent error mode.
    
    Throws:
    
    ErrorConditionException - if the number is invalid and we are not in silent error mode.
  - validateReposition
```
private boolean validateReposition(NumberType value)
```
    Validate a numeric value provided to a reposition request to ensure that it does not represent the unknown value.
    
    Parameters:
    
    value - ID or row number/offset to be validated.
    
    Returns:
    
    true if the number is valid; false if it is invalid, but we are in silent error mode.
    
    Throws:
    
    ErrorConditionException - if the number is invalid and we are not in silent error mode.
  - validateRepositionImpl
```
private boolean validateRepositionImpl(BaseDataType value,
                                       int errorNum,
                                       java.lang.String errorMsg)
```
    Validate a numeric value provided to a reposition request to ensure that it does not represent the unknown value.
    
    Parameters:
    
    value - ID or row number/offset to be validated.
    
    errorNum - Error number if validation fails.
    
    errorMsg - Error message if validation fails.
    
    Returns:
    
    true if the number is valid; false if it is invalid.
    
    Throws:
    
    ErrorConditionException - if the number is invalid and we are not in silent error mode.
  - isResultSetCached
```
private boolean isResultSetCached()
```
    Indicate whether the full result set for this query has been cached.
    
    Returns:
    
    true if there is a result set and it has been cached.

Class PreselectQuery

Nested Class Summary

Nested classes/interfaces inherited from interface com.goldencode.p2j.persist.P2JQuery

Nested classes/interfaces inherited from interface com.goldencode.p2j.persist.event.SessionListener

Field Summary

Fields inherited from class com.goldencode.p2j.persist.AbstractQuery

Fields inherited from interface com.goldencode.p2j.persist.QueryConstants

Constructor Summary

Method Summary

Methods inherited from class com.goldencode.p2j.persist.AbstractQuery

Methods inherited from class java.lang.Object

Methods inherited from interface com.goldencode.p2j.persist.Joinable

Methods inherited from interface com.goldencode.p2j.persist.P2JQuery

Methods inherited from interface com.goldencode.p2j.persist.BufferCollection

Methods inherited from interface com.goldencode.p2j.util.Openable

Methods inherited from interface com.goldencode.p2j.util.Finalizable

Field Detail

EMPTY_ARRAY

LOG

QUERY_ASSEMBLE

betweenRows

offEnd

sort

components

currentRowDeleted

sortTranslated

whereExprList

persistence

scrolling

repoCache

fql

results

resolvableArgs

rowCount

regWithSession

regCleaner

unregisterOnCleanup

cleaner

thisFinalizable

fullRecords

forceOnlyId

dynamicSorts

whereTranslated

LOG_FINE

Constructor Detail

PreselectQuery

Method Detail

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

initialize

translateWhere

setLenientOffEnd

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent

addComponent