protected static CollectionPersister getLoadedCollectionPersister( PersistentCollection collection, EventSource source ) { CollectionEntry ce = source.getPersistenceContext().getCollectionEntry( collection ); return ( ce == null ? null : ce.getLoadedPersister() ); }
/** * Is this the "inverse" end of a bidirectional association? */ @SuppressWarnings({"JavaDoc"}) protected boolean isInverseCollection() { final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this ); return ce != null && ce.getLoadedPersister().isInverse(); }
protected final CollectionEntry getCollectionEntry(AbstractCollectionEvent event) { return event.getSession().getPersistenceContext().getCollectionEntry( event.getCollection() ); }
final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this ); if ( ce != null ) { sb.append(
public void addEvent(AbstractCollectionEvent event, Listener listener) { CollectionEntry collectionEntry = event.getSession() .getPersistenceContext() .getCollectionEntry(event.getCollection()); Serializable snapshot = collectionEntry.getSnapshot(); log.debug("add Event: " + event.getClass() + "; listener = " + listener.getClass() + "; snapshot = " + snapshot); listenersCalled.add(listener); events.add(event); snapshots.add(snapshot); }
/** * Is this the "inverse" end of a bidirectional association with * no orphan delete enabled? */ @SuppressWarnings({"JavaDoc"}) protected boolean isInverseCollectionNoOrphanDelete() { final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this ); return ce != null && ce.getLoadedPersister().isInverse() && !ce.getLoadedPersister().hasOrphanDelete(); }
/** * Delete any entities that were removed from the collection */ private static void deleteOrphans(EventSource eventSource, String entityName, PersistentCollection pc) throws HibernateException { //TODO: suck this logic into the collection! final Collection orphans; if ( pc.wasInitialized() ) { final CollectionEntry ce = eventSource.getPersistenceContext().getCollectionEntry( pc ); orphans = ce==null ? java.util.Collections.EMPTY_LIST : ce.getOrphans( entityName, pc ); } else { orphans = pc.getQueuedOrphans( entityName ); } for ( Object orphan : orphans ) { if ( orphan != null ) { LOG.tracev( "Deleting orphaned entity instance: {0}", entityName ); eventSource.delete( entityName, orphan, false, new HashSet() ); } } } }
/** * Is this the "inverse" end of a bidirectional one-to-many, or * of a collection with no orphan delete? */ @SuppressWarnings({"JavaDoc"}) protected boolean isInverseOneToManyOrNoOrphanDelete() { final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( this ); return ce != null && ce.getLoadedPersister().isInverse() && ( ce.getLoadedPersister().isOneToMany() || !ce.getLoadedPersister().hasOrphanDelete() ); }
protected CollectionPersister resolveCollectionPersister( SessionImplementor session, PersistentCollection collection) { // First attempt to resolve the persister from the collection entry if ( collection != null ) { CollectionEntry collectionEntry = session.getPersistenceContext().getCollectionEntry( collection ); if ( collectionEntry != null ) { CollectionPersister collectionPersister = collectionEntry.getCurrentPersister(); if ( collectionPersister != null ) { return collectionPersister; } } } // Fallback to resolving the persister from the collection role final CollectionPersister collectionPersister = session.getFactory() .getMetamodel() .collectionPersister( commonCollectionMapperData.getRole() ); if ( collectionPersister == null ) { throw new AuditException( String.format( Locale.ROOT, "Failed to locate CollectionPersister for collection [%s]", commonCollectionMapperData.getRole() ) ); } return collectionPersister; }
@Override public Boolean doWork() { final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this ); final CollectionPersister persister = entry.getLoadedPersister(); if ( persister.isExtraLazy() ) { if ( hasQueuedOperations() ) { session.flush(); } return persister.indexExists( entry.getLoadedKey(), index, session ); } else { read(); } return null; } }
@Override public Boolean doWork() { final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this ); final CollectionPersister persister = entry.getLoadedPersister(); if ( persister.isExtraLazy() ) { if ( hasQueuedOperations() ) { session.flush(); } return persister.elementExists( entry.getLoadedKey(), element, session ); } else { read(); } return null; } }
@Override public Boolean doWork() { final CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this ); if ( entry != null ) { final CollectionPersister persister = entry.getLoadedPersister(); if ( persister.isExtraLazy() ) { if ( hasQueuedOperations() ) { session.flush(); } cachedSize = persister.getSize( entry.getLoadedKey(), session ); return true; } else { read(); } } else{ throwLazyInitializationExceptionIfNotConnected(); } return false; } }
private static void processNeverReferencedCollection(PersistentCollection coll, SessionImplementor session) throws HibernateException { final PersistenceContext persistenceContext = session.getPersistenceContext(); final CollectionEntry entry = persistenceContext.getCollectionEntry( coll ); if ( LOG.isDebugEnabled() ) { LOG.debugf( "Found collection with unloaded owner: %s", MessageHelper.collectionInfoString( entry.getLoadedPersister(), coll, entry.getLoadedKey(), session ) ); } entry.setCurrentPersister( entry.getLoadedPersister() ); entry.setCurrentKey( entry.getLoadedKey() ); prepareCollectionForUpdate( coll, entry, session.getFactory() ); }
@Override public void execute() throws HibernateException { // this QueuedOperationCollectionAction has to be executed before any other // CollectionAction involving the same collection. getPersister().processQueuedOps( getCollection(), getKey(), getSession() ); // TODO: It would be nice if this could be done safely by CollectionPersister#processQueuedOps; // Can't change the SPI to do this though. ((AbstractPersistentCollection) getCollection() ).clearOperationQueue(); // The other CollectionAction types call CollectionEntry#afterAction, which // clears the dirty flag. We don't want to call CollectionEntry#afterAction unless // there is no other CollectionAction that will be executed on the same collection. final CollectionEntry ce = getSession().getPersistenceContext().getCollectionEntry( getCollection() ); if ( !ce.isDoremove() && !ce.isDoupdate() && !ce.isDorecreate() ) { ce.afterAction( getCollection() ); } } }
@Override public void execute() throws HibernateException { // this method is called when a new non-null collection is persisted // or when an existing (non-null) collection is moved to a new owner final PersistentCollection collection = getCollection(); preRecreate(); getPersister().recreate( collection, getKey(), getSession() ); getSession().getPersistenceContext().getCollectionEntry( collection ).afterAction( collection ); evict(); postRecreate(); if ( getSession().getFactory().getStatistics().isStatisticsEnabled() ) { getSession().getFactory().getStatistics().recreateCollection( getPersister().getRole() ); } }
@Override public void execute() throws HibernateException { preRemove(); if ( !emptySnapshot ) { // an existing collection that was either non-empty or uninitialized // is replaced by null or a different collection // (if the collection is uninitialized, hibernate has no way of // knowing if the collection is actually empty without querying the db) getPersister().remove( getKey(), getSession() ); } final PersistentCollection collection = getCollection(); if ( collection != null ) { getSession().getPersistenceContext().getCollectionEntry( collection ).afterAction( collection ); } evict(); postRemove(); if ( getSession().getFactory().getStatistics().isStatisticsEnabled() ) { getSession().getFactory().getStatistics().removeCollection( getPersister().getRole() ); } }
persistenceContext.getCollectionEntry( collection ).postInitialize( collection );
SessionImplementor source = event.getSession(); CollectionEntry ce = source.getPersistenceContext().getCollectionEntry( collection ); if ( ce == null ) { throw new HibernateException( "collection was evicted" );
private static void processDereferencedCollection(PersistentCollection coll, SessionImplementor session) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final CollectionEntry entry = persistenceContext.getCollectionEntry( coll ); final CollectionPersister loadedPersister = entry.getLoadedPersister();
getSession().getPersistenceContext().getCollectionEntry( collection ).afterAction( collection ); evict(); postUpdate();