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

java.lang.Object
- com.goldencode.p2j.persist.QueryComponent

All Implemented Interfaces:

QueryConstants

Direct Known Subclasses:

AdaptiveComponent
```
class QueryComponent
extends java.lang.Object
implements QueryConstants
```
A helper container for a query component. A query component defines the buffer to be updated, the type of join to perform with the previous component (if any), the lock type for records fetched into the buffer, the where clause to be applied, and any query substitution parameters.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

(package private) static class QueryComponent.ServerJoinData
Information required to create a server-side join between two tables.

Nested Classes
Modifier and Type	Class and Description
`(package private) static class`	`QueryComponent.ServerJoinData` Information required to create a server-side join between two tables.

Field Summary

Fields
Modifier and Type	Field and Description
`private java.lang.Object[]`	`args` Base substitution arguments for this component
`private RecordBuffer`	`buffer` Record buffer updated by this component of the query
`private java.lang.Object[]`	`currentArgs` Intermediately resolved arguments for this component
`private RecordBuffer`	`definition` For bound buffers, this is the definition buffer
`private java.lang.Object[]`	`dfArgs` The substitution arguments with dynamic filtered ones inserted in front.
`private java.lang.String`	`dfWhere` The where clause, including the dynamic filters, before preprocessing.
`private java.util.Map<FieldReference,BaseDataType>`	`dynamicFilters` The list of dynamic filters.
`private java.util.Map<FieldReference,java.lang.String>`	`dynamicFormats` The list of format used by dynamic filters.
`private FQLPreprocessor`	`fqlPreprocessor` FQL preprocessor
`private boolean`	`idOnly` Whether query should return primary key ID only, or entire DMO
`private java.lang.String`	`indexInfo` Index information string as it is returned by INDEX-INFORMATION.
`private int`	`iteration` Iteration/retrieval mode (first, last, next, etc.)
`private AbstractJoin`	`join` Helper object for a join via a foreign key relation
`private LockType`	`lockType` Record lock type
`private boolean[]`	`nullArguments` Position of `null` elements in argument list with which FQL was preprocessed
`private java.lang.Object[]`	`origArgs` Original arguments before query substitution arguments preprocessing.
`private boolean`	`outer` `true` if component forms outer join with previous component; else `false`
`private Joinable`	`query` Joinable query which contains this query component
`private java.lang.String[]`	`referenceSubs` Array of field reference names and nulls used to replace substitution parameters when converting a nested looping (client-side) join to a server-side join
`private java.util.Set<RecordBuffer>`	`relatedBuffers` Set of related buffers, if component participates in a server-side join
`private java.lang.String`	`sort` Order by clause for FIRST/LAST iteration components
`private SortIndex`	`sortIndex` Sort index associated with this query component
`private boolean`	`top` Is this component the top/outermost among the query's components?
`private java.util.function.Supplier<java.lang.String>`	`translateWhere` A function to translate the where clause, just before it gets executed.
`private java.lang.String`	`where` Original where clause, before preprocessing

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

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`QueryComponent(Joinable query, BufferReference proxy, AbstractJoin join, java.lang.String where, java.util.function.Supplier<java.lang.String> translateWhere, java.lang.String indexInfo, LockType lockType, java.lang.Object[] args, int iteration, boolean outer)` Constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) 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`	`clearDynamicFilters()` Clears any dynamically filters added at runtime.
`(package private) java.util.Iterator<java.lang.String>`	`compositeJoins()` Get an iterator on the ANSI-style join subexpressions which must be merged by the enclosing query into the overall FQL query statement in order to properly join associated composite element lists (if any).
`(package private) void`	`enableTranslateWhere(java.util.function.Function<java.lang.String,java.lang.String> translate)` Enable the `translateWhere` for this component (if not already enabled).
`protected java.lang.Object[]`	`filterArgs(FQLPreprocessor preproc)` Get the (mostly) resolved query substitution parameters required by this query component and return them in an array.
`protected java.lang.Object[]`	`getArgs()` Get substitution arguments for this component, resolving them first if necessary.
`(package private) RecordBuffer`	`getBuffer()` Get record buffer for this component of the query.
`(package private) RecordBuffer`	`getDefinitionBuffer()` Get definition record buffer for this component of the query.
`protected Joinable`	`getEnclosingQuery()` Get the query which encloses this component.
`protected FQLPreprocessor`	`getHQLPreprocessor()` Get the FQL preprocessor associated with this component.
`(package private) java.lang.String`	`getIndexInfo()` Get the index information string as it is returned by INDEX-INFORMATION.
`(package private) int`	`getIteration()` Get iteration/retrieval mode (first, last, next, etc.).
`(package private) AbstractJoin`	`getJoin()` Get helper object for a join via a foreign key relation, if any.
`(package private) LockType`	`getLockType()` Get lock type for records fetched into this component's buffer.
`(package private) java.lang.String`	`getOriginalWhere()` Get restriction criteria in FQL where clause format for this component (before the FQL preprocessor has preprocessed it).
`(package private) java.lang.Object[]`	`getRawArgs()` Get unresolved substitution arguments for this component, if any.
`protected RecordBuffer[]`	`getReferencedBuffers()` Get an array of all record buffers referenced by this query, including those directly involved in the query, as well as those (if any) indirectly referenced by inlined, converted, CAN-FIND expressions, and those related via a server-side join (if any).
`(package private) java.util.Map<java.lang.String,java.util.Set<java.lang.String>>`	`getRestrictionProperties()` Get an unmodifiable map of DMO entity names to sets of the names of the DMO properties used as restriction criteria in the preprocessed where clause.
`(package private) SortIndex`	`getSortIndex()` Get sort criteria in FQL order by clause format for this component.
`(package private) FQLExpression`	`getWhere()` Get restriction criteria in FQL where clause format for this component (pre-processed).
`protected boolean`	`isIdOnly()` Indicate whether the query component should return a primary key ID only, or the entire DMO instance.
`(package private) boolean`	`isOuter()` Indicate whether this component is joined with the previous component via a left outer join.
`protected FQLPreprocessor`	`prepareHQLPreprocessor(java.lang.Object[] queryArgs)` Create the `FQLPreprocessor` which backs this component.
`(package private) static QueryComponent.ServerJoinData`	`prepareServerJoinData(java.util.List<? extends QueryComponent> joinList, RecordBuffer buffer, AbstractJoin join, java.lang.Object[] args)` Prepare the information needed to convert a nested looping (client-side) join of two tables to a server-side join of those tables.
`(package private) void`	`processDynamicFilters()` Processes all dynamic filters altering the original `where` predicate and inserting optional substitution arguments in the list of static ones.
`protected void`	`resetArgs(boolean forceOrigArgs)` Reset current arguments, so that they will need to be resolved the next time they are requested.
`protected void`	`resetHQLPreprocessor()` Reset the FQL preprocessor, so that it needs to be recreated the next time it is requested.
`private java.lang.Object`	`resolveArg(java.lang.Object arg)` Resolve a single resolvable query substitution parameter, with the exception of `FieldReference`s.
`private java.lang.Object[]`	`resolveArgs()` Resolve all resolvable query substitution parameters, with the exception of `FieldReference`s.
`(package private) void`	`setBuffer(RecordBuffer buffer)` Set the record buffer for this component's query.
`(package private) void`	`setIteration(int iteration, java.lang.String sort)` Set iteration/retrieval mode (first, last, next, etc.).
`(package private) void`	`setNotTop()` Mark this query component as being nested within an outer component (i.e., not the top component in a nested looping query).
`protected void`	`setReferenceSubs(java.lang.String[] referenceSubs)` Set the array of field reference names and nulls used when converting a nested loop where clause to a server-join where clause.
`protected void`	`setRelatedBuffers(java.util.Set<RecordBuffer> relatedBuffers)` Store a set of outer component buffers to which this component is related through a server side join.
`(package private) void`	`setSortIndex(SortIndex sortIndex)` Set sort criteria in FQL order by clause format for this component.
`protected void`	`translateWhere()` Translate the `where` clause, using the `translateWhere` function.

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

- Field Detail
  - query
```
private final Joinable query
```
    Joinable query which contains this query component
  - where
```
private java.lang.String where
```
    Original where clause, before preprocessing
  - translateWhere
```
private java.util.function.Supplier<java.lang.String> translateWhere
```
    A function to translate the where clause, just before it gets executed.
  - dfWhere
```
private java.lang.String dfWhere
```
    The where clause, including the dynamic filters, before preprocessing.
  - buffer
```
private RecordBuffer buffer
```
    Record buffer updated by this component of the query
  - definition
```
private final RecordBuffer definition
```
    For bound buffers, this is the definition buffer
  - join
```
private final AbstractJoin join
```
    Helper object for a join via a foreign key relation
  - lockType
```
private final LockType lockType
```
    Record lock type
  - origArgs
```
private final java.lang.Object[] origArgs
```
    Original arguments before query substitution arguments preprocessing.
  - args
```
private final java.lang.Object[] args
```
    Base substitution arguments for this component
  - dfArgs
```
private java.lang.Object[] dfArgs
```
    The substitution arguments with dynamic filtered ones inserted in front.
  - outer
```
private final boolean outer
```
    true if component forms outer join with previous component; else false
  - idOnly
```
private final boolean idOnly
```
    Whether query should return primary key ID only, or entire DMO
  - top
```
private boolean top
```
    Is this component the top/outermost among the query's components?
  - referenceSubs
```
private java.lang.String[] referenceSubs
```
    Array of field reference names and nulls used to replace substitution parameters when converting a nested looping (client-side) join to a server-side join
  - relatedBuffers
```
private java.util.Set<RecordBuffer> relatedBuffers
```
    Set of related buffers, if component participates in a server-side join
  - iteration
```
private int iteration
```
    Iteration/retrieval mode (first, last, next, etc.)
  - sort
```
private java.lang.String sort
```
    Order by clause for FIRST/LAST iteration components
  - fqlPreprocessor
```
private FQLPreprocessor fqlPreprocessor
```
    FQL preprocessor
  - nullArguments
```
private boolean[] nullArguments
```
    Position of null elements in argument list with which FQL was preprocessed
  - sortIndex
```
private SortIndex sortIndex
```
    Sort index associated with this query component
  - currentArgs
```
private java.lang.Object[] currentArgs
```
    Intermediately resolved arguments for this component
  - indexInfo
```
private java.lang.String indexInfo
```
    Index information string as it is returned by INDEX-INFORMATION.
  - dynamicFilters
```
private java.util.Map<FieldReference,BaseDataType> dynamicFilters
```
    The list of dynamic filters. These are filters added dynamically, at runtime and can also be removed dynamically.
  - dynamicFormats
```
private java.util.Map<FieldReference,java.lang.String> dynamicFormats
```
    The list of format used by dynamic filters. These are filters added dynamically, at runtime and can also be removed dynamically.
- Constructor Detail
  - QueryComponent
```
protected QueryComponent(Joinable query,
                         BufferReference proxy,
                         AbstractJoin join,
                         java.lang.String where,
                         java.util.function.Supplier<java.lang.String> translateWhere,
                         java.lang.String indexInfo,
                         LockType lockType,
                         java.lang.Object[] args,
                         int iteration,
                         boolean outer)
