How to use

getFactory

method

in

org.hibernate.engine.spi.SessionImplementor

@Override
public SessionFactoryImplementor getFactory() {
  return delegate.getFactory();
}

@Override
public EntityManagerFactory getEntityManagerFactory() {
  return delegate.getFactory();
}

public String getCastType(Class javaType) {
  SessionFactoryImplementor factory = entityManager.getFactory();
  Type hibernateType = factory.getTypeResolver().heuristicType( javaType.getName() );
  if ( hibernateType == null ) {
    throw new IllegalArgumentException(
        "Could not convert java type [" + javaType.getName() + "] to Hibernate type"
    );
  }
  return hibernateType.getName();
}

private boolean isOrderUpdatesEnabled() {
  return session.getFactory().getSessionFactoryOptions().isOrderUpdatesEnabled();
}

private static int bindPositionalParameters(
    final PreparedStatement st,
    final Object[] values,
    final Type[] types,
    final int start,
    final SessionImplementor session) throws SQLException, HibernateException {
  int span = 0;
  for ( int i = 0; i < values.length; i++ ) {
    types[i].nullSafeSet( st, values[i], start + span, session );
    span += types[i].getColumnSpan( session.getFactory() );
  }
  return span;
}

private Queryable getQueryable(String entityName, SessionImplementor sessionImplementor) {
  return (Queryable) sessionImplementor.getFactory().getMetamodel().entityPersister( entityName );
}

private boolean isOrderInsertsEnabled() {
  return session.getFactory().getSessionFactoryOptions().isOrderInsertsEnabled();
}

  /**
   * @return Java class mapped to specified entity name.
   */
  public static Class getEntityClass(SessionImplementor sessionImplementor, String entityName) {
    final EntityPersister entityPersister = sessionImplementor.getFactory().getMetamodel().entityPersister( entityName );
    return entityPersister.getMappedClass();
  }
}

/**
 * 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 );
}

protected AbstractAuditQuery(
    EnversService enversService,
    AuditReaderImplementor versionsReader,
    Class<?> cls,
    String entityName) {
  this.enversService = enversService;
  this.versionsReader = versionsReader;
  criterions = new ArrayList<>();
  entityInstantiator = new EntityInstantiator( enversService, versionsReader );
  entityClassName = cls.getName();
  this.entityName = entityName;
  versionsEntityName = enversService.getAuditEntitiesConfiguration().getAuditEntityName( entityName );
  if ( !enversService.getEntitiesConfigurations().isVersioned( entityName ) ) {
    throw new NotAuditedException( entityName, "Entity [" + entityName + "] is not versioned" );
  }
  aliasToEntityNameMap.put( REFERENCED_ENTITY_ALIAS, entityName );
  qb = new QueryBuilder( versionsEntityName, REFERENCED_ENTITY_ALIAS, versionsReader.getSessionImplementor().getFactory() );
}

  protected void performSecurityCheck(
      SessionImplementor session,
      PermissionCheckEntityInformation entityInformation,
      PermissibleAction action) {
    if ( jaccService == null ) {
      jaccService = session.getFactory().getServiceRegistry().getService( JaccService.class );
    }
    jaccService.checkPermission( entityInformation, action );
  }
}

@Override
public boolean mapToMapFromEntity(
    SessionImplementor session,
    Map<String, Object> data,
    Object newObj,
    Object oldObj) {
  data.put( propertyData.getName(), newObj );
  boolean dbLogicallyDifferent = true;
  if ( (session.getFactory().getJdbcServices()
      .getDialect() instanceof Oracle8iDialect) && (newObj instanceof String || oldObj instanceof String) ) {
    // Don't generate new revision when database replaces empty string with NULL during INSERT or UPDATE statements.
    dbLogicallyDifferent = !(StringTools.isEmpty( newObj ) && StringTools.isEmpty( oldObj ));
  }
  return dbLogicallyDifferent && !areEqual( newObj, oldObj );
}

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

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

/**
 * This method is now called once per execution of an ExecutableList or once for execution of an Execution.
 *
 * @param spaces The spaces to invalidate
 */
private void invalidateSpaces(String... spaces) {
  if ( spaces != null && spaces.length > 0 ) {
    for ( Serializable s : spaces ) {
      if( afterTransactionProcesses == null ) {
        afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session );
      }
      afterTransactionProcesses.addSpaceToInvalidate( (String) s );
    }
    // Performance win: If we are processing an ExecutableList, this will only be called once
    session.getFactory().getCache().getTimestampsCache().preInvalidate( spaces, session );
  }
}

  /**
   * 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 );
    }
  }
}

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

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

private void registerCleanupActions(Executable executable) {
  if( executable.getBeforeTransactionCompletionProcess() != null ) {
    if( beforeTransactionProcesses == null ) {
      beforeTransactionProcesses = new BeforeTransactionCompletionProcessQueue( session );
    }
    beforeTransactionProcesses.register( executable.getBeforeTransactionCompletionProcess() );
  }
  if ( session.getFactory().getSessionFactoryOptions().isQueryCacheEnabled() ) {
    invalidateSpaces( convertTimestampSpaces( executable.getPropertySpaces() ) );
  }
  if( executable.getAfterTransactionCompletionProcess() != null ) {
    if( afterTransactionProcesses == null ) {
      afterTransactionProcesses = new AfterTransactionCompletionProcessQueue( session );
    }
    afterTransactionProcesses.register( executable.getAfterTransactionCompletionProcess() );
  }
}