public void collectQuerySpaces(Collection<String> spaces) { for ( EntityPersister persister : alias2Persister.values() ) { Collections.addAll( spaces, (String[]) persister.getQuerySpaces() ); } for ( CollectionPersister persister : alias2CollectionPersister.values() ) { final Type elementType = persister.getElementType(); if ( elementType.isEntityType() && ! elementType.isAnyType() ) { final Joinable joinable = ( (EntityType) elementType ).getAssociatedJoinable( factory ); Collections.addAll( spaces, (String[]) ( (EntityPersister) joinable ).getQuerySpaces() ); } } } }
@Override public String toLoggableString(Object value, SessionFactoryImplementor factory) throws HibernateException { if ( value == null ) { return "null"; } if ( !getReturnedClass().isInstance( value ) && !PersistentCollection.class.isInstance( value ) ) { // its most likely the collection-key final CollectionPersister persister = getPersister( factory ); if ( persister.getKeyType().getReturnedClass().isInstance( value ) ) { return getRole() + "#" + getPersister( factory ).getKeyType().toLoggableString( value, factory ); } else { // although it could also be the collection-id if ( persister.getIdentifierType() != null && persister.getIdentifierType().getReturnedClass().isInstance( value ) ) { return getRole() + "#" + getPersister( factory ).getIdentifierType().toLoggableString( value, factory ); } } } return renderLoggableString( value, factory ); }
public CollectionKey(CollectionPersister persister, Serializable key) { this( persister.getRole(), key, persister.getKeyType(), persister.getOwnerEntityPersister().getEntityMetamodel().getEntityMode(), persister.getFactory() ); }
CollectionStatisticsImpl(CollectionPersister persister) { super( () -> persister.getCacheAccessStrategy() != null ? persister.getCacheAccessStrategy().getRegion() : null ); this.collectionRole = persister.getRole(); }
private CollectionKey( String role, Serializable key, Type keyType, EntityMode entityMode, SessionFactoryImplementor factory) { this.role = role; this.key = key; this.keyType = keyType; this.entityMode = entityMode; this.factory = factory; //cache the hash-code this.hashCode = generateHashCode(); }
public Iterator entries(CollectionPersister persister) { final Type elementType = persister.getElementType(); List elements = element.elements( persister.getElementNodeName() ); int length = elements.size(); List result = new ArrayList(length); for ( int i=0; i<length; i++ ) { Element elem = (Element) elements.get(i); Object object = elementType.fromXMLNode( elem, persister.getFactory() ); result.add(object); } return result.iterator(); }
public Object readFrom(ResultSet rs, CollectionPersister persister, CollectionAliases descriptor, Object owner) throws HibernateException, SQLException { Object object = persister.readElement( rs, owner, descriptor.getSuffixedElementAliases(), getSession() ); final Type elementType = persister.getElementType(); Element subelement = element.addElement( persister.getElementNodeName() ); elementType.setToXMLNode( subelement, object, persister.getFactory() ); return object; }
public void initializeFromCache(CollectionPersister persister, Serializable disassembled, Object owner) throws HibernateException { Type elementType = persister.getElementType(); Serializable[] cached = (Serializable[]) disassembled; for ( int i=0; i<cached.length; i++ ) { Object object = elementType.assemble( cached[i], getSession(), owner ); Element subelement = element.addElement( persister.getElementNodeName() ); elementType.setToXMLNode( subelement, object, persister.getFactory() ); } }
final EntityPersister ownerPersister = collectionPersister.getOwnerEntityPersister(); if ( ownerPersister.getIdentifierType().getReturnedClass().isInstance( key ) ) { return getEntity( session.generateEntityKey( key, collectionPersister.getOwnerEntityPersister() ) ); if ( ownerPersister.isInstance( key ) ) { final Serializable owenerId = ownerPersister.getIdentifier( key, session ); if ( owenerId == null ) { return null; final CollectionType collectionType = collectionPersister.getCollectionType(); if ( collectionType.getLHSPropertyName() != null ) { final Object owner = getEntity( new EntityUniqueKey( ownerPersister.getEntityName(), collectionType.getLHSPropertyName(), key, collectionPersister.getKeyType(), ownerPersister.getEntityMode(), session.getFactory() final Serializable ownerId = ownerPersister.getIdByUniqueKey( key, collectionType.getLHSPropertyName(), session ); return getEntity( session.generateEntityKey( ownerId, ownerPersister ) ); return getEntity( session.generateEntityKey( key, collectionPersister.getOwnerEntityPersister() ) );
/** * Get the id value from the owning entity key, usually the same as the key, but might be some * other property, in the case of property-ref * * @param key The collection owner key * @param session The session from which the request is originating. * @return The collection owner's id, if it can be obtained from the key; * otherwise, null is returned */ public Serializable getIdOfOwnerOrNull(Serializable key, SharedSessionContractImplementor session) { Serializable ownerId = null; if ( foreignKeyPropertyName == null ) { ownerId = key; } else { Type keyType = getPersister( session ).getKeyType(); EntityPersister ownerPersister = getPersister( session ).getOwnerEntityPersister(); // TODO: Fix this so it will work for non-POJO entity mode Class ownerMappedClass = ownerPersister.getMappedClass(); if ( ownerMappedClass.isAssignableFrom( keyType.getReturnedClass() ) && keyType.getReturnedClass().isInstance( key ) ) { // the key is the owning entity itself, so get the ID from the key ownerId = ownerPersister.getIdentifier( key, session ); } else { // TODO: check if key contains the owner ID } } return ownerId; }
s.append( persister.getRole() ); s.append( '#' ); Type ownerIdentifierType = persister.getOwnerEntityPersister() .getIdentifierType(); Serializable ownerKey; ownerIdentifierType.getReturnedClass() ) ) { ownerKey = collectionKey; EntityEntry entry = collectionOwner == null ? null : session.getPersistenceContext().getEntry(collectionOwner); ownerKey = entry == null ? null : entry.getId(); s.append( ownerIdentifierType.toLoggableString( ownerKey, session.getFactory() ) );
private void endLoadingCollection(LoadingCollectionEntry lce, CollectionPersister persister) { LOG.tracev( "Ending loading collection [{0}]", lce ); final SharedSessionContractImplementor session = getLoadContext().getPersistenceContext().getSession(); if ( persister.getCollectionType().hasHolder() ) { getLoadContext().getPersistenceContext().addCollectionHolder( lce.getCollection() ); persister.getOwnerEntityPersister().getInstrumentationMetadata(); if ( bytecodeEnhancementMetadata.isEnhancedForLazyLoading() ) { if ( StringHelper.qualifier( persister.getRole() ).length() == persister.getOwnerEntityPersister().getEntityName().length() ) { final String propertyName = persister.getRole().substring( persister.getOwnerEntityPersister().getEntityName().length() + 1 ); if ( !bytecodeEnhancementMetadata.isAttributeLoaded( lce.getCollection().getOwner(), propertyName ) ) { int propertyIndex = persister.getOwnerEntityPersister().getEntityMetamodel().getPropertyIndex( propertyName ); persister.getOwnerEntityPersister().setPropertyValue( lce.getCollection().getOwner(), propertyIndex, && persister.hasCache() session.getFactory().getStatistics().loadCollection( persister.getRole() );
EntityEntry entityEntry = session.getPersistenceContext().getEntry( owner ); if ( entityEntry == null ) { id = entityEntry.getPersister().getPropertyValue( owner, foreignKeyPropertyName ); Type keyType = getPersister( session ).getKeyType(); Class returnedClass = keyType.getReturnedClass(); id = keyType.semiResolve( entityEntry.getLoadedValue( foreignKeyPropertyName ), session,
private static void addIdToCollectionInfoString( CollectionPersister persister, Serializable id, SessionFactoryImplementor factory, StringBuilder s ) { // Need to use the identifier type of the collection owner // since the incoming is value is actually the owner's id. // Using the collection's key type causes problems with // property-ref keys. // Also need to check that the expected identifier type matches // the given ID. Due to property-ref keys, the collection key // may not be the owner key. Type ownerIdentifierType = persister.getOwnerEntityPersister() .getIdentifierType(); if ( id.getClass().isAssignableFrom( ownerIdentifierType.getReturnedClass() ) ) { s.append( ownerIdentifierType.toLoggableString( id, factory ) ); } else { // TODO: This is a crappy backup if a property-ref is used. // If the reference is an object w/o toString(), this isn't going to work. s.append( id.toString() ); } }
private CollectionFetchableIndex buildIndexGraph() { final CollectionPersister persister = collectionQuerySpace.getCollectionPersister(); if ( persister.hasIndex() ) { final Type type = persister.getIndexType(); if ( type.isAssociationType() ) { if ( type.isEntityType() ) { final EntityPersister indexPersister = persister.getFactory().getEntityPersister( ( (EntityType) type ).getAssociatedEntityName() ); indexPersister, CollectionPropertyNames.COLLECTION_INDICES, (EntityType) persister.getIndexType(), collectionQuerySpace.getExpandingQuerySpaces().generateImplicitUid(), collectionQuerySpace.canJoinsBeRequired(), return new CollectionFetchableIndexEntityGraph( this, entityQuerySpace ); collectionQuerySpace, new CompositePropertyMapping( (CompositeType) persister.getIndexType(), (PropertyMapping) persister, "" ), CollectionPropertyNames.COLLECTION_INDICES, (CompositeType) persister.getIndexType(), collectionQuerySpace.getExpandingQuerySpaces().generateImplicitUid(), collectionQuerySpace.canJoinsBeRequired(),
final Object anything, final CollectionType type) { final CollectionPersister persister = eventSource.getFactory().getCollectionPersister( type.getRole() ); final Type elemType = persister.getElementType(); if ( elemType.isEntityType() || elemType.isAnyType() || elemType.isComponentType() ) { cascadeCollectionElements( action, elemType, anything, persister.isCascadeDeleteEnabled() );
protected Serializable getCollectionKey( CollectionPersister persister, Object owner, EntityEntry ownerEntry, SharedSessionContractImplementor session) { final CollectionType collectionType = persister.getCollectionType(); if ( ownerEntry != null ) { // this call only works when the owner is associated with the Session, which is not always the case return collectionType.getKeyOfOwner( owner, session ); } if ( collectionType.getLHSPropertyName() == null ) { // collection key is defined by the owning entity identifier return persister.getOwnerEntityPersister().getIdentifier( owner, session ); } else { return (Serializable) persister.getOwnerEntityPersister().getPropertyValue( owner, collectionType.getLHSPropertyName() ); } }
String role = collRtn.getOwnerEntityName() + "." + collRtn.getOwnerProperty(); CollectionPersister persister = getFactory().getMetamodel().collectionPersister( role ); EntityType ownerType = (EntityType) persister.getElementType(); entityName = ownerType.getAssociatedEntityName( getFactory() ); Queryable persister = determineAppropriateOwnerPersister( fetchRtn.getOwner() ); Type ownerType = persister.getPropertyType( fetchRtn.getOwnerProperty() ); if ( ownerType.isEntityType() ) { entityName = ( (EntityType) ownerType ).getAssociatedEntityName( getFactory() ); else if ( ownerType.isCollectionType() ) { Type ownerCollectionElementType = ( (CollectionType) ownerType ).getElementType( getFactory() ); if ( ownerCollectionElementType.isEntityType() ) { entityName = ( (EntityType) ownerCollectionElementType ).getAssociatedEntityName( getFactory() );
private void evictCachedCollections(Type[] types, Serializable id, EventSource source) throws HibernateException { for ( Type type : types ) { if ( type.isCollectionType() ) { CollectionPersister collectionPersister = source.getFactory().getMetamodel().collectionPersister( ( (CollectionType) type ).getRole() ); if ( collectionPersister.hasCache() ) { final CollectionDataAccess cache = collectionPersister.getCacheAccessStrategy(); final Object ck = cache.generateCacheKey( id, collectionPersister, source.getFactory(), source.getTenantIdentifier() ); final SoftLock lock = cache.lockItem( source, ck, null ); cache.remove( source, ck ); source.getActionQueue().registerProcess( (success, session) -> cache.unlockItem( session, ck, lock ) ); } } else if ( type.isComponentType() ) { CompositeType actype = (CompositeType) type; evictCachedCollections( actype.getSubtypes(), id, source ); } } } }
private void evictCache(Object entity, EntityPersister persister, EventSource session, Object[] oldState) { try { SessionFactoryImplementor factory = persister.getFactory(); Set<String> collectionRoles = factory.getMetamodel().getCollectionRolesByEntityParticipant( persister.getEntityName() ); if ( collectionRoles == null || collectionRoles.isEmpty() ) { return; if ( !collectionPersister.hasCache() ) { String mappedBy = collectionPersister.getMappedByProperty(); if ( !collectionPersister.isManyToMany() && mappedBy != null && !mappedBy.isEmpty() ) { int i = persister.getEntityMetamodel().getPropertyIndex( mappedBy ); Serializable oldId = null; if ( oldState != null ) { final SoftLock softLock = collectionPersister.getCacheAccessStrategy().lockRegion(); session.getActionQueue().registerProcess( (success, session1) -> { collectionPersister.getCacheAccessStrategy().unlockRegion( softLock ); } );