```
    Constructor.
    
    Parameters:
    
    query - Enclosing query.
    
    proxy - DMO proxy which references the record buffer updated by this component of the query.
    
    join - Helper object for a join via a foreign key relation. May be null.
    
    where - Restriction criteria in FQL where clause format.
    
    translateWhere - A function to translate the where clause, just before it gets executed.
    
    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 - Requested record lock type.
    
    args - Default (unresolved) query substitution arguments.
    
    iteration - Type of iteration: FIRST, LAST, NEXT, PREVIOUS, or UNIQUE.
    
    outer - true if this component is joined with the previous component via an outer join; false if there is no previous component, or if this component is joined with the previous component via an inner join.
- Method Detail
  - prepareServerJoinData
```
static QueryComponent.ServerJoinData prepareServerJoinData(java.util.List<? extends QueryComponent> joinList,
                                                           RecordBuffer buffer,
                                                           AbstractJoin join,
                                                           java.lang.Object[] args)
```
    Prepare the information needed to convert a nested looping (client-side) join of two tables to a server-side join of those tables.
    
    Parameters:
    
    joinList - List of enclosing query components, from outermost to innermost (if any), from the original nested query. Does not include the component currently being visited.
    
    buffer - Record buffer associated with the query component currently being visited.
    
    join - Original join helper object which joins the current query component with an outer component or external buffer.
    
    args - Query substitution arguments for the where clause of the current query component.
    
    Returns:
    
    An object containing the information needed to convert the join from client-side to server-side.
  - translateWhere
```
protected void translateWhere()
```
    Translate the where clause, using the translateWhere function.
  - getHQLPreprocessor
```
protected FQLPreprocessor getHQLPreprocessor()
                                      throws PersistenceException
