org.springframework.data.jdbc.core.convert

## Interface DataAccessStrategy

All Superinterfaces:
  RelationResolver

All Known Implementing Classes:
  CascadingDataAccessStrategy, DefaultDataAccessStrategy, DelegatingDataAccessStrategy, MyBatisDataAccessStrategy

    public interface DataAccessStrategy
    extends RelationResolver

Abstraction for accesses to the database that should be implementable with a single SQL statement per method and relates to a single entity as opposed to `JdbcAggregateOperations` which provides interactions related to complete aggregates.

Author:
  Jens Schauder, Tyler Van Gorder, Milan Milanov, Myeonghyeon Lee

### Method Summary

All Methods Instance Methods Abstract Methods
`<T> void` `acquireLockAll(LockMode lockMode, Class<T> domainType)` Acquire a lock on all aggregates of the given domain type.
`<T> void` `acquireLockById(Object id, LockMode lockMode, Class<T> domainType)` Acquire a lock on the aggregate specified by id.
`long` `count(Class<?> domainType)` Counts the rows in the table representing the given domain type.
`void` `delete(Object id, Class<?> domainType)` Deletes a single row identified by the id, from the table identified by the domainType.
`void` `delete(Object rootId, PersistentPropertyPath<RelationalPersistentProperty> propertyPath)` Deletes all entities reachable via propertyPath from the instance identified by rootId.
`<T> void` `deleteAll(Class<T> domainType)` Deletes all entities of the given domain type.
`void` `deleteAll(PersistentPropertyPath<RelationalPersistentProperty> propertyPath)` Deletes all entities reachable via propertyPath from any instance.
`<T> void` `deleteWithVersion(Object id, Class<T> domainType, Number previousVersion)` Deletes a single entity from the database and enforce optimistic record locking using the version property.
`<T> boolean` `existsById(Object id, Class<T> domainType)` returns if a row with the given id exists for the given type.
`<T> Iterable<T>` `findAll(Class<T> domainType)` Loads all entities of the given type.
`<T> Iterable<T>` `findAll(Class<T> domainType, Pageable pageable)` Loads all entities of the given type, paged and sorted.
`<T> Iterable<T>` `findAll(Class<T> domainType, Sort sort)` Loads all entities of the given type, sorted.
`<T> Iterable<T>` `findAllById(Iterable<?> ids, Class<T> domainType)` Loads all entities that match one of the ids passed as an argument.
`Iterable<Object>` `findAllByPath(Identifier identifier, PersistentPropertyPath<? extends RelationalPersistentProperty> path)` Finds all entities reachable via path.
`<T> T` `findById(Object id, Class<T> domainType)` Loads a single entity identified by type and id.
`<T> Object` `insert(T instance, Class<T> domainType, Identifier identifier)` Inserts a the data of a single entity.
`<T> boolean` `update(T instance, Class<T> domainType)` Updates the data of a single entity in the database.
`<T> boolean` `updateWithVersion(T instance, Class<T> domainType, Number previousVersion)` Updates the data of a single entity in the database and enforce optimistic record locking using the `previousVersion` property.

### Method Detail

#### insert

    @Nullable
    <T> Object insert(T instance,
                                Class<T> domainType,
                                Identifier identifier)

Inserts a the data of a single entity. Referenced entities don't get handled.

Type Parameters:
  `T` - the type of the instance.
Parameters:
  `instance` - the instance to be stored. Must not be `null`.
  `domainType` - the type of the instance. Must not be `null`.
  `identifier` - information about data that needs to be considered for the insert but which is not part of the entity. Namely references back to a parent entity and key/index columns for entities that are stored in a `Map` or `List`.
Returns:
  the id generated by the database if any.
Since:
  1.1

#### update

    <T> boolean update(T instance,
                       Class<T> domainType)

Updates the data of a single entity in the database. Referenced entities don't get handled.

Type Parameters:
  `T` - the type of the instance to save.
Parameters:
  `instance` - the instance to save. Must not be `null`.
  `domainType` - the type of the instance to save. Must not be `null`.
Returns:
  whether the update actually updated a row.

#### updateWithVersion

    <T> boolean updateWithVersion(T instance,
                                  Class<T> domainType,
                                  Number previousVersion)

Updates the data of a single entity in the database and enforce optimistic record locking using the `previousVersion` property. Referenced entities don't get handled.

The statement will be of the form : `UPDATE … SET … WHERE ID = :id and VERSION_COLUMN = :previousVersion` and throw an optimistic record locking exception if no rows have been updated.

Type Parameters:
  `T` - the type of the instance to save.
Parameters:
  `instance` - the instance to save. Must not be `null`.
  `domainType` - the type of the instance to save. Must not be `null`.
  `previousVersion` - The previous version assigned to the instance being saved.
Returns:
  whether the update actually updated a row.
Throws:
  `OptimisticLockingFailureException` - if the update fails to update at least one row assuming the the optimistic locking version check failed.
Since:
  2.0

#### delete

    void delete(Object id,
                Class<?> domainType)

Deletes a single row identified by the id, from the table identified by the domainType. Does not handle cascading deletes.

The statement will be of the form : `DELETE FROM … WHERE ID = :id and VERSION_COLUMN = :version` and throw an optimistic record locking exception if no rows have been updated.

Parameters:
  `id` - the id of the row to be deleted. Must not be `null`.
  `domainType` - the type of entity to be deleted. Implicitly determines the table to operate on. Must not be `null`.

