Examples of org.eclipse.persistence.queries.FetchGroup

org.eclipse.persistence.queries.FetchGroup
A FetchGroup is a performance enhancement that allows a group of attributes of an object to be loaded on demand, which means that the data for an attribute might not loaded from the underlying data source until an explicit access call for the attribute first occurs. It avoids loading all data of the object's attributes, in which the user is interested in only a subset of them. A great deal of caution and careful system use case analysis should be use when using the fetch group feature, as the extra round-trip would well offset the gain from the deferred loading in many cases.
FetchGroup usage is only possible when an entity class implements the {@link FetchGroupTracker} interface so that the FetchGroup can be stored inthe entity. The entity must also use the provided check methods to ensure the attributes are loaded prior to use. In general this support is enabled through weaving of the entity classes. If an entity class does not implement {@link FetchGroupTracker} no FetchGroup functionality will be supported andattempted use of a FetchGroup in a query will not result in the expected behavior.
FetchGroups are defined in 3 ways:
- A {@link FetchGroupManager#getDefaultFetchGroup()} is created and storedon the {@link FetchGroupManager} during metadata processing if any of thebasic ( {@link DirectToFieldMapping}) are configured to be loaded directly.
- A named FetchGroup can be defined and added to the {@link FetchGroupManager}. For JPA users this can be accomplished using annotation (@FetchGroup) or in an eclipselink-orm.xml. For JPA and native users named groups can be defined in code and added to the {@link FetchGroupManager#addFetchGroup(FetchGroup)}. Adding named groups in code is typically done in a {@link DescriptorCustomizer}and should be done before the session is initialized at login. To use a named FetchGroup on a query the native {@link ObjectLevelReadQuery#setFetchGroupName(String)} canbe used of for JPA users the {@link QueryHints#FETCH_GROUP_NAME} an be used.
- A dynamic FetchGroup can be created within the application and used on a query. For native API usage this is done using {@link ObjectLevelReadQuery#setFetchGroup(FetchGroup)} while JPA usersgenerally use the {@link QueryHints#FETCH_GROUP}.
When a query is executed only one FetchGroup will be used. The order of precedence is:
1. If a FetchGroup is specified on a query it will be used.
2. If no FetchGroup is specified but a FetchGroup name is specified and the FetchGroupManager has a group by this name it will be used.
3. If neither a FetchGroup nor a FetchGroup name is specified on the query an the FetchGroupManager has a default group then it will be used.
4. If none of these conditions are met then no FetchGroup will be used when executing a query.
  Note: This includes the execution of queries to populate lazy and eager relationships.
  Loading: A FetchGroup can optionally specify that it needs its included relationships loaded. This can be done using {@link #setShouldLoad(boolean)} and {@link #setShouldLoadAll(boolean)} aswell as the corresponding configurations in the @FetchGroup annotation and the element in the eclipselink-orm.xml. When this si configured the FetchGroup will also function as a {@link LoadGroup} causing all of itsspecified relationships to be populated prior to returning the results form the query execution. @see FetchGroupManager @see QueryHints#FETCH_GROUP @see LoadGroup @author King Wang, dclarke, ailitchev @since TopLink 10.1.3

258 259 260 261 262 263 264 265 266 267 268         while(it.hasNext()) {             Map.Entry<String, AttributeItem> entry = it.next();             String name = entry.getKey();             DatabaseMapping mapping = builder.getMappingForAttributeName(name);             if(mapping != null) {                 FetchGroup nestedFetchGroup = (FetchGroup)entry.getValue().getGroup();                 if(nestedFetchGroup != null) {                    if(mapping.isForeignReferenceMapping()) {                        ClassDescriptor referenceDescriptor = ((ForeignReferenceMapping)mapping).getReferenceDescriptor();                        if(referenceDescriptor != null) {                            FetchGroupManager nestedFetchGroupManager = referenceDescriptor.getFetchGroupManager();

View Full Code Here

352 353 354 355 356 357 358 359 360 361 362      * Lookup the FetchGroup to use given a name taking into      * consideration descriptor inheritance to ensure parent descriptors are      * searched for named FetchGroups.      */     public FetchGroup getFetchGroup(String groupName) {         FetchGroup fg = this.fetchGroups.get(groupName);         if (fg == null && getDescriptor().isChildDescriptor()) {             ClassDescriptor current = this.descriptor;             while (fg == null && current.isChildDescriptor()) {                 ClassDescriptor parent = current.getInheritancePolicy().getParentDescriptor();

View Full Code Here

374 375 376 377 378 379 380 381 382 383 384      * consideration descriptor inheritance to ensure parent descriptors are      * searched for named and default FetchGroup. This is used to determine the      * FetchGroup to use in a query's prepare.      */     public FetchGroup getFetchGroup(String groupName, boolean useDefault) {         FetchGroup fg = null;         if (groupName != null) {             fg = getFetchGroup(groupName);         }

View Full Code Here

428 429 430 431 432 433 434 435 436 437 438      * Return true if the object is partially fetched and cached.      * It applies to the query with fetch group.      */     public boolean isPartialObject(Object domainObject) {         if (domainObject != null) {             FetchGroup fetchGroupInCache = ((FetchGroupTracker)domainObject)._persistence_getFetchGroup();             //if the fetch group reference is not null, it means the object is partial.             return (fetchGroupInCache != null);         }         return false;

View Full Code Here

441 442 443 444 445 446 447 448     /**      * INTERNAL:      * Return if the cached object data is sufficiently valid against a fetch group      */     public boolean isObjectValidForFetchGroup(Object object, FetchGroup fetchGroup) {         FetchGroup groupInObject = ((FetchGroupTracker)object)._persistence_getFetchGroup();         return (groupInObject == null) || groupInObject.isSupersetOf(fetchGroup);     }

View Full Code Here

451 452 453 454 455 456 457 458 459 460 461 462 463      * INTERNAL:      * Return true if the cached object data should be written in clone.      * It is used in Fetch Group case when filling in the clone from the cached object.      */     public boolean shouldWriteInto(Object cachedObject, Object clone) {         FetchGroup fetchGroupInTarg = ((FetchGroupTracker)clone)._persistence_getFetchGroup();         if (fetchGroupInTarg != null) {             FetchGroup fetchGroupInSrc = ((FetchGroupTracker)cachedObject)._persistence_getFetchGroup();             //should write if target's fetch group is not a superset of that of the source,             //or if refresh is required, should always write (either refresh or revert) data from the cache to the clones.             return !fetchGroupInTarg.isSupersetOf(fetchGroupInSrc) || ((FetchGroupTracker) cachedObject)._persistence_shouldRefreshFetchGroup();         }

View Full Code Here

467 468 469 470 471 472 473 474 475 476 477 478     /**      * INTERNAL:      * Write data of the partially fetched object into the working and backup clones      */     public void writePartialIntoClones(Object partialObject, Object workingClone, UnitOfWorkImpl uow) {         FetchGroup fetchGroupInClone = ((FetchGroupTracker)workingClone)._persistence_getFetchGroup();         FetchGroup fetchGroupInObject = ((FetchGroupTracker)partialObject)._persistence_getFetchGroup();         Object backupClone = uow.getBackupClone(workingClone, descriptor);         // Update fetch group in clone as the union of two,         // do this first to avoid fetching during method access.         EntityFetchGroup union = flatUnionFetchGroups(fetchGroupInObject, fetchGroupInClone);

View Full Code Here

629 630 631 632 633 634 635 636 637 638 639 640 641      * INTERNAL:      * Return FetchGroup held by the object.      */     public EntityFetchGroup getObjectEntityFetchGroup(Object domainObject) {         if (domainObject != null) {             FetchGroup fetchGroup = ((FetchGroupTracker)domainObject)._persistence_getFetchGroup();             if(fetchGroup != null) {                 if(fetchGroup.isEntityFetchGroup()) {                     return (EntityFetchGroup)fetchGroup;                 }                 return getEntityFetchGroup(fetchGroup);             }         }

View Full Code Here

679 680 681 682 683 684 685 686 687 688 689     /**      * Return true if the attribute of the object has already been fetched      */     public boolean isAttributeFetched(Object entity, String attributeName) {         FetchGroup fetchGroup = ((FetchGroupTracker) entity)._persistence_getFetchGroup();         if (fetchGroup == null) {             return true;         }                return fetchGroup.containsAttributeInternal(attributeName);     }

View Full Code Here

717 718 719 720 721 722 723 724 725 726 727 728     public void initialize(AbstractSession session) throws DescriptorException {         if (!(Helper.classImplementsInterface(getDescriptor().getJavaClass(), ClassConstants.FetchGroupTracker_class))) {             //to use fetch group, the domain class must implement FetchGroupTracker interface             session.getIntegrityChecker().handleError(DescriptorException.needToImplementFetchGroupTracker(getDescriptor().getJavaClass(), getDescriptor()));         }         this.minimalFetchGroup = new FetchGroup();         this.fullFetchGroup = new FetchGroup();         for (DatabaseMapping mapping : getDescriptor().getMappings()) {             String name = mapping.getAttributeName();             if(mapping.isPrimaryKeyMapping()) {                 this.minimalFetchGroup.addAttribute(name);             }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.persistence.queries.FetchGroup

org.eclipse.persistence.descriptors.changetracking.AttributeChangeTrackingPolicy

org.eclipse.persistence.descriptors.FetchGroupManager

org.eclipse.persistence.internal.descriptors.DescriptorIterator

org.eclipse.persistence.internal.jpa.metadata.queries.FetchGroupMetadata

org.eclipse.persistence.internal.jpa.QueryHintsHandler$FetchGraphHint

org.eclipse.persistence.internal.jpa.QueryHintsHandler$FetchGroupAttributeHint

org.eclipse.persistence.internal.jpa.QueryHintsHandler$FetchGroupLoadHint

org.eclipse.persistence.internal.queries.JoinedAttributeManager

org.eclipse.persistence.internal.xr.UpdateOperation

org.eclipse.persistence.jpa.rs.PersistenceContext

Copyright © 2018 www.massapicom. All rights reserved.

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.