```
    Get the FQL preprocessor associated with this component.
    
    Returns:
    
    FQL preprocessor.
    
    Throws:
    
    PersistenceException - if the preprocessor must first be created, and there is an error during its creation.
  - prepareHQLPreprocessor
```
protected FQLPreprocessor prepareHQLPreprocessor(java.lang.Object[] queryArgs)
                                          throws PersistenceException
```
    Create the FQLPreprocessor which backs this component. If this component represents a nested FIRST or LAST iteration, the where clause portion associated with this component will be embedded within a subselect. To avoid conflicts with the enclosing where clause, this portion will be emitted without DMO alias qualifiers for its references to the associated buffer.
    
    Parameters:
    
    queryArgs - Query substitution parameters used in the preprocessor's creation.
    
    Returns:
    
    FQL preprocessor.
    
    Throws:
    
    PersistenceException - if there is an error creating the preprocessor.
  - getReferencedBuffers
```
protected RecordBuffer[] getReferencedBuffers()
```
    Get an array of all record buffers referenced by this query, including those directly involved in the query, as well as those (if any) indirectly referenced by inlined, converted, CAN-FIND expressions, and those related via a server-side join (if any).
    
    Returns:
    
    All record buffers referenced by this query.
  - getArgs
```
protected java.lang.Object[] getArgs()
                              throws PersistenceException
