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

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

All Implemented Interfaces:

UnsafePersistence

Direct Known Subclasses:

RemotePersistence
```
public class Persistence
extends java.lang.Object
implements UnsafePersistence
```
The central point for fundamental persistence services in the P2J environment. This implementation is backed by the FWD ORM framework. This class provides basic CRUD (create, read, update, delete) services, as well as methods to begin/commit/rollback database-level transactions.
An instance of this class is retrieved from PersistenceFactory.getInstance(Database) method One instance of this class is associated with a single, physical database. Multiple user sessions can use this shared instance; each will have its own context.
An instance of a concrete LockManager implementation is created for each each instance of this class. The implementation to use is queried from the directory service, and defaults to the InMemoryLockManager if no other implementation is specified in the directory.
Transactions are explicitly managed with beginTransaction(), commit() and rollback(). Only one transaction per client context may be active at a time. These are database-level transactions, which may or may not coincide with application-level transactions.
External code which directly accesses query methods within the Persistence class should always properly bracket its use of these methods with transactions.
ORM sessions are managed implicitly, transparently to application code and even to other classes within the persistence framework. No more than one session per user context may be active at a time. Sessions are opened lazily as they are needed to fulfill database operations: executing a query, persisting a record, creating a temporary table, etc. They are closed when the runtime environment detects that they are no longer needed by any active resource. Upon opening a new session, the current context's BufferManager instance is interrogated for all active records. These are the current records stored in all open record buffers for the database matching the current Persistence instance. They represent detached records previously associated with the last open session (if any).

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) class`	`Persistence.Context` A storage and work area for context-local variables used by the enclosing class.
`private static class`	`Persistence.QueryKey` A hash key for a unique combination of FQL, with the existence of lack of maximum results, and starting row offset options.

Field Summary

Fields
Modifier and Type	Field and Description
`private static boolean`	`active` `true` if the persistence layer can be used.
`private boolean`	`allowDBUniqueCheck` Flag that marks if server side index validation can be skipped or not.
`private java.lang.String`	`codepage` The CP for this database.
`private java.lang.String`	`collation` The collation for this database.
`private ContextLocal<Persistence.Context>`	`context` Context local object to manage persistence variables
`private Database`	`database` Database served by this object.
`private static java.lang.String`	`DEFAULT_IDENTITY_MANAGER` Default identity manager implementation
`private static java.lang.String`	`DEFAULT_LOCK_MANAGER` Default lock manager implementation
`private Dialect`	`dialect` Database dialect helper.
`private DmoVersioning`	`dmoVersion` DMO version tracker (persistent databases only)
`private static boolean`	`foreignKeysEnabled` Flag indicating whether records are joined using foreign keys
`private int`	`hashCode` Cached hash code
`static java.lang.String`	`ID_GEN_SEQUENCE` Well-known name of ID generator sequence
`private IdentityManager`	`identityManager` Identity manager
`private boolean`	`isMultiTenancyEnabled` Flag that determines if multi-tenancy is enabled or not.
`private LockManager<java.lang.String>`	`lockManager` Pessimistic lock manager
`private LockTableUpdater`	`lockTableUpdater` Object which keeps lock metadata in sync with record lock activity
`private static CentralLogger`	`LOG` Logger
`private static java.lang.String`	`NOT_DETECTED_YET` Special values for a `codepage` or `collation` which has not been detected yet.
`private boolean`	`temporary` Does this object represent the temporary database?

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Persistence(Database database, Dialect dialect)` Construct an instance for a particular, physical database, storing the dialect which is used to create a portability layer.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`allowDBUniqueCheck()` Check if we can skip the index server-validation.
`boolean`	`beginTransaction()` Make sure a (new) transaction instance is created and stored in the local context.
`(package private) boolean`	`beginTransaction(Persistence.Context local, SavepointManager savepointManager)` Begin a new transaction and store the instance in the local context.
`(package private) boolean`	`beginTransaction(SavepointManager savepointManager)`
`void`	`cleanup()` Clean up the current context.
`void`	`commit()` Commit the current database transaction and close the current session.
`(package private) void`	`commit(Persistence.Context local)` Commit the current database transaction and close the current session.
`protected IdentityManager`	`createIdentityManager()` Create and initialize the identity manager to be used with this instance of persistence services for the given database.
`protected LockManager<java.lang.String>`	`createLockManager()` Create and initialize the lock manager to be used with this instance of persistence services for the given database.
`void`	`delete(Record dmo)` Delete the persisted object from the specified database.
`int`	`deleteOrUpdate(java.lang.String fql, java.lang.Object[] values, java.lang.String entity, boolean noUndo)` Perform a bulk delete or update of all objects which meet the specified criteria.
`(package private) void`	`deregisterSessionListener(SessionListener listener)` Deregister a session listener when it no longer needs to receive session life cycle events.
`(package private) void`	`enableTransactionTrace(boolean enable)` Set enable mode for transaction tracing in the current context.
`boolean`	`equals(java.lang.Object o)` Override the parent's implementation to ensure it is consistent with `hashCode`.
`(package private) void`	`evict(java.util.Collection<Record> evictees)` Evict a collection of DMOs from the current ORM session.
`(package private) void`	`evict(Persistence.Context local, Record dmo)` Evict the given DMO from the current session immediately.
`int`	`executeSQL(java.lang.String sql)` Execute an arbitrary SQL statement which does not produce a result set.
`int`	`executeSQL(java.lang.String sql, java.lang.Object[] args)` Execute an arbitrary SQL statement which does not produce a result set.
`int`	`executeSQL(java.lang.String sql, java.lang.Object[] args, boolean noUndo)` Execute an arbitrary SQL statement which does not produce a result set.
`void`	`executeSQLBatch(java.util.List<java.lang.String> sql, boolean noFlush)` Execute an arbitrary list of SQL statements in batch.
`void`	`executeSQLBatch(Persistence.Context local, java.util.List<java.lang.String> sql, boolean noFlush)` Execute an arbitrary list of standard JDBC statements in batch.
`void`	`executeSQLBatch(java.lang.String sql, java.util.function.Supplier<java.lang.Object[]> getArgs)` Execute a batch SQL statement, while the argument supplier returns non-null values.
`<T> ScrollableResults<T>`	`executeSQLQuery(java.lang.String sql, java.lang.Object[] args)` Execute an arbitrary SQL query.
`void`	`flush()` Flush the current session, which synchronizes the in-memory state of DMOs to the database.
`(package private) void`	`flush(boolean clear)` Flush the current session, which synchronizes the in-memory state of DMOs to the database.
`(package private) void`	`flush(Persistence.Context local, Session session, boolean clear)` Flush the current session, which synchronizes the in-memory state of DMOs to the database.
`static Persistence`	`get(java.lang.String name)` Deprecated. Use `PersistenceFactory.getInstance(String)` instead.
`(package private) java.lang.Throwable`	`getBeginTxTrace()` Retrieve trace information about where the current transaction, if any, was started.
`java.lang.String`	`getCodepage()` Use the dialect to obtain the code page (character encoding) of this connection.
`java.lang.String`	`getCollation()` Use the dialect to obtain the collation of this connection.
`(package private) Persistence.Context`	`getContext()` Get the context for the current user session.
`Database`	`getDatabase()` Get the database information object associated with this persistence service object.
`Dialect`	`getDialect()` Get the database dialect helper object associated with the database backing this object.
`IdentityManager`	`getIdentityManager()` Get the identity manager associated with this `Persistence` instance.
`LockManager<java.lang.String>`	`getLockManager()` Get the lock manager associated with this `Persistence` instance.
`private Query`	`getQuery(Persistence.Context local, java.lang.String fql, int maxResults, int startOffset, DataRelation relation, java.lang.Object[] values)` Get or create a query for the given FQL query string.
`private Query`	`getQuery(Persistence.Context local, java.lang.String fql, int maxResults, int startOffset, DataRelation relation, java.lang.Object[] values, boolean lazyMode)` Get or create a query for the given FQL query string.
`RecordLockContext`	`getRecordLockContext()` Get the record lock context associated with the current client session.
`Session`	`getSession()` Get the ORM session associated with the current context, creating one if needed.
`<T> T`	`getSingleSQLResult(java.lang.String sql, java.lang.Object[] args)` Convenience method to retrieve a single result from a SQL statement.
`private void`	`handleException(Persistence.Context local, PersistenceException exc, java.lang.String message)` Provides a template for handling PersistenceException exceptions.
`private void`	`handleException(java.lang.String message, PersistenceException exc)` Raise a STOP condition, if the given exception represents a catastrophic, JDBC failure; else throw a `PersistenceException`.
`int`	`hashCode()` Override the parent's implementation to return a hash code cached at construction.
`static void`	`initialize()` Initialize various infrastructure components of the persistence framework: `DataTypeHelper`, which is used when preprocessing FQL where clauses.
`protected void`	`initializeInstance()` Initialize the helper objects to which this object delegates certain service requests.
`static boolean`	`isActive()` Reports if the persistence layer can be used or not.
`(package private) static boolean`	`isForeignKeysEnabled()` Determine whether records are joined using foreign keys.
`(package private) boolean`	`isTemporary()` Determine whether this persistence object is for a temporary table database.
`boolean`	`isTransactionOpen()` Indicate whether an explicit, database-level transaction currently is open.
`<T> java.util.List<T>`	`list(java.lang.String[] entities, java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, boolean hydrateRecords)` Execute an FQL query and return the results as a list.
`<T> java.util.List<T>`	`list(java.lang.String[] entities, java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, DataRelation relation, boolean hydrateRecords)` Execute an FQL query and return the results as a list.
`<T> java.util.List<T>`	`list(java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset)` Execute an FQL query and return the results as a list.
`<T> java.util.List<T>`	`list(java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, DataRelation relation)` Execute an FQL query and return the results as a list.
`Record`	`load(java.lang.Class<? extends Record> implClass, java.lang.Long id, LockType lockType, long timeout, boolean updateLock)` Load a single record from the session-level cache or, optionally, refresh it from the database.
`Record`	`load(java.lang.Class<? extends Record> implClass, java.lang.Long id, LockType lockType, long timeout, boolean updateLock, java.util.BitSet partialFields)` Load a single record from the session-level cache or, optionally, refresh it from the database.
`Record`	`load(RecordBuffer buffer, java.lang.String fql, java.lang.Object[] values, LockType lockType, long timeout, boolean unique, boolean updateLock, boolean forceRefresh, boolean findByKey)` Execute an FQL query and load a single record from the session-level cache or, optionally, refresh it from the database.
`void`	`lock(LockType lockType, RecordIdentifier<java.lang.String> ident, boolean update)` Attempt to obtain the specified lock type on a particular record.
`void`	`lock(LockType lockType, RecordIdentifier<java.lang.String> ident, boolean update, long timeout)` Attempt to obtain the specified lock type on a particular record.
`LockType`	`lockTable(java.lang.String table, LockType lockType, boolean update)` Attempt to obtain the specified lock type on a table.
`Record`	`merge(Record dmo)` Deprecated.
`java.lang.String`	`message(java.lang.String message)` Format the given message text by prepending a descriptor including the user's current context and the physical name of the database.
`java.lang.Long`	`nextPrimaryKey(java.lang.String table)` Obtain the next available primary key ID on a per-table basis.
`static java.lang.Object`	`preprocessQueryParameter(java.lang.Object arg, Dialect dialect)` Perform special handling on a query substitution parameter to avoid errors during query execution.
`private void`	`preprocessQueryParameters(java.lang.Object[] args)` Perform special handling on query substitution parameters to avoid errors during query execution.
`LockType`	`queryLock(RecordIdentifier<java.lang.String> ident)` Query the lock type currently held by the current context for the specified database record.
`Record`	`quickLoad(RecordIdentifier<java.lang.String> ident)` Load a single record from the database or from the session-level cache.
`Record`	`quickLoad(RecordIdentifier<java.lang.String> ident, boolean refresh)` Load a single record from the database or from the session-level cache.
`(package private) void`	`registerSessionListener(SessionListener listener, SessionListener.Scope scope)` Register a `SessionListener` to receive session life cycle event notifications.
`(package private) void`	`reportUDFVersion(Database database, DatabaseConfig cfg)` Logs the FWD version returned by the getFWDVersion user-defined function (UDF/p2jpl) for this database.
`void`	`rollback()` Roll back the current database transaction and close the current session.
`(package private) void`	`rollback(Persistence.Context local)` Roll back the current database transaction and close the current session.
`void`	`save(Record dmo)` Updates the existing record in the backing database session.
`void`	`save(Record dmo, java.lang.Long id)` Persist the specified object to the backing database session, using the given ID.
`void`	`save(Record dmo, java.lang.Long id, boolean updateDmoState)` Persist the specified object to the backing database session, using the given ID.
`<T> ScrollableResults<T>`	`scroll(java.lang.String[] entities, java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, DataRelation relation, int scrollMode)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String[] entities, java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, DataRelation relation, int scrollMode, boolean lazyMode)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String[] entities, java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, int scrollMode)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String[] entities, java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, int scrollMode, boolean lazyMode)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String fql, java.lang.Object[] values)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String fql, java.lang.Object[] values, DataRelation relation)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, DataRelation relation)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, DataRelation relation, int scrollMode)` Execute an FQL query and get a scrollable cursor on the result set.
`<T> ScrollableResults<T>`	`scroll(java.lang.String fql, java.lang.Object[] values, int maxResults, int startOffset, int scrollMode)` Execute an FQL query and get a scrollable cursor on the result set.
`void`	`setUnsafe(boolean value)` Decide whether this persistence context is unsafe or not.
`(package private) void`	`shareLockTableUpdater(Database database)` If this object is associated with a metadata database, set this object's lock table updater to be the same as that of the `Persistence` instance associated with the given, primary database.
`boolean`	`supportsLazyQueryResultsMode()` Check if we can retrieve data lazily from the underlying database.
`(package private) void`	`uniqueResultViolation(RecordBuffer buffer, java.lang.Exception exc)` Process an error condition in which a unique result should have been found, but multiple results occurred.

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

