private static void processDereferencedCollection(PersistentCollection coll, SessionImplementor session) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final CollectionEntry entry = persistenceContext.getCollectionEntry( coll ); final CollectionPersister loadedPersister = entry.getLoadedPersister(); final boolean hasOrphanDelete = loadedPersister != null && loadedPersister.hasOrphanDelete(); if ( hasOrphanDelete ) { Serializable ownerId = loadedPersister.getOwnerEntityPersister().getIdentifier( coll.getOwner(), session ); if ( ownerId == null ) { if ( session.getFactory().getSessionFactoryOptions().isIdentifierRollbackEnabled() ) { final EntityEntry ownerEntry = persistenceContext.getEntry( coll.getOwner() ); if ( ownerEntry != null ) { ownerId = ownerEntry.getId(); final EntityKey key = session.generateEntityKey( ownerId, loadedPersister.getOwnerEntityPersister() ); final Object owner = persistenceContext.getEntity( key ); if ( owner == null ) { throw new AssertionFailure( ); final EntityEntry e = persistenceContext.getEntry( owner );
final PersistenceContext persistenceContext = session.getPersistenceContext(); persistenceContext.getCollectionsByKey().clear(); persistenceContext.getBatchFetchQueue().clear(); for ( Map.Entry<PersistentCollection, CollectionEntry> me : IdentityMap.concurrentEntries( persistenceContext.getCollectionEntries() ) ) { CollectionEntry collectionEntry = me.getValue(); PersistentCollection persistentCollection = me.getKey(); persistenceContext.getCollectionEntries() .remove(persistentCollection); collectionEntry.getLoadedKey() ); persistenceContext.getCollectionsByKey().put(collectionKey, persistentCollection);
throws HibernateException, SQLException { final PersistenceContext persistenceContext = session.getPersistenceContext(); boolean defaultReadOnlyOrig = persistenceContext.isDefaultReadOnly(); if ( queryParameters.isReadOnlyInitialized() ) { persistenceContext.setDefaultReadOnly( queryParameters.isReadOnly() ); queryParameters.setReadOnly( persistenceContext.isDefaultReadOnly() ); persistenceContext.beforeLoad(); List result; try { persistenceContext.afterLoad(); persistenceContext.initializeNonLazyCollections(); persistenceContext.setDefaultReadOnly( defaultReadOnlyOrig );
private boolean existsInDatabase(Object entity, EventSource source, EntityPersister persister) { EntityEntry entry = source.getPersistenceContext().getEntry( entity ); if ( entry == null ) { Serializable id = persister.getIdentifier( entity, source ); if ( id != null ) { final EntityKey key = source.generateEntityKey( id, persister ); final Object managedEntity = source.getPersistenceContext().getEntity( key ); entry = source.getPersistenceContext().getEntry( managedEntity ); } } return entry != null && entry.isExistsInDatabase(); }
private boolean flushMightBeNeeded(final EventSource source) { return !source.getHibernateFlushMode().lessThan( FlushMode.AUTO ) && source.getDontFlushFromFind() == 0 && ( source.getPersistenceContext().getNumberOfManagedEntities() > 0 || source.getPersistenceContext().getCollectionEntries().size() > 0 ); } }
isTransient = !source.contains( event.getObject() ); if ( source.getPersistenceContext().reassociateIfUninitializedProxy( event.getObject() ) ) { if ( isTransient ) { source.setReadOnly( event.getObject(), source.isDefaultReadOnly() ); final Object object = source.getPersistenceContext().unproxyAndReassociate( event.getObject() ); final EntityEntry e = source.getPersistenceContext().getEntry( object ); final EntityPersister persister; final Serializable id; object final EntityKey key = source.generateEntityKey( id, persister ); if ( source.getPersistenceContext().getEntry( key ) != null ) { throw new PersistentObjectException( "attempted to refresh transient instance when persistent instance was already associated with the Session: " + final EntityKey key = source.generateEntityKey( id, persister ); source.getPersistenceContext().removeEntity( key ); if ( persister.hasCollections() ) { new EvictVisitor( source, object ).process( object, persister ); source.getPersistenceContext().getEntry( result ).setLockMode( postRefreshLockMode );
entityName = source.bestGuessEntityName( entity ); event.setEntityName( entityName ); final EntityEntry entityEntry = source.getPersistenceContext().getEntry( entity ); EntityState entityState = getEntityState( entity, entityName, entityEntry, source ); if ( entityState == EntityState.DETACHED ) { EntityPersister persister = source.getFactory().getEntityPersister( entityName ); if ( ForeignGenerator.class.isInstance( persister.getIdentifierGenerator() ) ) { if ( LOG.isDebugEnabled() && persister.getIdentifier( entity, source ) != null ) { LOG.debug( "Resetting entity id attribute to null for foreign generator" ); persister.setIdentifier( entity, null, source ); entityState = getEntityState( entity, entityName, entityEntry, source ); entityEntry.setStatus( Status.MANAGED ); entityEntry.setDeletedState( null ); event.getSession().getActionQueue().unScheduleDeletion( entityEntry, event.getObject() ); entityIsDeleted( event, createCache ); break;
SessionImplementor source) { if ( !source.getLoadQueryInfluencers().getEnabledFilters().isEmpty() && persister.isAffectedByEnabledFilters( source ) ) { LOG.trace( "Disregarding cached version (if any) of collection due to enabled filters" ); return false; final boolean useCache = persister.hasCache() && source.getCacheMode().isGetEnabled(); final SessionFactoryImplementor factory = source.getFactory(); final CollectionDataAccess cacheAccessStrategy = persister.getCacheAccessStrategy(); final Object ck = cacheAccessStrategy.generateCacheKey( id, persister, factory, source.getTenantIdentifier() ); final Object ce = CacheHelper.fromSharedCache( source, ck, persister.getCacheAccessStrategy() ); if ( factory.getStatistics().isStatisticsEnabled() ) { if ( ce == null ) { factory.getStatistics().collectionCacheMiss( persister.getNavigableRole(), cacheAccessStrategy.getRegion().getName() factory.getStatistics().collectionCacheHit( persister.getNavigableRole(), cacheAccessStrategy.getRegion().getName() final PersistenceContext persistenceContext = source.getPersistenceContext(); cacheEntry.assemble( collection, persister, persistenceContext.getCollectionOwner( id, persister ) ); persistenceContext.getCollectionEntry( collection ).postInitialize( collection );
final PersistenceContext persistenceContext = source.getPersistenceContext(); Object entity = persistenceContext.unproxyAndReassociate( event.getObject() ); EntityEntry entityEntry = persistenceContext.getEntry( entity ); final EntityPersister persister; final Serializable id; LOG.trace( "Entity was not persistent in delete processing" ); persister = source.getEntityPersister( event.getEntityName(), entity ); if ( ForeignKeys.isTransient( persister.getEntityName(), entity, null, source ) ) { deleteTransientEntity( source, entity, event.isCascadeDeleteEnabled(), persister, transientEntities ); id = persister.getIdentifier( entity, source ); final EntityKey key = source.generateEntityKey( id, persister ); persistenceContext.checkUniqueness( key, entity ); version = persister.getVersion( entity ); entityEntry = persistenceContext.addEntity( entity, (persister.isMutable() ? Status.MANAGED : Status.READ_ONLY), );
/** * Register the entity as batch loadable, if enabled */ @SuppressWarnings({ "JavaDoc" }) private void scheduleBatchLoadIfNeeded(Serializable id, SessionImplementor session) throws MappingException { //cannot batch fetch by unique key (property-ref associations) if ( uniqueKeyPropertyName == null && id != null ) { final EntityPersister persister = session.getFactory().getEntityPersister( getAssociatedEntityName() ); final EntityKey entityKey = session.generateEntityKey( id, persister ); if ( !session.getPersistenceContext().containsEntity( entityKey ) ) { session.getPersistenceContext().getBatchFetchQueue().addBatchLoadableEntityKey( entityKey ); } } }
@Override public final void setReadOnly(boolean readOnly) { errorIfReadOnlySettingNotAvailable(); // only update if readOnly is different from current setting if ( this.readOnly != readOnly ) { final EntityPersister persister = session.getFactory().getEntityPersister( entityName ); if ( ! persister.isMutable() && ! readOnly ) { throw new IllegalStateException( "cannot make proxies for immutable entities modifiable"); } this.readOnly = readOnly; if ( initialized ) { EntityKey key = generateEntityKeyOrNull( getIdentifier(), session, getEntityName() ); if ( key != null && session.getPersistenceContext().containsEntity( key ) ) { session.getPersistenceContext().setReadOnly( target, readOnly ); } } } }
if ( source.getPersistenceContext().reassociateIfUninitializedProxy( event.getObject() ) ) { LOG.trace( "Uninitialized proxy passed to replicate()" ); return; Object entity = source.getPersistenceContext().unproxyAndReassociate( event.getObject() ); if ( source.getPersistenceContext().isEntryFor( entity ) ) { LOG.trace( "Ignoring persistent instance passed to replicate()" ); Serializable id = persister.getIdentifier( entity, source ); if ( id == null ) { throw new TransientObjectException( "instance with null id passed to replicate()" ); oldVersion = persister.getCurrentVersion( id, source ); final Object realOldVersion = persister.isVersioned() ? oldVersion : null;
SessionImplementor session) { collection.setOwner( entity ); final CollectionEntry ce = session.getPersistenceContext().getCollectionEntry( collection ); final SessionFactoryImplementor factory = session.getFactory(); final CollectionPersister persister = factory.getMetamodel().collectionPersister( type.getRole() ); final boolean isBytecodeEnhanced = persister.getOwnerEntityPersister().getInstrumentationMetadata().isEnhancedForLazyLoading(); if ( isBytecodeEnhanced && !collection.wasInitialized() ) {
SessionImplementor source = event.getSession(); CollectionEntry ce = source.getPersistenceContext().getCollectionEntry( collection ); if ( ce == null ) { throw new HibernateException( "collection was evicted" ); LOG.trace( "Collection not cached" ); ce.getLoadedPersister().initialize( ce.getLoadedKey(), source ); if ( traceEnabled ) { LOG.trace( "Collection initialized" ); if ( source.getFactory().getStatistics().isStatisticsEnabled() ) { source.getFactory().getStatistics().fetchCollection( ce.getLoadedPersister().getRole() );
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; }
assertTrue( ( (SessionImplementor) session ).getPersistenceContext().containsEntity( new EntityKey( ( (SessionImplementor) session ).getContextEntityIdentifier( a2.getB() ), ( (SessionImplementor) session ).getFactory().getEntityPersister( B.class.getName() )
EntityKey entityKey, Object entityInstance) { final Object version = session.getPersistenceContext().getEntry( entityInstance ).getVersion(); VersionType versionType = persister.getVersionType(); final Object currentVersion; try { throw session.getFactory().getServiceRegistry().getService( JdbcServices.class ).getSqlExceptionHelper().convert( e, "Could not read version value from result set" if ( session.getFactory().getStatistics().isStatisticsEnabled() ) { session.getFactory().getStatistics().optimisticFailure( persister.getEntityName() ); throw new StaleObjectStateException( persister.getEntityName(), entityKey.getIdentifier() );
Object entity = source.getPersistenceContext().unproxyAndReassociate( event.getObject() ); EntityEntry entry = source.getPersistenceContext().getEntry(entity); if (entry==null) { final EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity ); final Serializable id = persister.getIdentifier( entity, source ); if ( !ForeignKeys.isNotTransient( event.getEntityName(), entity, Boolean.FALSE, source ) ) { throw new TransientObjectException( "cannot lock an unsaved transient instance: " + persister.getEntityName() );
private Session openTemporarySessionForLoading(PersistentCollection coll) { final SessionFactory sf = _sessionFactory; final Session session = sf.openSession(); PersistenceContext persistenceContext = ((SessionImplementor) session).getPersistenceContext(); persistenceContext.setDefaultReadOnly(true); session.setFlushMode(FlushMode.MANUAL); persistenceContext.addUninitializedDetachedCollection( ((SessionFactoryImplementor) _sessionFactory).getCollectionPersister(coll.getRole()), coll ); return session; }
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 ) ) ); }