```
    Get substitution arguments for this component, resolving them first if necessary.
    
    Returns:
    
    Substitution arguments.
    
    Throws:
    
    PersistenceException - if there is any error creating the FQL preprocessor, which is necessary to properly filter/order the arguments.
  - resetArgs
```
protected void resetArgs(boolean forceOrigArgs)
```
    Reset current arguments, so that they will need to be resolved the next time they are requested. The fqlPreprocessor is dropped only if it was inlined (and the inlined nodes need to be re-evaluated with the new arguments) or if the argument list contains some other configuration of null values (they were also replaced with "is [not] null" fql constructs).
    
    Parameters:
    
    forceOrigArgs - Flag indicating that the original arguments used at the construction of the query must be re-calculated.
  - resetHQLPreprocessor
```
protected void resetHQLPreprocessor()
```
    Reset the FQL preprocessor, so that it needs to be recreated the next time it is requested.
  - filterArgs
```
protected java.lang.Object[] filterArgs(FQLPreprocessor preproc)
```
    Get the (mostly) resolved query substitution parameters required by this query component and return them in an array. The array's elements will match the positional placeholders in the query's where clause after it has been preprocessed. The preprocessing step may have reordered or dropped certain parameters. The only parameters which will not have been fully resolved will be those FieldReference parameters which are actually resolved by the query itself, when the query's full FQL is being assembled and when the final array of substitution parameters is prepared.
    
    Parameters:
    
    preproc - FQL preprocessor which maps parameter indices to the original parameters, in case any were changed during FQL where clause preprocessing.
    
    Returns:
    
    Array of filtered, resolved parameters.
  - setReferenceSubs
```
protected void setReferenceSubs(java.lang.String[] referenceSubs)
```
    Set the array of field reference names and nulls used when converting a nested loop where clause to a server-join where clause.
    
    Parameters:
    
    referenceSubs - Array of field reference names and nulls.
  - setRelatedBuffers
```
protected void setRelatedBuffers(java.util.Set<RecordBuffer> relatedBuffers)
```
    Store a set of outer component buffers to which this component is related through a server side join.
    
    Parameters:
    
    relatedBuffers - Set of related buffers; may be null.
  - processDynamicFilters
```
void processDynamicFilters()
```
    Processes all dynamic filters altering the original where predicate and inserting optional substitution arguments in the list of static ones.
    This method must be always called before accessing the where predicate or substitutions arguments, otherwise the dynamic filtering will not be correctly applied.
  - resolveArgs
```
private java.lang.Object[] resolveArgs()
```
    Resolve all resolvable query substitution parameters, with the exception of FieldReferences. The latter are only query substitution parameters when it is necessary to join the enclosing query's results with those of a related query, as would be the case when each query is a component of a CompoundQuery.
    
    Returns:
    
    Array of query substitution parameters after all non-FieldReference resolvable parameters have been resolved.
  - resolveArg
```
private java.lang.Object resolveArg(java.lang.Object arg)
```
    Resolve a single resolvable query substitution parameter, with the exception of FieldReferences.
    
    Returns:
    
    The resolved query substitution parameter or arg itself if it is an instance of FieldReference.
  - isIdOnly
```
protected boolean isIdOnly()
```
    Indicate whether the query component should return a primary key ID only, or the entire DMO instance.
    
    Returns:
    
    true for a projection query which returns only the ID; false to fetch the entire DMO.
  - getEnclosingQuery
```
protected Joinable getEnclosingQuery()
```
    Get the query which encloses this component.
    
    Returns:
    
    Enclosing query.
  - enableTranslateWhere
```
void enableTranslateWhere(java.util.function.Function<java.lang.String,java.lang.String> translate)
```
    Enable the translateWhere for this component (if not already enabled).
    
    Parameters:
    
    translate - The translation function, which will receive as argument the where predicate.
  - getBuffer
```
RecordBuffer getBuffer()
```
    Get record buffer for this component of the query.
    
    Returns:
    
    Record buffer.
  - setBuffer
```
void setBuffer(RecordBuffer buffer)
```
    Set the record buffer for this component's query.
    
    Parameters:
    
    buffer - Record buffer.
  - getDefinitionBuffer
```
RecordBuffer getDefinitionBuffer()
```
    Get definition record buffer for this component of the query.
    
    Returns:
    
    Record buffer.
  - getOriginalWhere
```
java.lang.String getOriginalWhere()
```
    Get restriction criteria in FQL where clause format for this component (before the FQL preprocessor has preprocessed it). If some dynamic filters were added, the returned string contains them, too.
    
    Returns:
    
    Un-preprocessed where clause.
  - getJoin
```
AbstractJoin getJoin()
```
    Get helper object for a join via a foreign key relation, if any.
    
    Returns:
    
    Join helper, or null if there is none.
  - getWhere
```
FQLExpression getWhere()
                throws PersistenceException