- Field Detail
  - ID_GEN_SEQUENCE
```
public static final java.lang.String ID_GEN_SEQUENCE
```
    Well-known name of ID generator sequence
    
    See Also:
    
    Constant Field Values
  - LOG
```
private static final CentralLogger LOG
```
    Logger
  - DEFAULT_LOCK_MANAGER
```
private static final java.lang.String DEFAULT_LOCK_MANAGER
```
    Default lock manager implementation
    
    See Also:
    
    Constant Field Values
  - DEFAULT_IDENTITY_MANAGER
```
private static final java.lang.String DEFAULT_IDENTITY_MANAGER
```
    Default identity manager implementation
    
    See Also:
    
    Constant Field Values
  - NOT_DETECTED_YET
```
private static final java.lang.String NOT_DETECTED_YET
```
    Special values for a codepage or collation which has not been detected yet.
    
    See Also:
    
    Constant Field Values
  - foreignKeysEnabled
```
private static boolean foreignKeysEnabled
```
    Flag indicating whether records are joined using foreign keys
  - active
```
private static volatile boolean active
```
    true if the persistence layer can be used.
  - context
```
private final ContextLocal<Persistence.Context> context
```
    Context local object to manage persistence variables
  - database
```
private Database database
```
    Database served by this object.
  - isMultiTenancyEnabled
```
private boolean isMultiTenancyEnabled
```
    Flag that determines if multi-tenancy is enabled or not.
  - dialect
```
private Dialect dialect
```
    Database dialect helper.
  - codepage
```
private java.lang.String codepage
```
    The CP for this database.
  - collation
```
private java.lang.String collation
```
    The collation for this database.
  - temporary
```
private final boolean temporary
```
    Does this object represent the temporary database?
  - allowDBUniqueCheck
