Difference between revisions of "EclipseLink/UserGuide/JPA/Advanced JPA Development/Performance/Attribute Group"

From Eclipsepedia

Jump to: navigation, search
m (New page: {{EclipseLink_UserGuide |info=y |toc=n |eclipselink=y |eclipselinktype=JPA |examples=y |example= *http://wiki.eclipse.org/EclipseLink/Examples/JPA/AttributeGroup Attribute Group}} =Att...)
 
m
 
(9 intermediate revisions by one user not shown)
Line 1: Line 1:
 +
----
 +
 +
 +
'''[[Image:Elug_draft_icon.png|Warning]] This page is now obsolete. '''
 +
 +
For current information, please see "AttributeGroup Types and Operations" in the ''EclipseLink Concepts Guide'':
 +
http://www.eclipse.org/eclipselink/documentation/latest/concepts/descriptors002.htm#sthref35
 +
 +
 +
----
 +
 +
 
{{EclipseLink_UserGuide
 
{{EclipseLink_UserGuide
 
|info=y
 
|info=y
Line 4: Line 16:
 
|eclipselink=y
 
|eclipselink=y
 
|eclipselinktype=JPA
 
|eclipselinktype=JPA
 +
|api=y
 +
|apis=
 +
*[http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/queries/AttributeGroup.html AttributeGroup]
 +
*[http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/queries/FetchGroup.html FetchGroup]
 +
*[http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/queries/LoadGroup.html LoadGroup]
 +
* [http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/sessions/CopyGroup.html CopyGroup]
 
|examples=y
 
|examples=y
 
|example=
 
|example=
 
*[[http://wiki.eclipse.org/EclipseLink/Examples/JPA/AttributeGroup Attribute Group]]}}
 
*[[http://wiki.eclipse.org/EclipseLink/Examples/JPA/AttributeGroup Attribute Group]]}}
 +
 +
''This topic is not yet complete.''
 
=Attribute Groups=
 
=Attribute Groups=
Starting in the [[EclipseLink/Release/2.1.0|EclipseLink 2.1.0]] release, EclipseLink has introduced the concept of an [http://www.eclipse.org/eclipselink/api/2.1/org/eclipse/persistence/queries/AttributeGroup.html AttributeGroup] that can be used configure the use of partial entities in fetch, load, copy, and merge operations. This example illustrates how this functionality can be used.
+
Use attribute groups to configure the use of partial entities in fetch, load, copy, and merge operations, as follows.  
:'''Fetch''': Control which attributes and their associated columns are retrieved from the database
+
*'''Fetch''': Control which attributes and their associated columns are retrieved from the database
:'''Load''': Control which relationships in the entities returned from a query are populated
+
*'''Load''': Control which relationships in the entities returned from a query are populated
:'''Copy''': Control which attributes are copied into a new entity instance
+
*'''Copy''': Control which attributes are copied into a new entity instance
:'''Merge''': Merge only those attributes fetched, loaded, or copied into an entity
+
*'''Merge''': Merge only those attributes fetched, loaded, or copied into an entity
 +
 
 +
An <tt>AttributeGroup</tt> represents a set of mappings and nested <tt>AttributeGroup</tt>s for relationship mappings for an entity type. Use <tt>AttributeGroup</tt> to:
 +
 
 +
* Define which attributes should be fetched from the database within a [http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/queries/FetchGroup.html <tt>FetchGroup</tt>].
 +
* Define which relationship attributes should be populated in a resulting entity graph within a [http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/queries/LoadGroup.html <tt>LoadGroup</tt>]
 +
* Define which attributes should be copied within a [http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/sessions/CopyGroup.html <tt>CopyGroup</tt>]
  
 
== AttributeGroup Types and Operations ==
 
== AttributeGroup Types and Operations ==
 +
There are three types of attribute groups:
 +
 +
*[[#FetchGroup|FetchGroup]]
 +
*[[#CopyGroup|CopyGroup]]
 +
*[[#LoadGroup|LoadGroup]]
  
 
=== FetchGroup ===
 
=== FetchGroup ===
  
The [http://www.eclipse.org/eclipselink/api/2.1.0/org/eclipse/persistence/queries/FetchGroup.html FetchGroup] which has existed in EclipseLInk for a number of releases defines which attributes should be fetched (selected from the database) when the entity is retrieved as the result of a query execution. The inclusion of relationship attributes in a FetchGroup only determines if the attribute's required columns should be fetched and populated. In the case of a lazy fetch type the inclusion of the attribute simply means that its proxy will be created to enable lazy loading when accessed. To force a relationship mapping to be populated when using a FetchGroup on a query the attribute must be included in the group and must either be <code>FetchType.EAGER</code> or it must be included in an associated LoadGroup on the query.
+
A [http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/queries/FetchGroup.html <tt>FetchGroup</tt>] defines which attributes should be fetched (selected from the database) when a entity is retrieved as the result of a query execution. The inclusion of relationship attributes in a fetch group only determines if the attribute's required columns should be fetched and populated. In the case of a ''lazy'' fetch type, the inclusion of the attribute simply means that its proxy will be created to enable lazy loading when accessed. To force a relationship mapping to be populated when using a <tt>FetchGroup</tt> on a query, the attribute must be included in the group and must either be <tt>FetchType.EAGER</tt> or it must be included in an associated <tt>LoadGroup</tt> on the query.
  
 
==== Default FetchGroup ====
 
==== Default FetchGroup ====
FetchGroup also has the notion of named and default FetchGroup which are managed by the [http://www.eclipse.org/eclipselink/api/2.1.0/org/eclipse/persistence/descriptors/FetchGroupManager.html FetchGroupManager]. A default FetchGroup is defined during metadata processing if one or more basic mappings are configured to be lazy and the entity class implements [http://www.eclipse.org/eclipselink/api/2.1.0/org/eclipse/persistence/queries/FetchGroupTracker.html FetchGroupTracker] (typically introduced through weaving). The default FetchGroup is used on all queries for this entity type where no explicit FetchGroup or named FetchGroup is configured.
+
<tt>FetchGroup</tt> also has the notion of named and default <tt>FetchGroup</tt>s which are managed by the [http://www.eclipse.org/eclipselink/api/latest/org/eclipse/persistence/descriptors/FetchGroupManager.html <tt>FetchGroupManager</tt>]. A default <tt>FetchGroup</tt> is defined during metadata processing if one or more basic mappings are configured to be lazy and the entity class implements [http://www.eclipse.org/eclipselink/api/2.1.0/org/eclipse/persistence/queries/FetchGroupTracker.html <tt>FetchGroupTracker</tt>] (typically introduced through weaving). The default <tt>FetchGroup</tt> is used on all queries for this entity type where no explicit <tt>FetchGroup</tt> or named <tt>FetchGroup</tt> is configured.
  
 
==== Named FetchGroup ====  
 
==== Named FetchGroup ====  
Line 184: Line 215:
  
 
{{EclipseLink_JPA
 
{{EclipseLink_JPA
|previous=[[EclipseLink/UserGuide/JPA/Advanced_JPA_Development/Performance/Weaving/Disabling Weaving with Persistence Unit Properties|Disabling Weaving with Persistence Unit Properties]]
+
|previous=[[EclipseLink/UserGuide/JPA/Advanced_JPA_Development/Performance/Fetch_Groups|Fetch Groups]]
 
|next    =[[EclipseLink/UserGuide/JPA/Advanced_JPA_Development/Platform Specific Configurations|Platform Specific Configurations]]
 
|next    =[[EclipseLink/UserGuide/JPA/Advanced_JPA_Development/Platform Specific Configurations|Platform Specific Configurations]]
 
|up      =[[EclipseLink/UserGuide/JPA/Advanced_JPA_Development/Performance|Performance]]
 
|up      =[[EclipseLink/UserGuide/JPA/Advanced_JPA_Development/Performance|Performance]]
 
|version=2.2.0 DRAFT}}
 
|version=2.2.0 DRAFT}}

Latest revision as of 07:58, 17 April 2013



Warning This page is now obsolete.

For current information, please see "AttributeGroup Types and Operations" in the EclipseLink Concepts Guide: http://www.eclipse.org/eclipselink/documentation/latest/concepts/descriptors002.htm#sthref35




EclipseLink JPA


This topic is not yet complete.

[edit] Attribute Groups

Use attribute groups to configure the use of partial entities in fetch, load, copy, and merge operations, as follows.

  • Fetch: Control which attributes and their associated columns are retrieved from the database
  • Load: Control which relationships in the entities returned from a query are populated
  • Copy: Control which attributes are copied into a new entity instance
  • Merge: Merge only those attributes fetched, loaded, or copied into an entity

An AttributeGroup represents a set of mappings and nested AttributeGroups for relationship mappings for an entity type. Use AttributeGroup to:

  • Define which attributes should be fetched from the database within a FetchGroup.
  • Define which relationship attributes should be populated in a resulting entity graph within a LoadGroup
  • Define which attributes should be copied within a CopyGroup

[edit] AttributeGroup Types and Operations

There are three types of attribute groups:

[edit] FetchGroup

A FetchGroup defines which attributes should be fetched (selected from the database) when a entity is retrieved as the result of a query execution. The inclusion of relationship attributes in a fetch group only determines if the attribute's required columns should be fetched and populated. In the case of a lazy fetch type, the inclusion of the attribute simply means that its proxy will be created to enable lazy loading when accessed. To force a relationship mapping to be populated when using a FetchGroup on a query, the attribute must be included in the group and must either be FetchType.EAGER or it must be included in an associated LoadGroup on the query.

[edit] Default FetchGroup

FetchGroup also has the notion of named and default FetchGroups which are managed by the FetchGroupManager. A default FetchGroup is defined during metadata processing if one or more basic mappings are configured to be lazy and the entity class implements FetchGroupTracker (typically introduced through weaving). The default FetchGroup is used on all queries for this entity type where no explicit FetchGroup or named FetchGroup is configured.

[edit] Named FetchGroup

A Named FetchGroup can be defined for an entity using [TODO @FetchGroup] or within the [[EclipseLink/Examples/JPA/EclipseLink-ORM.XML|eclipselink-orm.xml]

[edit] Full FetchGroup

A FetchGroup when first created is assumed to be empty. The user must add the attributes to the FetchGroup. If a FetchGroup is required with all of the attributes then the FetchGroupManager.createFullFetchGroup() must be used.

[edit] Load/LoadAll with FetchGroup

A FetchGroup can also be configured to perform a load operation of relationship mappings and nested relationship mappings.

[edit] LoadGroup

A LoadGroup is used to force a specified set of relationship attributes to be populated in a query result.

[edit] CopyGroup

The CopyGroup replaces the deprecated ObjectCopyPolicy being used to define how a entity is copied. In addition to specifying the attributes defining what should be copied from the source entity graph into the target copy the CopyGroup also allows definition of:

  • shouldResetPrimaryKey: Reset the identifier attributes to their default value. This is used when the copy operation is intended to clone the entity in order to make a new entity with similar state to the source. Default is false.
  • shouldRestVersion: Reset the optimistic version locking attribute to its default value in the copies. Default is false.
  • depth: defines cascade mode for handling relationships. By default CASCADE_PRIVATE_PARTS is used but it can also be configured to NO_CASCADE and CASCADE_ALL_PARTS.
    • a new depth () not available in ObjectCopyPolicy) CASCADE_TREE is default in case the group has at least one attribute (addAttribute method has been called on the group).

There are significant differences between behaviours of CopyGroup with CASCADE_PRIVATE_PARTS / CASCADE_ALL_PARTS / NO_CASCADE vs. CASCADE_TREE:

  • attributes that are not copied:
    • CASCADE_PRIVATE_PARTS / CASCADE_ALL_PARTS / NO_CASCADE: shared between the copy and original;
    • CASCADE_TREE: not set in the copy;
  • shouldResetPrimaryKey:
    • CASCADE_PRIVATE_PARTS / CASCADE_ALL_PARTS / NO_CASCADE: if true then the primary key of the copy is not set;
    • CASCADE_TREE: if false then the primary key attributes are always copied, if true then only primary key attribute(s) that are not specified in the group are not set (explicitly specified in the group primary key attributes are always copied);
      • if set to true, then the copy object never assigned a fetch group;
        • use this option to create a new object from original by persisting the copy (usually after setting some new attribute values);
      • if set to false, then copy object has a fetch group if there is at least one non copied attribute.
        • use this (default) option for sparse merge.
  • shouldResetVersion
    • CASCADE_PRIVATE_PARTS / CASCADE_ALL_PARTS / NO_CASCADE: ignored;
    • CASCADE_TREE: if false then version attribute is always copied, if true then copied only if specified in the group (explicitly specified in the group version attribute is always copied);

[edit] Merging

When a partial entity is merged into a persistence context that has an AttributeGroup associated with it defining which attributes are available only those attributes are merged. The relationship mappings within the entity are still merged according to their cascade merge settings.

[edit] Usage Examples

[edit] FetchGroup Examples

[edit] Named FetchGroup

Configuring using @FetchGroup

@FetchGroup(name="names", attributes={
        @FetchAttribute(name="firstName"), 
        @FetchAttribute(name="lastName")})

Configuring within eclipsleink-orm.xml

<entity class="model.Employee">
	<secondary-table name="SALARY" />
	<fetch-group name="names">
		<attribute name="firstName" />
		<attribute name="lastName" />
	</fetch-group>

Using Named FetchGroup on Query

TypedQuery query = em.createQuery("SELECT e FROM Employee e", Employee.class);
 
query.setHint(QueryHints.FETCH_GROUP_NAME, "names");

[edit] Dynamic FetchGroup

A FetchGroup can be created dynamically within the application's code and associated with a query using QueryHints.Fetch_Group.

FetchGroup group = new FetchGroup();
 
group.addAttribute("firstName");
group.addAttribute("lastName");
 
// Load the full PhoneNumber instances
FetchGroup phoneGroup = em.unwrap(Server.class).getClassDescriptor(PhoneNumber.class).getFetchGroupManager().createFullFetchGroup();
group.addAttribute("phoneNumbers", phoneGroup);
 
query.setHint(QueryHints.FETCH_GROUP, group);

[edit] Copy Examples

Here an Employee entity is copied with it basic names, address's city and street and phoneNumbers' area code and number

CopyGroup group = new CopyGroup();
// Because the group has attributes CASCADE_ATTRIBUTES is used by default: only copy the specified attribute group items
group.addAttribute("firstName");
group.addAttribute("lastName");
group.addAttribute("address.city");
group.addAttribute("address.street");
group.addAttribute("phoneNumbers.areaCode");
group.addAttribute("phoneNumbers.number");
 
Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);

If the reference attribute specified as a "leaf" (with no sub attributes) then all its non-reference attributes are copied (but primary key is copied, too - even if it's a reference attribute). Let's assume that Address class doesn't have any non-reference attributes - then

group.addAttribute("address");

is equivalent with adding all the address's attributes:

group.addAttribute("address.id");
group.addAttribute("address.version");
group.addAttribute("address.country");
group.addAttribute("address.province");
group.addAttribute("address.postalCode");
group.addAttribute("address.city");
group.addAttribute("address.street");

Let's assume that PhoneNumber class has a composite primary key: {owner, type} - where owner is a reference to it's owner Employee and type is a string (that code have values like 'Home", "Work", "Cell etc). Just like in Address's case, adding phoneNumber attribute is equivalent to adding all PhoneNumber's attributes (the only reference attribute "owner" is also added because it's part of primary key). Because of that

group.addAttribute("phoneNumbers");

would trigger copying of the whole owner Employee - not just firstName and lastName we wanted to copy. To overcome that there is a way to specify that we don't need the whole owner:

group.addAttribute("phoneNumbers.owner.id");
group.addAttribute("phoneNumbers.type");
group.addAttribute("phoneNumbers.areaCode");
group.addAttribute("phoneNumbers.number");

[edit] Clone Entity using Copy and Persist

In this example an employee entity is cloned using a CopyGroup to copy all attributes with the exception of relationships (1:1, 1:M, M:M) that are not configured as private-owned. The resulting copy of the entity is then persisted to have new identity but the same state as its source.

CopyGroup group = new CopyGroup();
// Because the group has no attributes CASCADE_PRIVATE_PARTS depth is used by default: copy all attributes and only private-owned relationships
group.setShouldResetPrimaryKey(true);
 
Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);
System.out.println(">>> Employee copied");
 
// pk should be reset
empCopy.setId(newId);
// non-copied attributes are shared with the original - most (or all) of them usually have to be cleared and reset.
empCopy.setAddress(newAddress);
empCopy.setPhoneNumbers().clear();
empCopy.addPhoneNumber(new PhoneNumber(...));
empCopy.addPhoneNumber(new PhoneNumber(...));
// Persist the employee copy
em.persist(empCopy);

Eclipselink-logo.gif
Version: 2.2.0 DRAFT
Other versions...