@Override public PersistenceContext getPersistenceContext() { return delegate.getPersistenceContext(); }
public Set getEntityKeys() { return Collections.unmodifiableSet( session.getPersistenceContext().getEntitiesByKey().keySet() ); }
public Set getCollectionKeys() { return Collections.unmodifiableSet( session.getPersistenceContext().getCollectionsByKey().keySet() ); }
public int getCollectionCount() { return session.getPersistenceContext().getCollectionEntries().size(); }
public int getEntityCount() { return session.getPersistenceContext().getNumberOfManagedEntities(); }
protected boolean reassociateIfUninitializedProxy(Object object, SessionImplementor source) { return source.getPersistenceContext().reassociateIfUninitializedProxy( object ); }
protected void postPostFlush(SessionImplementor session) { session.getInterceptor().postFlush( new LazyIterator( session.getPersistenceContext().getEntitiesByKey() ) ); } }
private void checkEmptyAuditSessionCache(Session session, String... auditEntityNames) { List<String> entityNames = Arrays.asList( auditEntityNames ); PersistenceContext persistenceContext = ((SessionImplementor) session).getPersistenceContext(); for ( Map.Entry<Object, EntityEntry> entrySet : persistenceContext.reentrantSafeEntityEntries() ) { final EntityEntry entityEntry = entrySet.getValue(); if ( entityNames.contains( entityEntry.getEntityName() ) ) { assert false : "Audit data shall not be stored in the session level cache. This causes performance issues."; } Assert.assertFalse( "Revision entity shall not be stored in the session level cache. This causes performance issues.", SequenceIdRevisionEntity.class.getName().equals( entityEntry.getEntityName() ) ); } } }
Object processCollection(Object collection, CollectionType type) throws HibernateException { if ( collection != null ) { final SessionImplementor session = getSession(); final PersistentCollection persistentCollection; if ( type.isArrayType() ) { persistentCollection = session.getPersistenceContext().getCollectionHolder( collection ); // if no array holder we found an unwrappered array (this can't occur, // because we now always call wrap() before getting to here) // return (ah==null) ? true : searchForDirtyCollections(ah, type); } else { // if not wrappered yet, its dirty (this can't occur, because // we now always call wrap() before getting to here) // return ( ! (obj instanceof PersistentCollection) ) ? //true : searchForDirtyCollections( (PersistentCollection) obj, type ); persistentCollection = (PersistentCollection) collection; } if ( persistentCollection.isDirty() ) { //we need to check even if it was not initialized, because of delayed adds! dirty = true; return null; //NOTE: EARLY EXIT! } } return null; }
/** * Constructs an EntityDeleteAction. * * @param id The entity identifier * @param state The current (extracted) entity state * @param version The current entity version * @param instance The entity instance * @param persister The entity persister * @param isCascadeDeleteEnabled Whether cascade delete is enabled * @param session The session */ public EntityDeleteAction( final Serializable id, final Object[] state, final Object version, final Object instance, final EntityPersister persister, final boolean isCascadeDeleteEnabled, final SessionImplementor session) { super( session, id, instance, persister ); this.version = version; this.isCascadeDeleteEnabled = isCascadeDeleteEnabled; this.state = state; // before remove we need to remove the local (transactional) natural id cross-reference naturalIdValues = session.getPersistenceContext().getNaturalIdHelper().removeLocalNaturalIdCrossReference( getPersister(), getId(), state ); }
final PersistenceContext persistenceContext = session.getPersistenceContext(); persistenceContext.getCollectionsByKey().clear();
private Object[] getDatabaseSnapshot(SessionImplementor session, EntityPersister persister, Serializable id) { if ( persister.isSelectBeforeUpdateRequired() ) { Object[] snapshot = session.getPersistenceContext() .getDatabaseSnapshot( id, persister ); if ( snapshot == null ) { //do we even really need this? the update will fail anyway.... if ( session.getFactory().getStatistics().isStatisticsEnabled() ) { session.getFactory().getStatistics() .optimisticFailure( persister.getEntityName() ); } throw new StaleObjectStateException( persister.getEntityName(), id ); } return snapshot; } // TODO: optimize away this lookup for entities w/o unsaved-value="undefined" final EntityKey entityKey = session.generateEntityKey( id, persister ); return session.getPersistenceContext().getCachedDatabaseSnapshot( entityKey ); } }
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; }
/** * Handle the given update event. * * @param event The update event to be handled. */ public void onSaveOrUpdate(SaveOrUpdateEvent event) { final SessionImplementor source = event.getSession(); final Object object = event.getObject(); final Serializable requestedId = event.getRequestedId(); if ( requestedId != null ) { //assign the requested id to the proxy, *before* //reassociating the proxy if ( object instanceof HibernateProxy ) { ( (HibernateProxy) object ).getHibernateLazyInitializer().setIdentifier( requestedId ); } } // For an uninitialized proxy, noop, don't even need to return an id, since it is never a save() if ( reassociateIfUninitializedProxy( object, source ) ) { LOG.trace( "Reassociated uninitialized proxy" ); } else { //initialize properties of the event: final Object entity = source.getPersistenceContext().unproxyAndReassociate( object ); event.setEntity( entity ); event.setEntry( source.getPersistenceContext().getEntry( entity ) ); //return the id in the event object event.setResultId( performSaveOrUpdate( event ) ); } }
Object entity = source.getPersistenceContext().unproxyAndReassociate( event.getObject() ); EntityEntry entry = source.getPersistenceContext().getEntry(entity); if (entry==null) { final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity );
for ( Object entity : ( (SessionImplementor) s ).getPersistenceContext().getEntitiesByKey().values() ) { if ( Parent.class.isInstance( entity ) ) { if ( entity != p ) {
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() ); }
private static void checkInBatchFetchQueue(long id, Session session, boolean expected) { final SessionImplementor sessionImplementor = (SessionImplementor) session; final EntityPersister persister = sessionImplementor.getFactory().getMetamodel().entityPersister( Task.class ); final BatchFetchQueue batchFetchQueue = sessionImplementor.getPersistenceContext().getBatchFetchQueue(); assertEquals( expected, batchFetchQueue.containsEntityKey( new EntityKey( id, persister ) ) ); }
CollectionPersister persister = session.getFactory().getCollectionPersister( collectionType.getRole() ); final PersistenceContext persistenceContext = session.getPersistenceContext();
assertTrue( ( (SessionImplementor) session ).getPersistenceContext().containsEntity( new EntityKey( ( (SessionImplementor) session ).getContextEntityIdentifier( a2.getB() ),