```
private final boolean allowDBUniqueCheck
```
    Flag that marks if server side index validation can be skipped or not.
  - hashCode
```
private final int hashCode
```
    Cached hash code
  - dmoVersion
```
private final DmoVersioning dmoVersion
```
    DMO version tracker (persistent databases only)
  - lockManager
```
private LockManager<java.lang.String> lockManager
```
    Pessimistic lock manager
  - lockTableUpdater
```
private LockTableUpdater lockTableUpdater
```
    Object which keeps lock metadata in sync with record lock activity
  - identityManager
```
private IdentityManager identityManager
```
    Identity manager
- Constructor Detail
  - Persistence
```
protected Persistence(Database database,
                      Dialect dialect)
```
    Construct an instance for a particular, physical database, storing the dialect which is used to create a portability layer.
    
    Parameters:
    
    database - Database with which this instance is permanently associated.
    
    dialect - Portability object used to issue dialect-specific commands to the database.
- Method Detail
  - get
```
@Deprecated
public static Persistence get(java.lang.String name)
```
    Deprecated. Use PersistenceFactory.getInstance(String) instead.
    
    Get the instance of this class associated with the given, physical database name, creating it first if necessary. Newly created instances are stored in a static cache.
    
    Parameters:
    
    name - Name of physical database with which the instance is permanently associated.
    
    Returns:
    
    Persistence object associated with the given database.
  - initialize
```
public static void initialize()
                       throws PersistenceException
```
    Initialize various infrastructure components of the persistence framework:
    - DataTypeHelper, which is used when preprocessing FQL where clauses.
    - DatabaseManager, which configures the ORM environment for the databases to which the framework connects.
    - P2OLookup, instances of which are used for runtime, on-the-fly query and temp-table conversion.
    - DatabaseTriggerManager, which tracks and fires database triggers at the appropriate times.
    Throws:
    
    java.lang.IllegalStateException - if invoked more than once.
    
    PersistenceException - if any error is encountered initializing the persistence framework.
    
    See Also:
    
    DataTypeHelper.initialize(), DatabaseManager.initialize(), TemporaryDatabaseManager.initialize(), P2OLookup.initialize(), CacheManager.initialize()
  - isActive
```
public static boolean isActive()
```
    Reports if the persistence layer can be used or not.
    
    Returns:
    
    true if the persistence layer is initialized and can be used.
  - preprocessQueryParameter
```
public static java.lang.Object preprocessQueryParameter(java.lang.Object arg,
                                                        Dialect dialect)
```
    Perform special handling on a query substitution parameter to avoid errors during query execution. This entails:
    - Trimming all trailing spaces, tabs, line feeds, and carriage returns from any parameter of type character. Any parameter affected is replaced with a new character instance at the same index position within args.
    - Clipping out of bounds date values to the range supported by the backing database's implementation of a date data type. Any parameter affected is replaced with a new date instance at the same index position within args.
    Note: this method has special processing for null bytes embedded in character variables. The text of the variable is truncated starting at the first embedded null byte. This means that the resulting substitution parameters are guaranteed to never include null bytes.
    Parameters:
    
    arg - A single substitution parameter.
    
    dialect - Database dialect.
    
    Returns:
    
    The given parameter, processed as described above.
  - isForeignKeysEnabled
```
static boolean isForeignKeysEnabled()
```
    Determine whether records are joined using foreign keys.
    
    Returns:
    
    true if records are joined using foreign keys; false if records are joined using legacy key fields.
  - reportUDFVersion
```
void reportUDFVersion(Database database,
                      DatabaseConfig cfg)
               throws PersistenceException
```
    Logs the FWD version returned by the getFWDVersion user-defined function (UDF/p2jpl) for this database. When this database is a temporary or not primary this method is a no-op. If the method fails to retrieve the version string, "undefined" version is reported in the log output.
    
    Parameters:
    
    database - The database in use.
    
    cfg - The database configuration in use.
    
    Throws:
    
    PersistenceException - if there is a problem creating a database session or statement.
  - hashCode
```
public final int hashCode()
```
    Override the parent's implementation to return a hash code cached at construction.
    
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public final boolean equals(java.lang.Object o)
```
    Override the parent's implementation to ensure it is consistent with hashCode.
    
    Overrides:
    
    equals in class java.lang.Object
  - getDialect
```
public Dialect getDialect()
```
    Get the database dialect helper object associated with the database backing this object.
    
    Returns:
    
    Database dialect helper.
  - getDatabase
```
public Database getDatabase()
```
    Get the database information object associated with this persistence service object. If the database cannot be retrieved from the context, take the main class object.
    
    Returns:
    
    Database information object.
  - getLockManager
```
public LockManager<java.lang.String> getLockManager()
```
    Get the lock manager associated with this Persistence instance. For temp tables, this will be null, since temp table data is naturally compartmentalized and record locking is meaningless in this case. For permanent databases, this method will return the lock manager created when this class was instantiated.
    
    Returns:
    
    Lock manager instance associated with this persistence service object.
  - getIdentityManager
```
public IdentityManager getIdentityManager()
```
    Get the identity manager associated with this Persistence instance. For temp tables, this will be null, since for temp tables unique primary keys generated using TemporaryBuffer.nextPrimaryKey(). For permanent databases, this method will return the identity manager created when this class was instantiated.
    
    Returns:
    
    Identity manager instance associated with this persistence service object.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String fql,
                                       java.lang.Object[] values)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method. This method creates a new, context local ORM session if necessary.
    Note:
    While this method attempts to use a server-side database cursor to fetch results, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the entire result set in memory instead, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String fql,
                                       java.lang.Object[] values,
                                       DataRelation relation)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method. This method creates a new, context local ORM session if necessary.
    Note:
    While this method attempts to use a server-side database cursor to fetch results, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the entire result set in memory instead, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method. This method creates a new, context local ORM session if necessary.
    Note:
    While this method attempts to use a server-side database cursor to fetch results, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the entire result set in memory instead, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       DataRelation relation)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method. This method creates a new, context local ORM session if necessary.
    Note:
    While this method attempts to use a server-side database cursor to fetch results, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the entire result set in memory instead, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       int scrollMode)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method. This method creates a new, context local ORM session if necessary.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    scrollMode - Scroll mode which should apply to the result set.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       DataRelation relation,
                                       int scrollMode)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method. This method creates a new, context local ORM session if necessary.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    scrollMode - Scroll mode which should apply to the result set.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String[] entities,
                                       java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       int scrollMode)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    entities - Names of the DMO entities associated with this query statement (Unused parameter).
    
    fql - FQL query statement to be parsed and executed by ORM framework.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    scrollMode - Scroll mode which should apply to the result set.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String[] entities,
                                       java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       DataRelation relation,
                                       int scrollMode)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    entities - Names of the DMO entities associated with this query statement (Unused parameter).
    
    fql - FQL query statement to be parsed and executed by ORM framework.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    scrollMode - Scroll mode which should apply to the result set.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String[] entities,
                                       java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       int scrollMode,
                                       boolean lazyMode)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    entities - Names of the DMO entities associated with this query statement (Unused parameter).
    
    fql - FQL query statement to be parsed and executed by ORM framework.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    scrollMode - Scroll mode which should apply to the result set.
    
    lazyMode - Flag that indicates whether the query should be executed in a lazy manner.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - scroll
```
public <T> ScrollableResults<T> scroll(java.lang.String[] entities,
                                       java.lang.String fql,
                                       java.lang.Object[] values,
                                       int maxResults,
                                       int startOffset,
                                       DataRelation relation,
                                       int scrollMode,
                                       boolean lazyMode)
                                throws PersistenceException
