LoadContext (Jmix-core 1.2 API)

java.lang.Object
- io.jmix.core.LoadContext<E>

All Implemented Interfaces:: DataLoadContext, java.io.Serializable

public class LoadContext<E>
extends java.lang.Object
implements DataLoadContext, java.io.Serializable

Class that defines parameters for loading entities from the database via DataManager.

Typical usage:

 LoadContext<User> context = new LoadContext(userMetaClass).setQuery(
 new LoadContext.Query("select u from sec$User u where u.login like :login")
 .setParameter("login", "a%")
 .setMaxResults(10))
 .setFetchPlan("user.browse");
 List<User> users = dataManager.loadList(context);

Instead of using this class directly, consider fluent interface with the entry point in UnconstrainedDataManager.load(Class).

See Also:: Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class LoadContext.Query
Class that defines a query to be executed for data loading.

Nested Classes
Modifier and Type	Class and Description
`static class`	`LoadContext.Query` Class that defines a query to be executed for data loading.

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.List<AccessConstraint<?>>`	`accessConstraints`
`protected FetchPlan`	`fetchPlan`
`protected java.util.Map<java.lang.String,java.io.Serializable>`	`hints`
`protected java.lang.Object`	`id`
`protected java.util.List<java.lang.Object>`	`idList`
`protected boolean`	`joinTransaction`
`protected boolean`	`loadPartialEntities`
`protected MetaClass`	`metaClass`
`protected java.util.List<LoadContext.Query>`	`prevQueries`
`protected LoadContext.Query`	`query`
`protected int`	`queryKey`

Constructor Summary

Constructors
Modifier Constructor and Description

protected LoadContext()

LoadContext(MetaClass metaClass)

Constructors
Modifier	Constructor and Description
`protected`	`LoadContext()`
	`LoadContext(MetaClass metaClass)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`LoadContext<?>`	`copy()` Creates a copy of this LoadContext instance.
`java.util.List<AccessConstraint<?>>`	`getAccessConstraints()` Returns directly accessible list of access constraints.
`MetaClass`	`getEntityMetaClass()`
`FetchPlan`	`getFetchPlan()`
`java.util.Map<java.lang.String,java.lang.Object>`	`getHints()`
`java.lang.Object`	`getId()`
`java.util.List<?>`	`getIds()`
`java.util.List<LoadContext.Query>`	`getPreviousQueries()` Allows to execute query on a previous query result.
`LoadContext.Query`	`getQuery()`
`int`	`getQueryKey()`
`boolean`	`isJoinTransaction()`
`boolean`	`isLoadPartialEntities()`
`LoadContext<E>`	`setAccessConstraints(java.util.Collection<AccessConstraint<?>> accessConstraints)` Sets list of access constraints.
`LoadContext<E>`	`setFetchPlan(FetchPlan fetchPlan)`
`LoadContext<E>`	`setHint(java.lang.String hintName, java.io.Serializable value)` Sets custom hint that should be used by the query.
`LoadContext<E>`	`setHints(java.util.Map<java.lang.String,java.io.Serializable> hints)` Sets custom hints that should be used by the query.
`LoadContext<E>`	`setId(java.lang.Object id)`
`LoadContext<E>`	`setIds(java.util.Collection<?> ids)`
`LoadContext<E>`	`setJoinTransaction(boolean joinTransaction)` Sets whether to join existing transaction or always start a new one.
`LoadContext<E>`	`setLoadPartialEntities(boolean loadPartialEntities)` Whether to load partial entities.
`LoadContext<E>`	`setQuery(LoadContext.Query query)`
`LoadContext<E>`	`setQueryKey(int queryKey)`
`LoadContext.Query`	`setQueryString(java.lang.String queryString)`
`java.lang.String`	`toString()`

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

- Field Detail
  - metaClass
```
protected MetaClass metaClass
```
  - query
```
protected LoadContext.Query query
```
  - fetchPlan
```
protected FetchPlan fetchPlan
```
  - id
```
protected java.lang.Object id
```
  - idList
```
protected java.util.List<java.lang.Object> idList
```
  - prevQueries
```
protected java.util.List<LoadContext.Query> prevQueries
```
  - accessConstraints
```
protected java.util.List<AccessConstraint<?>> accessConstraints
```
  - queryKey
```
protected int queryKey
```
  - loadPartialEntities
```
protected boolean loadPartialEntities
```
  - joinTransaction
```
protected boolean joinTransaction
```
  - hints
```
protected java.util.Map<java.lang.String,java.io.Serializable> hints
```
- Constructor Detail
  - LoadContext
```
public LoadContext(MetaClass metaClass)
```
    Parameters:
    
    metaClass - metaclass of the loaded entities
  - LoadContext
```
protected LoadContext()
```
- Method Detail
  - getEntityMetaClass
