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 ); } }
@Override public void doAction(boolean successful, SessionImplementor session) { if ( session.isClosed() ) { log.trace( "Session was closed; nothing to do" ); return; } if ( !successful && session.getTransactionCoordinator().getTransactionCoordinatorBuilder().isJta() ) { session.clear(); } } }
@Override public Connection connection() { return delegate.connection(); }
@Override public boolean shouldDoManagedFlush(SessionImplementor session) { if ( session.isClosed() ) { return false; } return session.getHibernateFlushMode() != FlushMode.MANUAL; } }
private static void processDereferencedCollection(PersistentCollection coll, SessionImplementor session) { final PersistenceContext persistenceContext = session.getPersistenceContext(); final CollectionEntry entry = persistenceContext.getCollectionEntry( coll ); final CollectionPersister loadedPersister = entry.getLoadedPersister(); 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( prepareCollectionForUpdate( coll, entry, session.getFactory() );
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 );
@Override public void afterTransaction(SessionImplementor session, boolean success) { TransactionCoordinator coordinator = session.getTransactionCoordinator(); if (!session.isTransactionInProgress() ) { session.getJdbcCoordinator().afterTransaction(); } if (coordinator instanceof JtaTransactionCoordinatorImpl) { ((JtaTransactionCoordinatorImpl) coordinator).getSynchronizationCallbackCoordinator().processAnyDelayedAfterCompletion(); } }
SessionImplementor source) { if ( !source.getLoadQueryInfluencers().getEnabledFilters().isEmpty() && persister.isAffectedByEnabledFilters( source ) ) { LOG.trace( "Disregarding cached version (if any) of collection due to enabled filters" ); 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 );
/** * Obtain a lob creator for the given session. * * @param session The session for which to obtain a lob creator * * @return The log creator reference */ public static LobCreator getLobCreator(SessionImplementor session) { return session.getFactory() .getServiceRegistry() .getService( JdbcServices.class ) .getLobCreator( session ); }
/** * make sure user didn't mangle the id */ public void checkId(Object object, EntityPersister persister, Serializable id, SessionImplementor session) throws HibernateException { if ( id != null && id instanceof DelayedPostInsertIdentifier ) { // this is a situation where the entity id is assigned by a post-insert generator // and was saved outside the transaction forcing it to be delayed return; } if ( persister.canExtractIdOutOfEntity() ) { Serializable oid = persister.getIdentifier( object, session ); if ( id == null ) { throw new AssertionFailure( "null id in " + persister.getEntityName() + " entry (don't flush the Session after an exception occurs)" ); } if ( !persister.getIdentifierType().isEqual( id, oid, session.getFactory() ) ) { throw new HibernateException( "identifier of an instance of " + persister.getEntityName() + " was altered from " + id + " to " + oid ); } } }
assertTrue( ( (SessionImplementor) session ).getPersistenceContext().containsEntity( new EntityKey( ( (SessionImplementor) session ).getContextEntityIdentifier( a2.getB() ), ( (SessionImplementor) session ).getFactory().getEntityPersister( B.class.getName() )
protected boolean invokeInterceptor( SessionImplementor session, Object entity, EntityEntry entry, final Object[] values, EntityPersister persister) { boolean isDirty = false; if ( entry.getStatus() != Status.DELETED ) { if ( callbackRegistry.preUpdate( entity ) ) { isDirty = copyState( entity, persister.getPropertyTypes(), values, session.getFactory() ); } } final boolean answerFromInterceptor = session.getInterceptor().onFlushDirty( entity, entry.getId(), values, entry.getLoadedState(), persister.getPropertyNames(), persister.getPropertyTypes() ); return answerFromInterceptor || isDirty; }
CriteriaImpl criteriaImpl = (CriteriaImpl)criteria; SessionImplementor session = criteriaImpl.getSession(); SessionFactoryImplementor factory = session.getFactory(); CriteriaQueryTranslator translator=new CriteriaQueryTranslator(factory,criteriaImpl,criteriaImpl.getEntityOrClassName(),CriteriaQueryTranslator.ROOT_SQL_ALIAS); String[] implementors = factory.getImplementors( criteriaImpl.getEntityOrClassName() ); CriteriaJoinWalker walker = new CriteriaJoinWalker((OuterJoinLoadable)factory.getEntityPersister(implementors[0]), translator, factory, criteriaImpl, criteriaImpl.getEntityOrClassName(), session.getLoadQueryInfluencers() ); String sql=walker.getSQLString();
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; }
/** * Create Hibernate proxy or retrieve the complete object of referenced, not audited entity. According to * {@link org.hibernate.envers.Audited#targetAuditMode()}} documentation, reference shall point to current * (non-historical) version of an entity. */ private Object createNotAuditedEntityReference( AuditReaderImplementor versionsReader, Class<?> entityClass, String entityName, Serializable primaryKey) { final EntityPersister entityPersister = versionsReader.getSessionImplementor().getFactory().getMetamodel() .entityPersister( entityName ); if ( entityPersister.hasProxy() ) { // If possible create a proxy. Returning complete object may affect performance. return versionsReader.getSession().load( entityClass, primaryKey ); } else { // If proxy is not allowed (e.g. @Proxy(lazy=false)) construct the original object. return versionsReader.getSession().get( entityClass, primaryKey ); } } }
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() );
public AddWorkUnit( SessionImplementor sessionImplementor, String entityName, EnversService enversService, Serializable id, Map<String, Object> data) { super( sessionImplementor, entityName, enversService, id, RevisionType.ADD ); this.data = data; final String[] propertyNames = sessionImplementor.getFactory().getMetamodel() .entityPersister( getEntityName() ) .getPropertyNames(); this.state = ArraysTools.mapToArray( data, propertyNames ); }
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(); PersistentCollection ah = persistenceContext.getCollectionHolder( collection ); if ( ah == null ) { ah = collectionType.wrap( session, collection ); persistenceContext.addNewCollection( persister, ah ); persistenceContext.addCollectionHolder( ah );
@Override protected CollectionInitializer createSubselectInitializer(SubselectFetch subselect, SessionImplementor session) { return new SubselectOneToManyLoader( this, subselect.toSubselectString( getCollectionType().getLHSPropertyName() ), subselect.getResult(), subselect.getQueryParameters(), subselect.getNamedParameterLocMap(), session.getFactory(), session.getLoadQueryInfluencers() ); }