```
    Execute an FQL query and get a scrollable cursor on the result set. Records represented by the result set are not locked by this method.
    
    Specified by:
    
    scroll in interface UnsafePersistence
    
    Parameters:
    
    entities - Names of the DMO entities associated with this query statement (Unused parameter).
    
    fql - FQL query statement to be parsed and executed by ORM framework.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    scrollMode - Scroll mode which should apply to the result set.
    
    lazyMode - Flag that indicates whether the query should be executed in a lazy manner.
    
    Returns:
    
    An object which provides access to a scrollable cursor on the result set.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - list
```
public <T> java.util.List<T> list(java.lang.String fql,
                                  java.lang.Object[] values,
                                  int maxResults,
                                  int startOffset)
                           throws PersistenceException
```
    Execute an FQL query and return the results as a list. If the query returns multiple results per row, each element in the list will be an array of Objects.
    No locking is attempted.
    Note:
    This method should be used only for queries that are expected to return a relatively small result set, since the entire result set is stored in the returned list. Additionally, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the result set in memory, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    This overloaded variant always attempts to hydrate and return the result as Records.
    
    Specified by:
    
    list in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    Returns:
    
    A list of results, or null if no result was found.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - list
```
public <T> java.util.List<T> list(java.lang.String fql,
                                  java.lang.Object[] values,
                                  int maxResults,
                                  int startOffset,
                                  DataRelation relation)
                           throws PersistenceException
```
    Execute an FQL query and return the results as a list. If the query returns multiple results per row, each element in the list will be an array of Objects.
    No locking is attempted.
    Note:
    This method should be used only for queries that are expected to return a relatively small result set, since the entire result set is stored in the returned list. Additionally, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the result set in memory, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    This overloaded variant always attempts to hydrate and return the result as Records.
    
    Specified by:
    
    list in interface UnsafePersistence
    
    Parameters:
    
    fql - FQL query statement.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    Returns:
    
    A list of results, or null if no result was found.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - list
```
public <T> java.util.List<T> list(java.lang.String[] entities,
                                  java.lang.String fql,
                                  java.lang.Object[] values,
                                  int maxResults,
                                  int startOffset,
                                  boolean hydrateRecords)
                           throws PersistenceException
```
    Execute an FQL query and return the results as a list. If the query returns multiple results per row, each element in the list will be an array of Objects.
    No locking is attempted.
    Note:
    This method should be used only for queries that are expected to return a relatively small result set, since the entire result set is stored in the returned list. Additionally, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the result set in memory, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    
    Specified by:
    
    list in interface UnsafePersistence
    
    Type Parameters:
    
    T - Type of object being listed.
    
    Parameters:
    
    entities - Names of the DMO entities associated with this query statement (Unused parameter).
    
    fql - FQL query statement to be processed. This method makes no assumptions as to the types of object(s) returned.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    hydrateRecords - If true the result is interpreted as legacy records, and they will be hydrated. Otherwise, the returned List contains an array of Java objects for each row.
    
    Returns:
    
    A list of results, or null if no result was found.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - list
```
public <T> java.util.List<T> list(java.lang.String[] entities,
                                  java.lang.String fql,
                                  java.lang.Object[] values,
                                  int maxResults,
                                  int startOffset,
                                  DataRelation relation,
                                  boolean hydrateRecords)
                           throws PersistenceException
```
    Execute an FQL query and return the results as a list. If the query returns multiple results per row, each element in the list will be an array of Objects.
    No locking is attempted.
    Note:
    This method should be used only for queries that are expected to return a relatively small result set, since the entire result set is stored in the returned list. Additionally, some JDBC driver implementations (e.g., PostgreSQL) may store an intermediate form of the result set in memory, effectively doubling the amount of memory required. To avoid this, consider using scroll(String, Object[], int, int, DataRelation, int) instead. Using that method with a ScrollMode of FORWARD_ONLY and setting a JDBC fetch size to a reasonable value may allow a JDBC driver to use a server-side cursor to fetch smaller batches of results at a time. Consult your JDBC driver documentation and/or source code to determine whether this is an issue for your JDBC implementation.
    
    Specified by:
    
    list in interface UnsafePersistence
    
    Type Parameters:
    
    T - Type of object being listed.
    
    Parameters:
    
    entities - Names of the DMO entities associated with this query statement (Unused parameter).
    
    fql - FQL query statement to be processed. This method makes no assumptions as to the types of object(s) returned.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    maxResults - The maximum number of elements to be returned in the list. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    hydrateRecords - If true the result is interpreted as legacy records, and they will be hydrated. Otherwise, the returned List contains an array of Java objects for each row.
    
    Returns:
    
    A list of results, or null if no result was found.
    
    Throws:
    
    PersistenceException - if there was an error executing the query.
  - load
```
public Record load(RecordBuffer buffer,
                   java.lang.String fql,
                   java.lang.Object[] values,
                   LockType lockType,
                   long timeout,
                   boolean unique,
                   boolean updateLock,
                   boolean forceRefresh,
                   boolean findByKey)
            throws PersistenceException
```
    Execute an FQL query and load a single record from the session-level cache or, optionally, refresh it from the database. The record will be locked with the specified lock type upon return from this method. Note that the lock refers to a runtime-level lock, not a database-level lock. The record is not automatically loaded into the record buffer provided. The buffer argument is used only to extract information needed to perform the query.
    
    Specified by:
    
    load in interface UnsafePersistence
    
    Parameters:
    
    buffer - Record buffer which holds information about the DMO class type and name of the table being queried.
    
    fql - FQL query statement. This may be either an ID-only projection query or a full query (see above).
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    lockType - Type of lock the lock manager should register on the resulting record for the current user context.
    
    timeout - Number of milliseconds to wait to acquire the requested lock type. Throws LockTimeoutException if this time elapses before the lock is acquired. Specify 0 to wait indefinitely for the lock. Ignored if lockType is NONE.
    
    unique - true if no more than one result is expected from this query; false if the query could result in more than one record.
    
    updateLock - true to update the current lock state; false to leave the current lock state unchanged.
    
    forceRefresh - If true forces the record to be refreshed from database. Otherwise it will be refreshed only if the lockType has been upgraded from NONE.
    
    findByKey - If true, this overrides the current rereadnolock setting; if false, honor rereadnolock.
    
    Returns:
    
    A single DMO instance representing the query result, or null if no result was found.
    
    Throws:
    
    LockTimeoutException - if a record was found, but its lock could not be acquired within the positive timeout period specified.
    
    LockUnavailableException - if a record was found and a no-wait lock type was specified, but the lock could not be acquired immediately.
    
    PersistenceException - if there was an error executing the query or if a unique query (i.e., unique == true) returned multiple results,
  - load
```
public Record load(java.lang.Class<? extends Record> implClass,
                   java.lang.Long id,
                   LockType lockType,
                   long timeout,
                   boolean updateLock)
            throws PersistenceException,
                   LockTimeoutException
```
    Load a single record from the session-level cache or, optionally, refresh it from the database. The record will be locked with the specified lock type upon return from this method. Note that the lock refers to a runtime-level lock, not a database-level lock.
    
    Specified by:
    
    load in interface UnsafePersistence
    
    Parameters:
    
    implClass - The DMO implementation class of record being read.
    
    id - Primary key of the record to be loaded into the buffer. May not be null.
    
    lockType - Type of lock the lock manager should register on the resulting record for the current user context.
    
    timeout - Number of milliseconds to wait to acquire the requested lock type. Throws LockTimeoutException if this time elapses before the lock is acquired. Specify 0 to wait indefinitely for the lock. Ignored if lockType is NONE.
    
    updateLock - true to update the current lock state; false to leave the current lock state unchanged.
    
    Returns:
    
    A single DMO instance loaded from the database, or null if no result was found.
    
    Throws:
    
    LockTimeoutException - if a record was found, but its lock could not be acquired within the positive timeout period specified.
    
    LockUnavailableException - if a record was found and a no-wait lock type was specified, but the lock could not be acquired immediately.
    
    PersistenceException - if there was an error loading the DMO from the ORM session and/or database.
  - load
```
public Record load(java.lang.Class<? extends Record> implClass,
                   java.lang.Long id,
                   LockType lockType,
                   long timeout,
                   boolean updateLock,
                   java.util.BitSet partialFields)
            throws PersistenceException,
                   LockTimeoutException
