TransactionalDataManager (CUBA 7.2 API)

All Known Implementing Classes:: TransactionalDataManagerBean

public interface TransactionalDataManager

Similar to DataManager but joins an existing transaction.

Use this bean in the middleware logic to perform some operations in one transaction, for example:

      @Inject
      private TransactionalDataManager txDataManager;

      @Transactional
      private void transfer(Id<Account, UUID> acc1Id, Id<Account, UUID> acc2Id, Long amount) {
          Account acc1 = txDataManager.load(acc1Id).one();
          Account acc2 = txDataManager.load(acc2Id).one();
          acc1.setBalance(acc1.getBalance() - amount);
          acc2.setBalance(acc2.getBalance() + amount);
          txDataManager.save(acc1);
          txDataManager.save(acc2);
      }

Transactions can also be created/committed programmatically using the Transactions interface which is available via transactions() method.

Field Summary

Fields
Modifier and Type Field and Description

static java.lang.String NAME

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`NAME`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`TransactionalAction`	`commitAction(java.util.function.Supplier<CommitContext> supplier)` Entry point to TransactionalAction API.
`<T extends Entity> T`	`create(java.lang.Class<T> entityClass)` Creates a new entity instance.
`<T extends BaseGenericIdEntity<K>,K> T`	`getReference(java.lang.Class<T> entityClass, K id)` Returns an entity instance which can be used as a reference to an object which exists in the database.
`default <T extends BaseGenericIdEntity<K>,K> T`	`getReference(Id<T,K> entityId)` Returns an entity instance which can be used as a reference to an object which exists in the database.
`<E extends Entity<K>,K> FluentLoader<E,K>`	`load(java.lang.Class<E> entityClass)` Entry point to the fluent API for loading entities.
`<E extends Entity<K>,K> FluentLoader.ById<E,K>`	`load(Id<E,K> entityId)` Entry point to the fluent API for loading entities.
`<E extends Entity> E`	`load(LoadContext<E> context)` Loads a single entity instance.
`<E extends Entity> java.util.List<E>`	`loadList(LoadContext<E> context)` Loads collection of entity instances.
`<T> FluentValueLoader<T>`	`loadValue(java.lang.String queryString, java.lang.Class<T> valueClass)` Entry point to the fluent API for loading a single scalar value.
`FluentValuesLoader`	`loadValues(java.lang.String queryString)` Entry point to the fluent API for loading scalar values.
`java.util.List<KeyValueEntity>`	`loadValues(ValueLoadContext context)` Loads list of key-value pairs.
`void`	`remove(Entity entity)` Removes the entity instance from the data store.
`void`	`remove(Entity entity, boolean softDeletion)` Removes the entity instance from the data store.
`default <T extends BaseGenericIdEntity<K>,K> void`	`remove(Id<T,K> entityId)` Removes the entity instance from the data store by its id.
`<E extends Entity> E`	`save(E entity)` Saves the entity to the data store.
`EntitySet`	`save(Entity... entities)` Saves entity instances to the data store.
`<E extends Entity> E`	`save(E entity, java.lang.String viewName)` Saves the entity to the data store.
`<E extends Entity> E`	`save(E entity, View view)` Saves the entity to the data store.
`TransactionalDataManager`	`secure()` By default, DataManager does not apply security restrictions on entity operations and attributes, only row-level constraints take effect.
`Transactions`	`transactions()` Returns an entry point to programmatic transaction control.

- Field Detail
  - NAME
```
static final java.lang.String NAME
```
    See Also:
    
    Constant Field Values
- Method Detail
  - load
```
<E extends Entity<K>,K> FluentLoader<E,K> load(java.lang.Class<E> entityClass)
```
    Entry point to the fluent API for loading entities.
    Usage examples:
```
 Customer customer = txDataManager.load(Customer.class).id(someId).one();

 List<Customer> customers = txDataManager.load(Customer.class)
      .query("select c from sample$Customer c where c.name = :name")
      .parameter("name", "Smith")
      .view("customer-view")
      .list();
 
```
    Parameters:
    
    entityClass - class of entity that needs to be loaded
  - load
```
<E extends Entity<K>,K> FluentLoader.ById<E,K> load(Id<E,K> entityId)
```
    Entry point to the fluent API for loading entities.
    Usage example:
```
 Customer customer = txDataManager.load(customerId).view("with-grade").one();
 
```
    Parameters:
    
    entityId - Id of entity that needs to be loaded
  - loadValues
```
FluentValuesLoader loadValues(java.lang.String queryString)
```
    Entry point to the fluent API for loading scalar values.
    Usage examples:
```
 List<KeyValueEntity> customerDataList = txDataManager.loadValues(
          "select c.name, c.status from sample$Customer c where c.name = :n")
      .properties("custName", "custStatus")
      .parameter("name", "Smith")
      .list();

 KeyValueEntity customerData = txDataManager.loadValues(
          "select c.name, count(c) from sample$Customer c group by c.name")
      .properties("custName", "custCount")
      .one();
 
```
    Parameters:
    
    queryString - query string
  - loadValue
```
<T> FluentValueLoader<T> loadValue(java.lang.String queryString,
                                   java.lang.Class<T> valueClass)
```
    Entry point to the fluent API for loading a single scalar value.
    Terminal methods of this API (list, one and optional) return a single value from the first column of the query result set. You should provide the expected type of this value in the second parameter. Number types will be converted appropriately, so for example if the query returns Long and you expected Integer, the returned value will be automatically converted from Long to Integer.
    Usage examples:
```
 Long customerCount = txDataManager.loadValue(
          "select count(c) from sample$Customer c", Long.class).one();
 
```
    Parameters:
    
    queryString - query string
    
    valueClass - type of the returning value
  - load
```
@Nullable
 @CheckReturnValue
<E extends Entity> E load(LoadContext<E> context)
```
    Loads a single entity instance.
    
    Parameters:
    
    context - LoadContext object, defining what and how to load
    
    Returns:
    
    the loaded detached object, or null if not found
  - loadList
```
@CheckReturnValue
<E extends Entity> java.util.List<E> loadList(LoadContext<E> context)
```
    Loads collection of entity instances.
    
    Parameters:
    
    context - LoadContext object, defining what and how to load
    
    Returns:
    
    a list of detached instances, or empty list if nothing found
  - loadValues
```
@CheckReturnValue
java.util.List<KeyValueEntity> loadValues(ValueLoadContext context)
```
    Loads list of key-value pairs.
    
    Parameters:
    
    context - defines a query for scalar values and a list of keys for returned KeyValueEntity
    
    Returns:
    
    list of KeyValueEntity instances
  - save
```
EntitySet save(Entity... entities)
```
    Saves entity instances to the data store.
    
    Parameters:
    
    entities - entities to save
    
    Returns:
    
    set of saved instances
  - save
```
<E extends Entity> E save(E entity)
```
    Saves the entity to the data store.
    
    Parameters:
    
    entity - entity instance
    
    Returns:
    
    saved instance
  - save
```
<E extends Entity> E save(E entity,
                          @Nullable
                          View view)
```
    Saves the entity to the data store.
    
    Parameters:
    
    entity - entity instance
    
    view - view object which affects the returned instance
    
    Returns:
    
    saved instance fetched according to the given view
  - save
```
<E extends Entity> E save(E entity,
                          @Nullable
                          java.lang.String viewName)
```
    Saves the entity to the data store.
    
    Parameters:
    
    entity - entity instance
    
    viewName - name of a view which affects the returned instance
    
    Returns:
    
    saved instance fetched according to the given view
  - remove
```
void remove(Entity entity)
```
    Removes the entity instance from the data store.
    
    Parameters:
    
    entity - entity instance
  - remove
```
void remove(Entity entity,
            boolean softDeletion)
```
    Removes the entity instance from the data store.
    
    Parameters:
    
    entity - entity instance
    
    softDeletion - whether to use soft deletion for entities implementing SoftDelete (true by default)
  - remove
```
default <T extends BaseGenericIdEntity<K>,K> void remove(Id<T,K> entityId)
```
    Removes the entity instance from the data store by its id.
    
    Parameters:
    
    entityId - entity id
  - create
```
<T extends Entity> T create(java.lang.Class<T> entityClass)
```
    Creates a new entity instance. This is a shortcut to Metadata.create().
    
    Parameters:
    
    entityClass - entity class
  - getReference
```
<T extends BaseGenericIdEntity<K>,K> T getReference(java.lang.Class<T> entityClass,
                                                    K id)
```
    Returns an entity instance which can be used as a reference to an object which exists in the database.
    For example, if you are creating a User, you have to set a Group the user belongs to. If you know the group id, you could load it from the database and set to the user. This method saves you from unneeded database round trip:
```
 user.setGroup(dataManager.getReference(Group.class, groupId));
 dataManager.commit(user);
 
```
    A reference can also be used to delete an existing object by id:
```
 dataManager.remove(dataManager.getReference(Customer.class, customerId));
 
```
    Parameters:
    
    entityClass - entity class
    
    id - id of an existing object
  - getReference
```
default <T extends BaseGenericIdEntity<K>,K> T getReference(Id<T,K> entityId)
```
    Returns an entity instance which can be used as a reference to an object which exists in the database.
    
    Parameters:
    
    entityId - id of an existing object
    
    See Also:
    
    getReference(Class, Object)
  - secure
```
TransactionalDataManager secure()
```
    By default, DataManager does not apply security restrictions on entity operations and attributes, only row-level constraints take effect.
    This method returns the TransactionalDataManager implementation that applies security restrictions on entity operations. Attribute permissions will be enforced only if you additionally set the cuba.entityAttributePermissionChecking application property to true.
    Usage example:
```
 txDataManager.secure().load(Customer.class).list();
 
```
  - transactions
```
Transactions transactions()
```
    Returns an entry point to programmatic transaction control.
    Usage example:
```
 try (Transaction tx = txDataManager.transactions().create()) {
     // ...
     tx.commit();
 }
 
```
  - commitAction
```
TransactionalAction commitAction(java.util.function.Supplier<CommitContext> supplier)
```
    Entry point to TransactionalAction API.
    
    Parameters:
    
    supplier - defines how to retrieve CommitContext
    
    Returns:
    
    instance of TransactionalAction without any additional actions (onSuccess, onFail, beforeCommit, afterCompletion) and with joinTransaction=true

Interface TransactionalDataManager

Field Summary

Method Summary

Field Detail

NAME

Method Detail

load

load

loadValues

loadValue

load

loadList

loadValues

save

save

save

save

remove

remove

remove

create

getReference

getReference

secure

transactions

commitAction