```
    Get restriction criteria in FQL where clause format for this component (pre-processed).
    
    Returns:
    
    Where clause.
    
    Throws:
    
    PersistenceException - if there is an error creating the FQLPreprocessor from which the preprocessed where clause is retrieved.
  - addDynamicFilter
```
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.
    
    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
```
void clearDynamicFilters()
```
    Clears any dynamically filters added at runtime. The query predicate will be restored to its form from generated at conversion time.
  - getLockType
```
LockType getLockType()
```
    Get lock type for records fetched into this component's buffer.
    
    Returns:
    
    Lock type.
  - getRawArgs
```
java.lang.Object[] getRawArgs()
```
    Get unresolved substitution arguments for this component, if any.
    
    Returns:
    
    Substitution arguments, or null if none.
  - getIteration
```
int getIteration()
```
    Get iteration/retrieval mode (first, last, next, etc.).
    
    Returns:
    
    Retrieval mode from QueryConstants.
  - setIteration
```
void setIteration(int iteration,
                  java.lang.String sort)
           throws PersistenceException
```
    Set iteration/retrieval mode (first, last, next, etc.).
    
    Parameters:
    
    iteration - Retrieval mode from QueryConstants.
    
    sort - Order by clause which should be associated with this query component. Must be non-null for iteration types FIRST and LAST.
    
    Throws:
    
    java.lang.IllegalArgumentException - if iteration type is FIRST or LAST, but sort is null.
    
    PersistenceException - if sort clause is invalid.
  - setNotTop