```
    Load a single record from the session-level cache or, optionally, refresh it from the database. The record will be locked with the specified lock type upon return from this method. Note that the lock refers to a runtime-level lock, not a database-level lock.
    
    Specified by:
    
    load in interface UnsafePersistence
    
    Parameters:
    
    implClass - The DMO implementation class of record being read.
    
    id - Primary key of the record to be loaded into the buffer. May not be null.
    
    lockType - Type of lock the lock manager should register on the resulting record for the current user context.
    
    timeout - Number of milliseconds to wait to acquire the requested lock type. Throws LockTimeoutException if this time elapses before the lock is acquired. Specify 0 to wait indefinitely for the lock. Ignored if lockType is NONE.
    
    updateLock - true to update the current lock state; false to leave the current lock state unchanged.
    
    partialFields - For an incomplete record, read only these fields.
    
    Returns:
    
    A single DMO instance loaded from the database, or null if no result was found.
    
    Throws:
    
    LockTimeoutException - if a record was found, but its lock could not be acquired within the positive timeout period specified.
    
    LockUnavailableException - if a record was found and a no-wait lock type was specified, but the lock could not be acquired immediately.
    
    PersistenceException - if there was an error loading the DMO from the ORM session and/or database.
  - quickLoad
```
public Record quickLoad(RecordIdentifier<java.lang.String> ident)
                 throws PersistenceException
```
    Load a single record from the database or from the session-level cache. No locking is attempted, the assumption being that any required lock previously was acquired.
    
    Specified by:
    
    quickLoad in interface UnsafePersistence
    
    Parameters:
    
    ident - Record identifier of the record to be loaded. Consists of the primary key and the fully qualified DMO entity name.
    
    Returns:
    
    A single DMO instance loaded from the database, or null if no result was found.
    
    Throws:
    
    PersistenceException - if there was an error creating an ORM session or getting the requested record.
  - quickLoad
```
public Record quickLoad(RecordIdentifier<java.lang.String> ident,
                        boolean refresh)
                 throws PersistenceException
```
    Load a single record from the database or from the session-level cache. No locking is attempted, the assumption being that any required lock previously was acquired.
    
    Specified by:
    
    quickLoad in interface UnsafePersistence
    
    Parameters:
    
    ident - Record identifier of the record to be loaded. Consists of the primary key and the fully qualified DMO entity name.
    
    refresh - If true then re-read the state of the record from the underlying database. This is useful when record has been changed bypassing the FWD ORM.
    
    Returns:
    
    A single DMO instance loaded from the database, or null if no result was found.
    
    Throws:
    
    PersistenceException - if there was an error creating an ORM session or getting the requested record.
  - executeSQL
```
public int executeSQL(java.lang.String sql)
               throws PersistenceException
```
    Execute an arbitrary SQL statement which does not produce a result set.
    Note: Do not forget to invalidate the index-based cache (FastFindCache) of each buffer affected by this statement. This cannot be done here because the method is not aware of the buffer list and if multiple SQL statements are batch executed, then is better to issue a single invalidate command for all of then.
    
    Specified by:
    
    executeSQL in interface UnsafePersistence
    
    Parameters:
    
    sql - SQL statement text.
    
    Returns:
    
    The number of entities updated or deleted, or -1 if the statement did not complete normally.
    
    Throws:
    
    PersistenceException - if any error occurs executing the statement.
  - executeSQL
```
public int executeSQL(java.lang.String sql,
                      java.lang.Object[] args)
               throws PersistenceException
```
    Execute an arbitrary SQL statement which does not produce a result set.
    Note: Do not forget to invalidate the index-based cache (FastFindCache) of each buffer affected by this statement. This cannot be done here because the method is not aware of the buffer list and if multiple SQL statements are batch executed, then is better to issue a single invalidate command for all of then.
    
    Specified by:
    
    executeSQL in interface UnsafePersistence
    
    Parameters:
    
    sql - SQL statement text.
    
    args - The statement arguments.
    
    Returns:
    
    The number of entities updated or deleted, or -1 if the statement did not complete normally.
    
    Throws:
    
    PersistenceException - if any error occurs executing the statement.
  - executeSQLQuery
```
public <T> ScrollableResults<T> executeSQLQuery(java.lang.String sql,
                                                java.lang.Object[] args)
                                         throws PersistenceException
```
    Execute an arbitrary SQL query.
    It is the responsibility of the calling code to close the returned result set. In addition, if this method is called outside of a database transaction, the caller should optionally invoke beginTransaction() before calling this method and commit() or rollback() after fully processing the result set returned by this method. This will ensure a transaction is opened and properly closed if necessary.
    
    Specified by:
    
    executeSQLQuery in interface UnsafePersistence
    
    Parameters:
    
    sql - SQL query text.
    
    args - The query parameters.
    
    Returns:
    
    Result set produced by query.
    
    Throws:
    
    PersistenceException - if any error occurs executing the statement.
  - getSingleSQLResult
```
public <T> T getSingleSQLResult(java.lang.String sql,
                                java.lang.Object[] args)
                         throws PersistenceException
```
    Convenience method to retrieve a single result from a SQL statement. This is intended to be used for SQL statements that return only one result. Only the first result is checked; if there is more than one in the result set, all but the first are ignored.
    The result set and statement are closed immediately; no additional cleanup is required by the caller.
    
    Specified by:
    
    getSingleSQLResult in interface UnsafePersistence
    
    Parameters:
    
    sql - SQL statement to execute.
    
    args - Query substitution parameters, if any. If present, these should match the number of placeholders in the SQL statement. If not present, this argument may either be null or an empty array.
    
    Returns:
    
    The first (and presumably only) result returned by the SQL statement.
    
    Throws:
    
    PersistenceException - if any error occurs, either during the statement's execution, or when pushing or popping an implicit transaction.
  - executeSQLBatch
```
public void executeSQLBatch(java.util.List<java.lang.String> sql,
                            boolean noFlush)
                     throws PersistenceException
```
    Execute an arbitrary list of SQL statements in batch.
    
    Parameters:
    
    sql - List of SQL statements to execute in batch.
    
    noFlush - If true, flushing is bypassed.
    
    Throws:
    
    PersistenceException - if any error occurs executing the statements.
  - lock
```
public void lock(LockType lockType,
                 RecordIdentifier<java.lang.String> ident,
                 boolean update)
          throws LockUnavailableException
```
    Attempt to obtain the specified lock type on a particular record. If the lock cannot be obtained immediately, the current thread will block until the lock becomes available and it is obtained, unless the requested lock type is a "no-wait" lock.
    In the no-wait case, an exception is raised indicating that the lock is not available.
    The current thread continues normally once the lock is obtained.
    A lock currently held can be released by specifying LockType.NONE for the lockType parameter.
    The normal return of this method indicates that the lock request (or lack thereof) completed successfully, and that the current context now holds a lock of the requested type.
    NOTE: legacy persistence framework code should access this method only via a RecordLockContext method, unless simply testing whether a lock is available (i.e., update == false). This ensures that record locks shared across record buffers within a client context are managed properly. Non-legacy code may access this API directly.
    
    Parameters:
    
    lockType - Type of lock to be obtained. LockType.NONE is used to release an existing lock, and to continue with no lock.
    
    ident - ID which uniquely identifies the record being locked.
    
    update - true if the lock state for the current record should be updated; else false.
    
    Throws:
    
    LockUnavailableException - if a "no-wait" lock cannot be acquired immediately.
    
    See Also:
    
    getRecordLockContext()
  - lock
```
public void lock(LockType lockType,
                 RecordIdentifier<java.lang.String> ident,
                 boolean update,
                 long timeout)
          throws LockUnavailableException
