DataManager (Jmix-cuba 1.0 API)

All Known Subinterfaces:

DataSupplier

All Known Implementing Classes:

CubaDataManager, GenericDataSupplier
```
public interface DataManager
```
Central interface to provide CRUD functionality. Can be used on both middle and client tiers.
In case of RdbmsStore, works with non-managed (new or detached) entities, always starts and commits new transactions.
When used on the client tier - always applies security restrictions. When used on the middleware - does not apply security restrictions by default. If you want to apply security, get secure() instance or set the cuba.dataManagerChecksSecurityOnMiddleware application property to use it by default.

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
Modifier and Type	Method and Description
`EntitySet`	`commit(CommitContext context)` Commits a collection of new or detached entity instances to the data store.
`<E extends io.jmix.core.Entity> E`	`commit(E entity)` Commits the entity to the data store.
`<E extends io.jmix.core.Entity> E`	`commit(E entity, io.jmix.core.FetchPlan fetchPlan)` Commits the entity to the data store.
`EntitySet`	`commit(io.jmix.core.Entity... entities)` Commits new or detached entity instances to the data store.
`<E extends io.jmix.core.Entity> E`	`commit(E entity, java.lang.String fetchPlanName)` Commits the entity to the data store.
`<T extends io.jmix.core.Entity> T`	`create(java.lang.Class<T> entityClass)` Creates a new entity instance in memory.
`long`	`getCount(LoadContext<? extends io.jmix.core.Entity> context)` Returns the number of entity instances for the given query passed in the `LoadContext`.
`io.jmix.core.UnconstrainedDataManager`	`getDelegate()`
`<T extends io.jmix.core.Entity,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.
`<T extends io.jmix.core.Entity,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 io.jmix.core.Entity> FluentLoader<E>`	`load(java.lang.Class<E> entityClass)` Entry point to the fluent API for loading entities.
`<E extends io.jmix.core.Entity,K> FluentLoader.ById<E>`	`load(Id<E,K> entityId)` Entry point to the fluent API for loading entities.
`<E extends io.jmix.core.Entity> E`	`load(LoadContext<E> context)` Loads a single entity instance.
`<E extends io.jmix.core.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<io.jmix.core.entity.KeyValueEntity>`	`loadValues(ValueLoadContext context)` Loads list of key-value pairs.
`<E extends io.jmix.core.Entity> E`	`reload(E entity, io.jmix.core.FetchPlan fetchPlan)` Reloads the entity instance from data store with the fetch plan specified.
`<E extends io.jmix.core.Entity> E`	`reload(E entity, io.jmix.core.FetchPlan fetchPlan, io.jmix.core.metamodel.model.MetaClass metaClass)` Reloads the entity instance from data store with the fetch plan specified.
`<E extends io.jmix.core.Entity> E`	`reload(E entity, io.jmix.core.FetchPlan fetchPlan, io.jmix.core.metamodel.model.MetaClass metaClass, boolean loadDynamicAttributes)` Reloads the entity instance from data store with the fetch plan specified.
`<E extends io.jmix.core.Entity> E`	`reload(E entity, java.lang.String fetchPlanName)` Reloads the entity instance from data store with the fetch plan specified.
`void`	`remove(io.jmix.core.Entity entity)` Removes the entity instance from the data store.
`<T extends io.jmix.core.Entity,K> void`	`remove(Id<T,K> entityId)` Removes the entity instance from the data store by its id.
`DataManager`	`secure()` By default, DataManager does not apply security restrictions on entity operations and attributes, only row-level constraints take effect.

- Field Detail
  - NAME
```
static final java.lang.String NAME
```
    See Also:
    
    Constant Field Values
- Method Detail
  - load
```
@Nullable
<E extends io.jmix.core.Entity> E load(LoadContext<E> context)
```
    Loads a single entity instance.
    The depth of object graphs, starting from loaded instances, defined by FetchPlan object passed in LoadContext.
    
    Parameters:
    
    context - LoadContext object, defining what and how to load
    
    Returns:
    
    the loaded detached object, or null if not found
  - loadList
```
<E extends io.jmix.core.Entity> java.util.List<E> loadList(LoadContext<E> context)
```
    Loads collection of entity instances.
    The depth of object graphs, starting from loaded instances, defined by FetchPlan object passed in LoadContext.
    
    Parameters:
    
    context - LoadContext object, defining what and how to load
    
    Returns:
    
    a list of detached instances, or empty list if nothing found
  - getCount
```
long getCount(LoadContext<? extends io.jmix.core.Entity> context)
```
    Returns the number of entity instances for the given query passed in the LoadContext.
    
    Parameters:
    
    context - defines the query
    
    Returns:
    
    number of instances in the data store
  - reload
```
<E extends io.jmix.core.Entity> E reload(E entity,
                                         java.lang.String fetchPlanName)
```
    Reloads the entity instance from data store with the fetch plan specified.
    
    Parameters:
    
    entity - reloading instance
    
    fetchPlanName - fetch plan name
    
    Returns:
    
    reloaded instance
    
    Throws:
    
    io.jmix.core.EntityAccessException - if the entity cannot be reloaded because it was deleted or access restrictions has been changed
  - reload
```
<E extends io.jmix.core.Entity> E reload(E entity,
                                         io.jmix.core.FetchPlan fetchPlan)
```
    Reloads the entity instance from data store with the fetch plan specified.
    
    Parameters:
    
    entity - reloading instance
    
    fetchPlan - fetch plan object
    
    Returns:
    
    reloaded instance
    
    Throws:
    
    io.jmix.core.EntityAccessException - if the entity cannot be reloaded because it was deleted or access restrictions has been changed
  - reload
```
<E extends io.jmix.core.Entity> E reload(E entity,
                                         io.jmix.core.FetchPlan fetchPlan,
                                         @Nullable
                                         io.jmix.core.metamodel.model.MetaClass metaClass)