```
void setNotTop()
```
    Mark this query component as being nested within an outer component (i.e., not the top component in a nested looping query).
  - isOuter
```
boolean isOuter()
```
    Indicate whether this component is joined with the previous component via a left outer join.
    
    Returns:
    
    true if an outer join, false if an inner join or no join (i.e., no previous component).
  - compositeJoins
```
java.util.Iterator<java.lang.String> compositeJoins()
                                             throws PersistenceException
```
    Get an iterator on the ANSI-style join subexpressions which must be merged by the enclosing query into the overall FQL query statement in order to properly join associated composite element lists (if any).
    
    Returns:
    
    An iterator on join subexpressions. The iterator may be empty, but will not be null.
    
    Throws:
    
    PersistenceException - if there is an error creating the FQLPreprocessor from which the composite join subexpressions are gathered.
  - getRestrictionProperties
```
java.util.Map<java.lang.String,java.util.Set<java.lang.String>> getRestrictionProperties()
                                                                                  throws PersistenceException
```
    Get an unmodifiable map of DMO entity names to sets of the names of the DMO properties used as restriction criteria in the preprocessed where clause.
    
    Returns:
    
    Map of DMO entity names to sets of property names, or null if the where clause for this component contained no restriction properties.
    
    Throws:
    
    PersistenceException - if there is an error creating the FQLPreprocessor from which the restriction properties are gathered.
  - getSortIndex
```
SortIndex getSortIndex()
```
    Get sort criteria in FQL order by clause format for this component.
    
    Returns:
    
    Sort index associated with this component.
  - setSortIndex
```
void setSortIndex(SortIndex sortIndex)
```
    Set sort criteria in FQL order by clause format for this component.
    
    Parameters:
    
    sortIndex - Sort index.
  - getIndexInfo
```
java.lang.String getIndexInfo()
```
    Get the index information string as it is returned by INDEX-INFORMATION.
    
    Returns:
    
    Index information string.

Class QueryComponent

Nested Class Summary

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

query

where

translateWhere

dfWhere

buffer

definition

join

lockType

origArgs

args

dfArgs

outer

idOnly

top

referenceSubs

relatedBuffers

iteration

sort

fqlPreprocessor

nullArguments

sortIndex

currentArgs

indexInfo

dynamicFilters

dynamicFormats

Constructor Detail

QueryComponent

Method Detail

prepareServerJoinData

translateWhere

getHQLPreprocessor

prepareHQLPreprocessor

getReferencedBuffers

getArgs

resetArgs

resetHQLPreprocessor

filterArgs

setReferenceSubs

setRelatedBuffers

processDynamicFilters

resolveArgs

resolveArg

isIdOnly

getEnclosingQuery

enableTranslateWhere

getBuffer

setBuffer

getDefinitionBuffer

getOriginalWhere

getJoin

getWhere

addDynamicFilter

clearDynamicFilters

getLockType

getRawArgs

getIteration

setIteration

setNotTop

isOuter

compositeJoins

getRestrictionProperties

getSortIndex

setSortIndex

getIndexInfo