```
    Attempt to obtain the specified lock type on a particular record. If the lock cannot be obtained immediately, the current thread will block until the lock becomes available and it is obtained, unless the requested lock type is a "no-wait" lock, or a positive timeout value is specified and that time elapses before the lock is acquired.
    In the no-wait case, an exception is raised indicating that the lock is not available. In the timeout case, an exception is raised indicating that the timeout period elapsed.
    The current thread continues normally once the lock is obtained.
    A lock currently held can be released by specifying LockType.NONE for the lockType parameter.
    The normal return of this method indicates that the lock request (or lack thereof) completed successfully, and that the current context now holds a lock of the requested type.
    NOTE: legacy persistence framework code should access this method only via a RecordLockContext method, unless simply testing whether a lock is available (i.e., update == false). This ensures that record locks shared across record buffers within a client context are managed properly. Non-legacy code may access this API directly.
    
    Parameters:
    
    lockType - Type of lock to be obtained. LockType.NONE is used to release an existing lock, and to continue with no lock.
    
    ident - ID which uniquely identifies the record being locked.
    
    update - true if the lock state for the current record should be updated; else false.
    
    timeout - Number of milliseconds to wait to acquire the requested lock type. Throws LockTimeoutException if this time elapses before the lock is acquired. Specify 0 to wait indefinitely for the lock. Ignored if lockType is NONE.
    
    Throws:
    
    LockTimeoutException - if a lock cannot be acquired within the positive timeout period specified.
    
    LockUnavailableException - if a "no-wait" lock cannot be acquired immediately.
    
    See Also:
    
    getRecordLockContext()
  - lockTable
```
public LockType lockTable(java.lang.String table,
                          LockType lockType,
                          boolean update)
                   throws LockUnavailableException
```
    Attempt to obtain the specified lock type on a table. If the lock cannot be obtained immediately, the current thread will block until the lock becomes available and is obtained, unless the requested lock type is a "no-wait" lock. In the latter case, an exception is raised, indicating that the lock is not available. The current thread continues once the lock is obtained.
    A lock currently held can be released by specifying LockType.NONE for the lockType parameter.
    Method returns previous lock type (so that calling code knows what to set it back to after bulk delete). The normal return of this method indicates that the lock request (or lack thereof) completed successfully, and that the current context now holds a lock of the requested type.
    
    Parameters:
    
    table - Table name.
    
    lockType - Type of lock to be obtained. LockType.NONE is used to release an existing lock, and to continue with no lock.
    
    update - true if the lock state for the current table should be updated; else false.
    
    Returns:
    
    previous lock type.
    
    Throws:
    
    LockUnavailableException - if a "no-wait" lock cannot be acquired immediately.
  - queryLock
```
public LockType queryLock(RecordIdentifier<java.lang.String> ident)
```
    Query the lock type currently held by the current context for the specified database record.
    This method will always return the non-NO_WAIT variants of a lock type. That is, even if the actual lock type is LockType.EXCLUSIVE_NO_WAIT or LockType.SHARE_NO_WAIT, the simpler types of LockType.EXCLUSIVE and LockType.SHARE, respectively, are returned. The lack of a lock returns LockType.NONE rather than null.
    
    Parameters:
    
    ident - ID which uniquely identifies the record being queried.
    
    Returns:
    
    The lock type currently held by the current context, never null.
  - nextPrimaryKey
```
public java.lang.Long nextPrimaryKey(java.lang.String table)
                              throws PersistenceException
```
    Obtain the next available primary key ID on a per-table basis.
    
    Parameters:
    
    table - Table for which next primary key will be returned.
    
    Returns:
    
    The next available ID for the given table.
    
    Throws:
    
    PersistenceException - if there is an error determining the next primary key ID.
    
    java.lang.IllegalStateException - if identity manager was not initialized.
  - save
```
public void save(Record dmo)
          throws PersistenceException
```
    Updates the existing record in the backing database session. It is assumed this method will be invoked only within a database transaction.
    
    Specified by:
    
    save in interface UnsafePersistence
    
    Parameters:
    
    dmo - DMO to be persisted.
    
    Throws:
    
    PersistenceException - if a problem occurs saving the object in the current session.
  - save
```
public void save(Record dmo,
                 java.lang.Long id)
          throws PersistenceException
```
    Persist the specified object to the backing database session, using the given ID. It is assumed this method will be invoked only within a database transaction.
    
    Specified by:
    
    save in interface UnsafePersistence
    
    Parameters:
    
    dmo - DMO to be persisted.
    
    id - Primary key to associate with the persisted DMO.
    
    Throws:
    
    PersistenceException - if a problem occurs saving the object in the current session.
  - save
```
public void save(Record dmo,
                 java.lang.Long id,
                 boolean updateDmoState)
          throws PersistenceException
```
    Persist the specified object to the backing database session, using the given ID. It is assumed this method will be invoked only within a database transaction.
    
    Specified by:
    
    save in interface UnsafePersistence
    
    Parameters:
    
    dmo - DMO to be persisted.
    
    id - Primary key to associate with the persisted DMO.
    
    updateDmoState - true to update the record state of the DMO. Should be false for non-legacy use cases).
    
    Throws:
    
    PersistenceException - if a problem occurs saving the object in the current session.
  - merge
```
@Deprecated
public Record merge(Record dmo)
                         throws PersistenceException
```
    Deprecated.
    
    Merges the state of the given object with the persistent object with the same identifier and returns the merged object.
    
    Parameters:
    
    dmo - DMO to merge.
    
    Returns:
    
    Merged DMO.
    
    Throws:
    
    PersistenceException - in error
  - getSession
```
public Session getSession()
```
    Get the ORM session associated with the current context, creating one if needed.
    
    Returns:
    
    ORM session for the current context.
  - cleanup
```
public void cleanup()
```
    Clean up the current context.
  - delete
```
public void delete(Record dmo)
            throws PersistenceException
```
    Delete the persisted object from the specified database.
    
    Specified by:
    
    delete in interface UnsafePersistence
    
    Parameters:
    
    dmo - Persistent entity to be deleted.
    
    Throws:
    
    PersistenceException - if a problem occurs deleting the object.
  - deleteOrUpdate
```
public int deleteOrUpdate(java.lang.String fql,
                          java.lang.Object[] values,
                          java.lang.String entity,
                          boolean noUndo)
                   throws PersistenceException
```
    Perform a bulk delete or update of all objects which meet the specified criteria. The criteria must indicate a single DMO type only.
    This action must take place within a database transaction, so this method attempts to begin one and commit it, if one is not already active.
    This method should only be used for temp-tables (where an exclusive lock is irrelevant) or in cases where the current context already holds locks on all records which meet the specified criteria.
    
    Specified by:
    
    deleteOrUpdate in interface UnsafePersistence
    
    Parameters:
    
    fql - Query string which defines the criteria which determine which records are deleted or updated.
    
    values - Query substitution parameters, if any.
    
    entity - Entity associated with the FQL statement, if any. Used to check whether a session flush is needed before execution.
    
    noUndo - true if this operation is being performed on a NO-UNDO temp-table, else false.
    
    Returns:
    
    The number of entities deleted or updated.
    
    Throws:
    
    PersistenceException - if a problem occurs performing the bulk delete or update.
  - beginTransaction
```
public boolean beginTransaction()
                         throws PersistenceException
```
    Make sure a (new) transaction instance is created and stored in the local context. A new database session is created if one does not already exist in the current context.
    
    Returns:
    
    true if a new transaction was begun; false if there was already an active transaction.
    
    Throws:
    
    PersistenceException - if there is an error beginning the new transaction.
  - commit
```
public void commit()
            throws PersistenceException
```
    Commit the current database transaction and close the current session. If the transaction cannot be committed, roll it back and raise an error.
    
    Specified by:
    
    commit in interface UnsafePersistence
    
    Throws:
    
    java.lang.IllegalStateException - if no transaction is active in the current session; this represents a programming error.
    
    PersistenceException - if there is an error committing the transaction.
  - rollback
```
public void rollback()
              throws PersistenceException