```
public MetaClass getEntityMetaClass()
```
    Returns:
    
    metaclass of the loaded entities
  - getQuery
```
@Nullable
public LoadContext.Query getQuery()
```
    Returns:
    
    query definition
  - setQuery
```
public LoadContext<E> setQuery(LoadContext.Query query)
```
    Parameters:
    
    query - query definition
    
    Returns:
    
    this instance for chaining
  - setQueryString
```
public LoadContext.Query setQueryString(java.lang.String queryString)
```
    Specified by:
    
    setQueryString in interface DataLoadContext
    
    Parameters:
    
    queryString - JPQL query string. Only named parameters are supported.
    
    Returns:
    
    query definition object
  - getFetchPlan
```
@Nullable
public FetchPlan getFetchPlan()
```
    Returns:
    
    fetchPlan that is used for loading entities
  - setFetchPlan
```
public LoadContext<E> setFetchPlan(FetchPlan fetchPlan)
```
    Parameters:
    
    fetchPlan - fetchPlan that is used for loading entities
    
    Returns:
    
    this instance for chaining
  - getId
```
@Nullable
public java.lang.Object getId()
```
    Returns:
    
    id of an entity to be loaded
  - setId
```
public LoadContext<E> setId(java.lang.Object id)
```
    Parameters:
    
    id - id of an entity to be loaded
    
    Returns:
    
    this instance for chaining
  - getIds
```
public java.util.List<?> getIds()
```
    Returns:
    
    identifiers of entities to be loaded
  - setIds
```
public LoadContext<E> setIds(java.util.Collection<?> ids)
```
    Parameters:
    
    ids - identifiers of entities to be loaded
    
    Returns:
    
    this instance for chaining
  - getPreviousQueries
```
public java.util.List<LoadContext.Query> getPreviousQueries()
```
    Allows to execute query on a previous query result.
    
    Returns:
    
    editable list of previous queries
  - getQueryKey
```
public int getQueryKey()
```
    Returns:
    
    key of the current stack of sequential queries, which is unique for the current user session
  - setQueryKey
```
public LoadContext<E> setQueryKey(int queryKey)
```
    Parameters:
    
    queryKey - key of the current stack of sequential queries, which is unique for the current user session
  - getHints
```
public java.util.Map<java.lang.String,java.lang.Object> getHints()
```
    Returns:
    
    custom hints which are used by the query
  - setHint
```
public LoadContext<E> setHint(java.lang.String hintName,
                              java.io.Serializable value)
```
    Sets custom hint that should be used by the query.
  - setHints
```
public LoadContext<E> setHints(java.util.Map<java.lang.String,java.io.Serializable> hints)
```
    Sets custom hints that should be used by the query.
  - isLoadPartialEntities
```
public boolean isLoadPartialEntities()
```
    Returns:
    
    whether to load partial entities. When true (which is by default), some local attributes can be unfetched according to setFetchPlan(FetchPlan).
    The state of FetchPlan.loadPartialEntities() is ignored when the fetchPlan is passed to DataManager.
  - setLoadPartialEntities
```
public LoadContext<E> setLoadPartialEntities(boolean loadPartialEntities)
```
    Whether to load partial entities. When true (which is by default), some local attributes can be unfetched according to setFetchPlan(FetchPlan).
    The state of FetchPlan.loadPartialEntities() is ignored when the fetchPlan is passed to DataManager.
  - getAccessConstraints
```
public java.util.List<AccessConstraint<?>> getAccessConstraints()
```
    Returns directly accessible list of access constraints.
  - setAccessConstraints
```
public LoadContext<E> setAccessConstraints(@Nullable
                                           java.util.Collection<AccessConstraint<?>> accessConstraints)
```
    Sets list of access constraints.
  - isJoinTransaction
```
public boolean isJoinTransaction()
```
    Returns:
    
    whether to join existing transaction or always start a new one
  - setJoinTransaction
```
public LoadContext<E> setJoinTransaction(boolean joinTransaction)
```
    Sets whether to join existing transaction or always start a new one.
  - copy
```
public LoadContext<?> copy()
```
    Creates a copy of this LoadContext instance.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class LoadContext<E>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

metaClass

query

fetchPlan

id

idList

prevQueries

accessConstraints

queryKey

loadPartialEntities

joinTransaction

hints

Constructor Detail

LoadContext

LoadContext

Method Detail

getEntityMetaClass

getQuery

setQuery

setQueryString

getFetchPlan

setFetchPlan

getId

setId

getIds

setIds

getPreviousQueries

getQueryKey

setQueryKey

getHints

setHint

setHints

isLoadPartialEntities

setLoadPartialEntities

getAccessConstraints

setAccessConstraints

isJoinTransaction

setJoinTransaction

copy

toString