How to use

SessionImplementor

in

org.hibernate.engine.spi

  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()
    );
}