```
    Roll back the current database transaction and close the current session. If the transaction cannot be rolled back, raise an error.
    
    Specified by:
    
    rollback in interface UnsafePersistence
    
    Throws:
    
    java.lang.IllegalStateException - if no transaction is active in the current session; this represents a programming error.
    
    PersistenceException - if there is an error rolling back the transaction.
  - flush
```
public void flush()
           throws PersistenceException
```
    Flush the current session, which synchronizes the in-memory state of DMOs to the database.
    This request bypasses the current client context's setting as to whether flushing is enabled.
    It is expected that this method will only be called within an active transaction. If no session is active, this method will raise an exception.
    
    Specified by:
    
    flush in interface UnsafePersistence
    
    Throws:
    
    java.lang.IllegalStateException - if no session currently is active.
    
    PersistenceException - if an error occurs during session flush.
  - isTransactionOpen
```
public boolean isTransactionOpen()
```
    Indicate whether an explicit, database-level transaction currently is open.
    
    Returns:
    
    true if open, else false.
  - message
```
public java.lang.String message(java.lang.String message)
```
    Format the given message text by prepending a descriptor including the user's current context and the physical name of the database.
    
    Parameters:
    
    message - Core message
    
    Returns:
    
    Descriptor.
  - getRecordLockContext
```
public RecordLockContext getRecordLockContext()
```
    Get the record lock context associated with the current client session. Although is method is public to allow access from other internal packages, it is not meant for use outside the persist package and its sub-packages.
    
    Returns:
    
    Record lock context for the current session.
  - supportsLazyQueryResultsMode
```
public boolean supportsLazyQueryResultsMode()
```
    Check if we can retrieve data lazily from the underlying database.
    
    Returns:
    
    true if we can use database cursors to iterate through the records
  - getCodepage
```
public java.lang.String getCodepage()
```
    Use the dialect to obtain the code page (character encoding) of this connection.
    
    Returns:
    
    the database's CP, if it can be retrieved in a dialect-specific manner.
  - getCollation
```
public java.lang.String getCollation()
```
    Use the dialect to obtain the collation of this connection.
    
    Returns:
    
    the database's collation, if it can be retrieved in a dialect-specific manner.
  - allowDBUniqueCheck
```
public boolean allowDBUniqueCheck()
```
    Check if we can skip the index server-validation.
    
    Returns:
    
    true If the dialect has support for unique index validation, meaning we can skip this process in the server.
  - setUnsafe
```
public void setUnsafe(boolean value)
```
    Decide whether this persistence context is unsafe or not.
    
    Parameters:
    
    value - If true the persistence will run in unsafe mode and in safe mode if false.
  - initializeInstance
```
protected void initializeInstance()
```
    Initialize the helper objects to which this object delegates certain service requests.
  - createLockManager
```
protected LockManager<java.lang.String> createLockManager()
                                                   throws java.lang.ReflectiveOperationException
```
    Create and initialize the lock manager to be used with this instance of persistence services for the given database. The lock manager implementation to use is read from the directory. The default if no entry is found is the InMemoryLockManager.
    
    Returns:
    
    Lock manager instance.
    
    Throws:
    
    java.lang.IllegalAccessException - if the LockManager concrete implementation's default constructor cannot be accessed.
    
    java.lang.InstantiationException - if the LockManager concrete implementation cannot be instantiated.
    
    java.lang.ClassNotFoundException - if the LockManager concrete implementation class cannot be located.
    
    java.lang.IllegalArgumentException - if lock metadata is used by the current application, but no lock table updater is found for the current database.
    
    java.lang.ReflectiveOperationException
  - createIdentityManager
```
protected IdentityManager createIdentityManager()
                                         throws java.lang.ReflectiveOperationException
```
    Create and initialize the identity manager to be used with this instance of persistence services for the given database. The identity manager implementation to use is read from the directory. The default if no entry is found is DEFAULT_IDENTITY_MANAGER.
    
    Returns:
    
    Identity manager instance or null if given database is temporary.
    
    Throws:
    
    java.lang.IllegalAccessException - if the IdentityManager concrete implementation's default constructor cannot be accessed.
    
    java.lang.InstantiationException - if the IdentityManager concrete implementation cannot be instantiated.
    
    java.lang.ClassNotFoundException - if the IdentityManager concrete implementation class cannot be located.
    
    java.lang.ReflectiveOperationException
  - isTemporary
```
boolean isTemporary()
```
    Determine whether this persistence object is for a temporary table database.
    
    Returns:
    
    true if temporary, else false.
  - beginTransaction
```
boolean beginTransaction(SavepointManager savepointManager)
                  throws PersistenceException
```
    Throws:
    
    PersistenceException
  - beginTransaction
```
boolean beginTransaction(Persistence.Context local,
                         SavepointManager savepointManager)
                  throws PersistenceException
```
    Begin a new transaction and store the instance in the local context. A new database session is created if one does not already exist in the current context.
    
    Parameters:
    
    local - User context.
    
    Returns:
    
    true if a new transaction was begun; false if there was already an active transaction.
    
    Throws:
    
    PersistenceException - if there is an error beginning the new transaction.
  - commit
```
void commit(Persistence.Context local)
     throws PersistenceException
```
    Commit the current database transaction and close the current session. If the transaction cannot be committed, roll it back and raise an error.
    
    Parameters:
    
    local - User context.
    
    Throws:
    
    java.lang.IllegalStateException - if no transaction is active in the current session; this represents a programming error.
    
    PersistenceException - if there is an error committing the transaction.
  - rollback
```
void rollback(Persistence.Context local)
       throws PersistenceException
```
    Roll back the current database transaction and close the current session. If the transaction cannot be rolled back, raise an error.
    
    Parameters:
    
    local - User context.
    
    Throws:
    
    java.lang.IllegalStateException - if no transaction is active in the current session; this represents a programming error.
    
    PersistenceException - if there is an error rolling back the transaction.
  - executeSQLBatch
```
public void executeSQLBatch(java.lang.String sql,
                            java.util.function.Supplier<java.lang.Object[]> getArgs)
                     throws PersistenceException
```
    Execute a batch SQL statement, while the argument supplier returns non-null values.
    
    Specified by:
    
    executeSQLBatch in interface UnsafePersistence
    
    Parameters:
    
    sql - The SQL statement to execute.
    
    getArgs - The argument supplier.
    
    Throws:
    
    PersistenceException
  - executeSQLBatch
```
public void executeSQLBatch(Persistence.Context local,
                            java.util.List<java.lang.String> sql,
                            boolean noFlush)
                     throws PersistenceException
```
    Execute an arbitrary list of standard JDBC statements in batch.
    
    Specified by:
    
    executeSQLBatch in interface UnsafePersistence
    
    Parameters:
    
    local - Persistence context.
    
    sql - List of SQL statements to execute in batch.
    
    noFlush - If true, flushing is bypassed.
    
    Throws:
    
    PersistenceException - if any error occurs executing the statements.
  - executeSQL
```
public int executeSQL(java.lang.String sql,
                      java.lang.Object[] args,
                      boolean noUndo)
               throws PersistenceException
```
    Execute an arbitrary SQL statement which does not produce a result set.
    
    Specified by:
    
    executeSQL in interface UnsafePersistence
    
    Parameters:
    
    sql - SQL statement text.
    
    args - The statement arguments.
    
    noUndo - If true, the update is on a NO-UNDO temp-table.
    
    Returns:
    
    The number of entities updated or deleted, or -1 if the statement did not complete normally.
    
    Throws:
    
    PersistenceException - if any error occurs executing the statement.
  - enableTransactionTrace
```
void enableTransactionTrace(boolean enable)
```
    Set enable mode for transaction tracing in the current context.
    
    Parameters:
    
    enable - true to enable; false to disable.
  - getBeginTxTrace
```
java.lang.Throwable getBeginTxTrace()
```
    Retrieve trace information about where the current transaction, if any, was started. This mode must be enabled with enableTransactionTrace(boolean), or this method always will return null.
    
    Returns:
    
    Throwable containing stack trace from last transaction start, or null.
  - shareLockTableUpdater
```
void shareLockTableUpdater(Database database)
                    throws PersistenceException