```
    Reloads the entity instance from data store with the fetch plan specified. Loading instance class may differ from original instance if we want to load an ancestor or a descendant.
    
    Parameters:
    
    entity - reloading instance
    
    fetchPlan - fetch plan object
    
    metaClass - desired MetaClass, if null - original entity's metaclass is used
    
    Returns:
    
    reloaded instance
    
    Throws:
    
    io.jmix.core.EntityAccessException - if the entity cannot be reloaded because it was deleted or access restrictions has been changed
  - reload
```
<E extends io.jmix.core.Entity> E reload(E entity,
                                         io.jmix.core.FetchPlan fetchPlan,
                                         @Nullable
                                         io.jmix.core.metamodel.model.MetaClass metaClass,
                                         boolean loadDynamicAttributes)
```
    Reloads the entity instance from data store with the fetch plan specified. Loading instance class may differ from original instance if we want to load an ancestor or a descendant.
    
    Parameters:
    
    entity - reloading instance
    
    fetchPlan - fetch plan object
    
    metaClass - desired MetaClass, if null - original entity's metaclass is used
    
    loadDynamicAttributes - whether to load dynamic attributes for the entity
    
    Returns:
    
    reloaded instance
    
    Throws:
    
    io.jmix.core.EntityAccessException - if the entity cannot be reloaded because it was deleted or access restrictions has been changed
  - commit
```
EntitySet commit(CommitContext context)
```
    Commits a collection of new or detached entity instances to the data store.
    
    Parameters:
    
    context - CommitContext object, containing committing entities and other information
    
    Returns:
    
    set of committed instances
  - commit
```
EntitySet commit(io.jmix.core.Entity... entities)
```
    Commits new or detached entity instances to the data store.
    
    Parameters:
    
    entities - entities to commit
    
    Returns:
    
    set of committed instances
  - commit
```
<E extends io.jmix.core.Entity> E commit(E entity,
                                         @Nullable
                                         io.jmix.core.FetchPlan fetchPlan)
```
    Commits the entity to the data store.
    
    Parameters:
    
    entity - entity instance
    
    fetchPlan - fetch plan object, affects the returned committed instance
    
    Returns:
    
    committed instance
  - commit
```
<E extends io.jmix.core.Entity> E commit(E entity,
                                         @Nullable
                                         java.lang.String fetchPlanName)
```
    Commits the entity to the data store.
    
    Parameters:
    
    entity - entity instance
    
    fetchPlanName - fetch plan name, affects the returned committed instance
    
    Returns:
    
    committed instance
  - commit
```
<E extends io.jmix.core.Entity> E commit(E entity)
```
    Commits the entity to the data store.
    
    Parameters:
    
    entity - entity instance
    
    Returns:
    
    committed instance
  - remove
```
void remove(io.jmix.core.Entity entity)
```
    Removes the entity instance from the data store.
    
    Parameters:
    
    entity - entity instance
  - remove
```
<T extends io.jmix.core.Entity,K> void remove(Id<T,K> entityId)
```
    Removes the entity instance from the data store by its id.
    
    Parameters:
    
    entityId - entity id
  - loadValues
```
java.util.List<io.jmix.core.entity.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
  - secure
```
DataManager secure()
```
    By default, DataManager does not apply security restrictions on entity operations and attributes, only row-level constraints take effect.
    This method returns the DataManager 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:
```
     AppBeans.get(DataManager.class).secure().load(context);
 
```
  - getDelegate
```
io.jmix.core.UnconstrainedDataManager getDelegate()
```
  - load
```
<E extends io.jmix.core.Entity> FluentLoader<E> load(java.lang.Class<E> entityClass)
```
    Entry point to the fluent API for loading entities.
    Usage examples:
```
 Customer customer = dataManager.load(Customer.class).id(someId).one();

 List<Customer> customers = dataManager.load(Customer.class)
      .query("select c from sample$Customer c where c.name = :name")
      .parameter("name", "Smith")
      .fetchPlan("customer-fetch-plan")
      .list();
 
```
    Parameters:
    
    entityClass - class of entity that needs to be loaded
  - load
```
<E extends io.jmix.core.Entity,K> FluentLoader.ById<E> load(Id<E,K> entityId)
```
    Entry point to the fluent API for loading entities.
    Usage example:
```
 Customer customer = dataManager.load(customerId).fetchPlan("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 = dataManager.loadValues(
          "select c.name, c.status from sample$Customer c where c.name = :n")
      .properties("custName", "custStatus")
      .parameter("name", "Smith")
      .list();

 KeyValueEntity customerData = dataManager.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 = dataManager.loadValue(
          "select count(c) from sample$Customer c", Long.class).one();
 
```
    Parameters:
    
    queryString - query string
    
    valueClass - type of the returning value
  - create
```
<T extends io.jmix.core.Entity> T create(java.lang.Class<T> entityClass)
```
    Creates a new entity instance in memory. This is a shortcut to Metadata.create().
    
    Parameters:
    
    entityClass - entity class
  - getReference
```
<T extends io.jmix.core.Entity,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
```
<T extends io.jmix.core.Entity,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)

Interface DataManager

Field Summary

Method Summary

Field Detail

NAME

Method Detail

load

loadList

getCount

reload

reload

reload

reload

commit

commit

commit

commit

commit

remove

remove

loadValues

secure

getDelegate

load

load

loadValues

loadValue

create

getReference

getReference