Blaze the Entity Quiz and Flashcards

Introduction to Blaze Persistence Entity View Module

JPA applications that use the entity model in every layer often suffer from LazyInitializationException or N + 1 queries issues.
Blaze Persistence entity views solve these issues by defining DTOs as interfaces and providing mappings to the JPA model via annotations.
Entity views allow developers to query a subset of entity fields, reducing network traffic and improving performance.
Entity views are defined as interfaces or abstract classes with getter definitions that serve as attribute definitions.
Entity views support various mapping types, including basic mappings, collection mappings, and correlated mappings.
Entity views can have a constructor and map parameters for further transformations on the data.
The entity view module implements a convention over configuration approach with smart defaults for mappings.
Id mappings declare that an attribute represents the identifier, and entity views with an id attribute can map collections and be mapped in collections.
Flat view id mappings are used when the view type has no id declared and are mostly used when working with JPA embeddable types.
Basic mappings are declared by annotating the desired attribute with @Mapping and specifying the mapping expression.
Entity views can use any scalar expression that JPQL or Blaze Persistence allows.
The EntityViewManager and EntityViewSetting are the two most important interfaces in entity views, and the EntityViewUpdater is responsible for flushing dirty attributes to the persistence context.Blaze Persistence Entity Views: Mapping and Querying Entities with Ease
Blaze Persistence Entity Views allow for easy mapping and querying of JPA entities.
Subview and embeddable view mappings are similar to basic mappings, but only path expressions are allowed for their mappings.
Subviews are used when the type of the attribute is an entity view type, and the target type of the subview mapping and the entity view's entity type must be compatible.
Flat views are used when the entity view has no ID declared and are mostly used when working with JPA embeddable types.
Subquery mappings allow scalar subqueries to be mapped into entity views and are declared by annotating the desired attribute with @MappingSubquery and specifying a SubqueryProvider.
Parameter mappings can be used to inject query parameters or optional parameters into instances of an entity view.
Managed types can be mapped directly using the @Mapping annotation and can map any path expression as a singular or plural attribute.
Collections can be mapped in multiple ways, including 1:1 mapping, mapping a single property within a collection using @Mapping, and re-mapping a collection to a different collection type.
Indexed collections like maps and lists can be mapped by specifying a @MappingIndex and a collection value to collect all values grouped by their index value.
The @Limit annotation can be used to fetch only the top N values of a collection or correlation.
Correlated mappings can be used to connect entities through a custom criteria instead of through mapped entity relations.
Blaze Persistence Entity Views support the full set of expressions that JPQL and Blaze Persistence core module supports, and also offers some expression extensions, including the use of the this expression to refer to the entity type backing the entity view.Blaze Persistence Entity Views: Advanced Features and Use Cases
Blaze Persistence Entity Views can refer to the query root of a parent query from within a subquery, but this can lead to unintuitive behavior when the subquery provider uses OUTER and is used in a subview.
It is best to use the EMBEDDING_VIEW function instead of OUTER to refer to the relation of the embedding view.
The VIEW function can be used to refer to the relation backed by the current view, and the VIEW_ROOT function can be used to refer to the relation for which the main entity view is applied.
Blaze Persistence Entity Views supports abstract classes, which can have a custom constructor that applies transformations on data and defines an implementation for the equals and hashCode methods.
The EMBEDDING_VIEW function can be used to refer to the relation backed by the embedding view, and external services can be injected via optional parameters.
Entity views can have multiple constructors, and @ViewConstructor can be used to define a name for each constructor.
Blaze Persistence Entity Views supports inheritance mapping for subtypes, which can be defined via @EntityViewInheritance and @EntityViewInheritanceMapping annotations.
Subtypes can be defined at the declaration site or use site, and @MappingInheritance and @MappingInheritanceSubtype annotations can be used to delimit and override the entity view subtype mappings.
Entity views can use secondary entity view roots to define joins that are registered and available through a defined name to mappings of an entity view.
Fetch strategies can be applied to mappings, and the JOIN fetch strategy is usually the best default choice unless the JPA provider does not support entity joins.
The SELECT fetch strategy creates a separate query for every attribute that uses it, and the batch size can be configured at multiple levels.
Blaze Persistence Entity Views also supports CTEs, which can be defined via @With annotations and CTEProvider instances that can define CTEs.Blaze Persistence Entity Views: Fetching, Filtering and Sorting
Blaze Persistence Entity Views provide support for mapping projections, filtering, and sorting on attribute-level
The @BatchFetch annotation is used for fetching multiple values like a table for querying and selecting the correlation value
The correlation query might get executed multiple times depending on the cardinality of the correlationBasis
The runtime collects up to batch size different values and executes the correlation query for these values, caching results to avoid multiple querying
The @BatchFetch annotation can be overridden on a per attribute basis by setting the com.blazebit.persistence.view.batch_size property
The SUBSELECT strategy creates one query for every attribute and is useful for bigger collections
The MULTISET strategy uses the TO_MULTISET function to aggregate tuples to a JSON/XML which is efficient for big collections and wide rows
Entity View Filtering and Sorting is provided via com.blazebit.persistence.view.EntityViewSetting
The filter and sorter API allows filtering and sorting to be applied to entity views dynamically without modifying the entity view type or criteria builder
The EntityViewSetting essentially is configuration that can be applied to a CriteriaBuilder and contains aspects like pagination, filtering, and sorting
The EntityViewSetting API comes with an integration with the keyset pagination feature
When using a stateless approach like RESTful backends, the keyset page has to be serialized to the client and deserialized back when reading from the client.