```
    If this object is associated with a metadata database, set this object's lock table updater to be the same as that of the Persistence instance associated with the given, primary database.
    
    Parameters:
    
    database - Primary database presumably associated with the metadata database represented by this object.
    
    Throws:
    
    PersistenceException - if this object is not associated with a metadata database or the given database is not a primary database.
  - getContext
```
Persistence.Context getContext()
```
    Get the context for the current user session.
    NOTE: this method is package private and should remain so. It is meant to allow optimized calls to certain frequently used methods of this class, in order to avoid the overhead of an unnecessary context local lookup.
    
    Returns:
    
    User context.
  - evict
```
void evict(Persistence.Context local,
           Record dmo)
```
    Evict the given DMO from the current session immediately. If there is no existing session, this method is a no-op.
    
    Parameters:
    
    local - Persistence context.
    
    dmo - Data model object to be evicted.
  - evict
```
void evict(java.util.Collection<Record> evictees)
```
    Evict a collection of DMOs from the current ORM session. If there is no existing session, this method is a no-op.
    
    Parameters:
    
    evictees - Collection of DMOs to be evicted.
  - registerSessionListener
```
void registerSessionListener(SessionListener listener,
                             SessionListener.Scope scope)
```
    Register a SessionListener to receive session life cycle event notifications. The listener will be deregistered according to the following rules at the earlier of:
    - the point at which it is collected by the garbage collector (once business logic no longer strongly references it); or
    - the end of the scope indicated by the scope parameter:
      
      ENCLOSING_EXTERNAL_SCOPE
      CURRENT_SCOPE
      NEXT_EXTERNAL_SCOPE
    Parameters:
    
    listener - Session listener to be registered.
    
    scope - SessionListener.Scope enum indicating the scope to which this listener should be registered. When the scope ends, the listener is deregistered as described above.
  - deregisterSessionListener
```
void deregisterSessionListener(SessionListener listener)
```
    Deregister a session listener when it no longer needs to receive session life cycle events.
    
    Parameters:
    
    listener - Listener to deregister.
  - uniqueResultViolation
```
void uniqueResultViolation(RecordBuffer buffer,
                           java.lang.Exception exc)
                    throws PersistenceException
```
    Process an error condition in which a unique result should have been found, but multiple results occurred.
    
    Parameters:
    
    buffer - Record buffer associated with the failed query.
    
    exc - Optional root cause exception.
    
    Throws:
    
    PersistenceException - always; indicates the nature of the error.
  - flush
```
void flush(boolean clear)
    throws PersistenceException
```
    Flush the current session, which synchronizes the in-memory state of DMOs to the database. Optionally, the session is cleared as well. This request bypasses the current client context's setting as to whether flushing is enabled.
    It is expected that this method will only be called within an active transaction. If no session is active, this method will raise an exception.
    
    Parameters:
    
    clear - true to clear the session (used during bulk inserts or updates to prevent a progressive memory leak) after the flush.
    
    Throws:
    
    PersistenceException - if no session currently is active or if an error occurs during session flush.
  - flush
```
void flush(Persistence.Context local,
           Session session,
           boolean clear)
    throws PersistenceException
```
    Flush the current session, which synchronizes the in-memory state of DMOs to the database. Optionally, the session is cleared as well. This request bypasses the current client context's setting as to whether flushing is enabled.
    
    Parameters:
    
    local - Context-local state.
    
    session - ORM session
    
    clear - true to clear the session (used during bulk inserts or updates to prevent a progressive memory leak) after the flush.
    
    Throws:
    
    PersistenceException - if an error occurs during session flush.
  - preprocessQueryParameters
```
private void preprocessQueryParameters(java.lang.Object[] args)
```
    Perform special handling on query substitution parameters to avoid errors during query execution. This entails:
    - Trimming all trailing spaces, tabs, line feeds, and carriage returns from any parameter of type character. Any parameter affected is replaced with a new character instance at the same index position within args.
    - Clipping out of bounds date values to the range supported by the backing database's implementation of a date data type. Any parameter affected is replaced with a new date instance at the same index position within args.
    Note: this method has special processing for null bytes embedded in character variables. The text of the variable is truncated starting at the first embedded null byte. This means that the resulting substitution parameters are guaranteed to never include null bytes.
    Parameters:
    
    args - Array of query substitution parameters or null if none.
  - getQuery
```
private Query getQuery(Persistence.Context local,
                       java.lang.String fql,
                       int maxResults,
                       int startOffset,
                       DataRelation relation,
                       java.lang.Object[] values)
                throws PersistenceException
```
    Get or create a query for the given FQL query string. A cached query is used if it exists.
    
    Parameters:
    
    local - Context-local state.
    
    fql - FQL query string.
    
    maxResults - The maximum number of results to be returned by the query. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    Returns:
    
    FQL query object.
    
    Throws:
    
    PersistenceException - if there was an error creating an ORM session.
  - getQuery
```
private Query getQuery(Persistence.Context local,
                       java.lang.String fql,
                       int maxResults,
                       int startOffset,
                       DataRelation relation,
                       java.lang.Object[] values,
                       boolean lazyMode)
                throws PersistenceException
```
    Get or create a query for the given FQL query string. A cached query is used if it exists.
    
    Parameters:
    
    local - Context-local state.
    
    fql - FQL query string.
    
    maxResults - The maximum number of results to be returned by the query. If this value is non-positive, no upper limit is applied.
    
    startOffset - The 0-based offset of the first record to retrieve. If this value is non-positive, an offset of 0 is used by default.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    values - Substitution values for the query. If none, this should be an empty array.
    
    lazyMode - Flag that indicates whether the query should be executed in a lazy manner.
    
    Returns:
    
    FQL query object.
    
    Throws:
    
    PersistenceException - if there was an error creating an ORM session.
  - handleException
```
private void handleException(java.lang.String message,
                             PersistenceException exc)
                      throws PersistenceException
```
    Raise a STOP condition, if the given exception represents a catastrophic, JDBC failure; else throw a PersistenceException.
    
    Parameters:
    
    message - Error text for the exception.
    
    exc - A persistence exception which may or may not represent an unrecoverable database error.
    
    Throws:
    
    StopConditionException - if the error is unrecoverable.
    
    PersistenceException - if the error is likely recoverable.
  - handleException
```
private void handleException(Persistence.Context local,
                             PersistenceException exc,
                             java.lang.String message)
                      throws PersistenceException
```
    Provides a template for handling PersistenceException exceptions. Depending on context a more suitable exception will be thrown. A rollback for the local context will also be initiated and a log message will be written.
    
    Parameters:
    
    local - The client context.
    
    exc - A persistence exception which may or may not represent an unrecoverable database error.
    
    message - The message which will be written as a log. If null no message will be displayed.
    
    Throws:
    
    StopConditionException - if the error is unrecoverable.
    
    PersistenceException - if the error is likely recoverable.

Class Persistence

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ID_GEN_SEQUENCE

LOG

DEFAULT_LOCK_MANAGER

DEFAULT_IDENTITY_MANAGER

NOT_DETECTED_YET

foreignKeysEnabled

active

context

database

isMultiTenancyEnabled

dialect

codepage

collation

temporary

allowDBUniqueCheck

hashCode

dmoVersion

lockManager

lockTableUpdater

identityManager

Constructor Detail

Persistence

Method Detail

get

initialize

isActive

preprocessQueryParameter

isForeignKeysEnabled

reportUDFVersion

hashCode

equals

getDialect

getDatabase

getLockManager

getIdentityManager

scroll

scroll

scroll

scroll

scroll

scroll

scroll

scroll

scroll

scroll

list

list

list

list

load

load

load

quickLoad

quickLoad

executeSQL

executeSQL

executeSQLQuery

getSingleSQLResult

executeSQLBatch

lock

lock

lockTable

queryLock

nextPrimaryKey

save

save

save

merge

getSession

cleanup

delete

deleteOrUpdate

beginTransaction