BasicEntityPersister

Initializes a new BasicEntityPersister that uses the given EntityManager and persists instances of the class described by the given ClassMetadata descriptor.

Gets the ResultSetMapping used for hydration.

Adds an entity to the queued insertions.

The entity remains queued until {@link executeInserts} is invoked.

Get all queued inserts.

Executes all queued entity insertions and returns any generated post-insert identifiers that were created as a result of the insertions.

If no inserts are queued, invoking this method is a NOOP.

Retrieves the default version value which was created by the preceding INSERT statement and assigns it back in to the entities version field.

Fetches the current version value of a versioned entity.

Updates a managed entity. The entity is updated according to its current changeset in the running UnitOfWork. If there is no changeset, nothing is updated.

Performs an UPDATE statement for an entity on a specific table.

The UPDATE can optionally be versioned, which requires the entity to have a version field.

Deletes a managed entity.

The entity to delete must be managed and have a persistent identifier. The deletion happens instantaneously.

Subclasses may override this method to customize the semantics of entity deletion.

Prepares the changeset of an entity for database insertion (UPDATE).

The changeset is obtained from the currently running UnitOfWork.

During this preparation the array that is passed as the second parameter is filled with => pairs, grouped by table name.

Example: array( 'foo_table' => array('column1' => 'value1', 'column2' => 'value2', ...), 'bar_table' => array('columnX' => 'valueX', 'columnY' => 'valueY', ...), ... )

Prepares the data changeset of a managed entity for database insertion (initial INSERT).

The changeset of the entity is obtained from the currently running UnitOfWork.

The default insert data preparation is the same as for updates.

Gets the name of the table that owns the column the given field is mapped to.

The default implementation in BasicEntityPersister always returns the name of the table the entity type of this persister is mapped to, since an entity is always persisted to a single table with a BasicEntityPersister.

Loads an entity by a list of field criteria.

Loads an entity by identifier.

Loads an entity of this persister's mapped class as part of a single-valued association from another entity.

Refreshes a managed entity.

Count entities (optionally filtered by a criteria)

Loads Entities matching the given Criteria object.

Expands Criteria Parameters by walking the expressions and grabbing all parameters and types from it.

Loads a list of entities by a list of field criteria.

Gets (sliced or full) elements of the given collection.

Loads a collection of entities of a many-to-many association.

Gets the SELECT SQL to select one or more entities by a set of field criteria.

Get the COUNT SQL to count entities (optionally based on a criteria)

Gets the ORDER BY SQL snippet for ordered collections.

Gets the SQL fragment with the list of columns to select when querying for an entity in this persister.

Subclasses should override this method to alter or change the select column list SQL fragment. Note that in the implementation of BasicEntityPersister the resulting SQL fragment is generated only once and cached in {@link selectColumnListSql}. Subclasses may or may not do the same.

Gets the SQL join fragment used when selecting entities from an association.

Gets the SQL join fragment used when selecting entities from a many-to-many association.

Gets the list of columns to put in the INSERT SQL statement.

Subclasses should override this method to alter or change the list of columns placed in the INSERT statements used by the persister.

Gets the SQL snippet of a qualified column name for the given field name.

Gets the SQL table alias for the given class name.

Locks all rows of this entity matching the given criteria with the specified pessimistic lock mode.

Gets the FROM and optionally JOIN conditions to lock the entity managed by this persister.

Gets the Select Where Condition from a Criteria object.

Gets the SQL WHERE condition for matching a field with a given value.

Gets the conditional SQL fragment used in the WHERE clause when selecting entities in this persister.

Subclasses are supposed to override this method if they intend to change or alter the criteria by which entities are selected.

Returns an array with (sliced or full list) of elements in the specified collection.

Loads a collection of entities in a one-to-many association.

Expands the parameters from the given criteria and use the correct binding types if found.

Checks whether the given managed entity exists in the database.

Generates the appropriate join SQL for the given join column.

{@inheritdoc}

Generates the filter SQL for a given entity and table alias.

Switches persister context according to current query offset/limits

This is due to the fact that to-many associations cannot be fetch-joined when a limit is involved