#### deleteWithVersion

    <T> void deleteWithVersion(Object id,
                               Class<T> domainType,
                               Number previousVersion)

Deletes a single entity from the database and enforce optimistic record locking using the version property. Does not handle cascading deletes.

Parameters:
  `id` - the id of the row to be deleted. Must not be `null`.
  `domainType` - the type of entity to be deleted. Implicitly determines the table to operate on. Must not be `null`.
  `previousVersion` - The previous version assigned to the instance being saved.
Throws:
  `OptimisticLockingFailureException` - if the update fails to update at least one row assuming the the optimistic locking version check failed.
Since:
  2.0

#### delete

    void delete(Object rootId,
                PersistentPropertyPath<RelationalPersistentProperty> propertyPath)

Deletes all entities reachable via propertyPath from the instance identified by rootId.

Parameters:
  `rootId` - Id of the root object on which the propertyPath is based. Must not be `null`.
  `propertyPath` - Leading from the root object to the entities to be deleted. Must not be `null`.

#### deleteAll

    <T> void deleteAll(Class<T> domainType)

Deletes all entities of the given domain type.

Type Parameters:
  `T` - type of the domain type.
Parameters:
  `domainType` - the domain type for which to delete all entries. Must not be `null`.

#### deleteAll

    void deleteAll(PersistentPropertyPath<RelationalPersistentProperty> propertyPath)

Deletes all entities reachable via propertyPath from any instance.

Parameters:
  `propertyPath` - Leading from the root object to the entities to be deleted. Must not be `null`.

#### acquireLockById

    <T> void acquireLockById(Object id,
                             LockMode lockMode,
                             Class<T> domainType)

Acquire a lock on the aggregate specified by id.

Parameters:
  `id` - the id of the entity to load. Must not be `null`.
  `lockMode` - the lock mode for select. Must not be `null`.
  `domainType` - the domain type of the entity. Must not be `null`.

#### acquireLockAll

    <T> void acquireLockAll(LockMode lockMode,
                            Class<T> domainType)

Acquire a lock on all aggregates of the given domain type.

Parameters:
  `lockMode` - the lock mode for select. Must not be `null`.
  `domainType` - the domain type of the entity. Must not be `null`.

#### count

    long count(Class<?> domainType)

Counts the rows in the table representing the given domain type.

Parameters:
  `domainType` - the domain type for which to count the elements. Must not be `null`.
Returns:
  the count. Guaranteed to be not `null`.

#### findById

    @Nullable
    <T> T findById(Object id,
                             Class<T> domainType)

Loads a single entity identified by type and id.

Type Parameters:
  `T` - the type of the entity.
Parameters:
  `id` - the id of the entity to load. Must not be `null`.
  `domainType` - the domain type of the entity. Must not be `null`.
Returns:
  Might return `null`.

#### findAll

    <T> Iterable<T> findAll(Class<T> domainType)

Loads all entities of the given type.

Type Parameters:
  `T` - the type of entities to load.
Parameters:
  `domainType` - the type of entities to load. Must not be `null`.
Returns:
  Guaranteed to be not `null`.

#### findAllById

    <T> Iterable<T> findAllById(Iterable<?> ids,
                                Class<T> domainType)

Loads all entities that match one of the ids passed as an argument. It is not guaranteed that the number of ids passed in matches the number of entities returned.

Type Parameters:
  `T` - type of entities to load.
Parameters:
  `ids` - the Ids of the entities to load. Must not be `null`.
  `domainType` - the type of entities to load. Must not be `null`.
Returns:
  the loaded entities. Guaranteed to be not `null`.

#### findAllByPath

    Iterable<Object> findAllByPath(Identifier identifier,
                                   PersistentPropertyPath<? extends RelationalPersistentProperty> path)

Description copied from interface: `RelationResolver`
Finds all entities reachable via path.

Specified by:
  `findAllByPath` in interface `RelationResolver`
Parameters:
  `identifier` - the combination of Id, map keys and list indexes that identify the parent of the entity to be loaded. Must not be null.
  `path` - the path from the aggregate root to the entities to be resolved. Must not be null.
Returns:
  guaranteed to be not null.

#### existsById

    <T> boolean existsById(Object id,
                           Class<T> domainType)

returns if a row with the given id exists for the given type.

Type Parameters:
  `T` - the type of the entity.
Parameters:
  `id` - the id of the entity for which to check. Must not be `null`.
  `domainType` - the type of the entity to check for. Must not be `null`.
Returns:
  `true` if a matching row exists, otherwise `false`.

#### findAll

    <T> Iterable<T> findAll(Class<T> domainType,
                            Sort sort)

Loads all entities of the given type, sorted.

Type Parameters:
  `T` - the type of entities to load.
Parameters:
  `domainType` - the type of entities to load. Must not be `null`.
  `sort` - the sorting information. Must not be `null`.
Returns:
  Guaranteed to be not `null`.
Since:
  2.0

#### findAll

    <T> Iterable<T> findAll(Class<T> domainType,
                            Pageable pageable)

Loads all entities of the given type, paged and sorted.

Type Parameters:
  `T` - the type of entities to load.
Parameters:
  `domainType` - the type of entities to load. Must not be `null`.
  `pageable` - the pagination information. Must not be `null`.
Returns:
  Guaranteed to be not `null`.
Since:
  2.0