How to use

SessionImpl

in

org.hibernate.impl

public Object load(String entityName, Serializable id) throws HibernateException {
  LoadEvent event = new LoadEvent(id, entityName, false, this);
  boolean success = false;
  try {
    fireLoad( event, LoadEventListener.LOAD );
    if ( event.getResult() == null ) {
      getFactory().getEntityNotFoundDelegate().handleEntityNotFound( entityName, id );
    }
    success = true;
    return event.getResult();
  }
  finally {
    afterOperation(success);
  }
}

public Session getSession(EntityMode entityMode) {
  if ( this.entityMode == entityMode ) {
    return this;
  }
  if ( rootSession != null ) {
    rootSession.getSession( entityMode );
  }
  errorIfClosed();
  checkTransactionSynchStatus();
  SessionImpl rtn = null;
  if ( childSessionsByEntityMode == null ) {
    childSessionsByEntityMode = new HashMap();
  }
  else {
    rtn = (SessionImpl) childSessionsByEntityMode.get( entityMode );
  }
  if ( rtn == null ) {
    rtn = new SessionImpl( this, entityMode );
    childSessionsByEntityMode.put( entityMode, rtn );
  }
  return rtn;
}

public ScrollableResults scroll(String query, QueryParameters queryParameters) throws HibernateException {
  errorIfClosed();
  checkTransactionSynchStatus();
  HQLQueryPlan plan = getHQLQueryPlan( query, false );
  autoFlushIfRequired( plan.getQuerySpaces() );
  dontFlushFromFind++;
  try {
    return plan.performScroll( queryParameters, this );
  }
  finally {
    dontFlushFromFind--;
  }
}

public List listFilter(Object collection, String filter, QueryParameters queryParameters) 
throws HibernateException {
  errorIfClosed();
  checkTransactionSynchStatus();
  FilterQueryPlan plan = getFilterQueryPlan( collection, filter, queryParameters, false );
  List results = CollectionHelper.EMPTY_LIST;
  boolean success = false;
  dontFlushFromFind++;   //stops flush being called multiple times if this method is recursively called
  try {
    results = plan.performList( queryParameters, this );
    success = true;
  }
  finally {
    dontFlushFromFind--;
    afterOperation(success);
  }
  return results;
}

public int delete(String query, Object[] values, Type[] types) throws HibernateException {
  errorIfClosed();
  checkTransactionSynchStatus();
  if ( query == null ) {
    throw new IllegalArgumentException("attempt to perform delete-by-query with null query");
  }
  if ( log.isTraceEnabled() ) {
    log.trace( "delete: " + query );
    if ( values.length != 0 ) {
      log.trace( "parameters: " + StringHelper.toString( values ) );
    }
  }
  List list = find( query, values, types );
  int deletionCount = list.size();
  for ( int i = 0; i < deletionCount; i++ ) {
    delete( list.get( i ) );
  }
  return deletionCount;
}

public ScrollableResults scroll(CriteriaImpl criteria, ScrollMode scrollMode) {
  errorIfClosed();
  checkTransactionSynchStatus();
  String entityName = criteria.getEntityOrClassName();
  CriteriaLoader loader = new CriteriaLoader(
      getOuterJoinLoadable(entityName),
      factory,
      criteria,
      entityName,
      getEnabledFilters()
  );
  autoFlushIfRequired( loader.getQuerySpaces() );
  dontFlushFromFind++;
  try {
    return loader.scroll(this, scrollMode);
  }
  finally {
    dontFlushFromFind--;
  }
}

      getOuterJoinLoadable( implementors[i] ),
      factory,
      criteria,
      implementors[i],
      getEnabledFilters()
  );
autoFlushIfRequired(spaces);
  afterOperation(success);

public EntityPersister getEntityPersister(final String entityName, final Object object) {
  errorIfClosed();
  if (entityName==null) {
    return factory.getEntityPersister( guessEntityName( object ) );
  }
  else {
    // try block is a hack around fact that currently tuplizers are not
    // given the opportunity to resolve a subclass entity name.  this
    // allows the (we assume custom) interceptor the ability to
    // influence this decision if we were not able to based on the
    // given entityName
    try {
      return factory.getEntityPersister( entityName )
          .getSubclassEntityPersister( object, getFactory(), entityMode );
    }
    catch( HibernateException e ) {
      try {
        return getEntityPersister( null, object );
      }
      catch( HibernateException e2 ) {
        throw e;
      }
    }
  }
}

public int executeNativeUpdate(NativeSQLQuerySpecification nativeQuerySpecification,
    QueryParameters queryParameters) throws HibernateException {
  errorIfClosed();
  checkTransactionSynchStatus();
  queryParameters.validateParameters();
  NativeSQLQueryPlan plan = getNativeSQLQueryPlan(nativeQuerySpecification);
  
  autoFlushIfRequired( plan.getCustomQuery().getQuerySpaces() );
  
  boolean success = false;
  int result = 0;
  try {
    result = plan.performExecuteUpdate(queryParameters, this);
    success = true;
  } finally {
    afterOperation(success);
  }
  return result;
}

public List listCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) 
throws HibernateException {
  if ( log.isTraceEnabled() ) log.trace( "SQL query: " + customQuery.getSQL() );
  
  CustomLoader loader = new CustomLoader( customQuery, getFactory() );
  autoFlushIfRequired( loader.getQuerySpaces() );
  dontFlushFromFind++;
  boolean success = false;
  try {
    List results = loader.list(this, queryParameters);
    success = true;
    return results;
  }
  finally {
    dontFlushFromFind--;
    afterOperation(success);
  }
}

flush();
entry = persistenceContext.getCollectionEntryOrNull(collection);
CollectionPersister roleAfterFlush = (entry == null) ? null : entry.getLoadedPersister();
if ( roleAfterFlush == null ) throw new QueryException( "The collection was unreferenced" );
filterTranslator = factory.getFilter( filter, roleAfterFlush.getRole(), scalar, getEnabledFilters() );
filterTranslator = factory.getFilter( filter, roleBeforeFlush.getRole(), scalar, getEnabledFilters() );
if ( autoFlushIfRequired( filterTranslator.getQuerySpaces() ) ) {
  if ( roleBeforeFlush != roleAfterFlush ) {
    if ( roleAfterFlush == null ) throw new QueryException( "The collection was dereferenced" );
    filterTranslator = factory.getFilter( filter, roleAfterFlush.getRole(), scalar, getEnabledFilters() );

public ScrollableResults scroll(CriteriaImpl criteria, ScrollMode scrollMode) {
  String entityName = criteria.getEntityOrClassName();
  CriteriaLoader loader = new CriteriaLoader(
      getOuterJoinLoadable(entityName),
      factory,
      criteria,
      entityName,
      getEnabledFilters()
  );
  autoFlushIfRequired( loader.getQuerySpaces() );
  dontFlushFromFind++;
  try {
    return loader.scroll(this, scrollMode);
  }
  finally {
    dontFlushFromFind--;
  }
}

public Connection close() throws HibernateException {
  log.trace( "closing session" );
  if ( isClosed() ) {
    throw new SessionException( "Session was already closed" );
        while ( childSessions.hasNext() ) {
          final SessionImpl child = ( SessionImpl ) childSessions.next();
          child.close();
    setClosed();
    cleanup();

public Object get(String entityName, Serializable id) throws HibernateException {
  LoadEvent event = new LoadEvent(id, entityName, false, this);
  boolean success = false;
  try {
    fireLoad(event, LoadEventListener.GET);
    success = true;
    return event.getResult();
  }
  finally {
    afterOperation(success);
  }
}

public EntityPersister getEntityPersister(final String entityName, final Object object) {
  if (entityName==null) {
    return factory.getEntityPersister( guessEntityName(object) );
  }
  else {
    return factory.getEntityPersister( entityName ).getSubclassEntityPersister( object, getFactory(), entityMode );
  }
}

public ScrollableResults scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) 
throws HibernateException {
  if ( log.isTraceEnabled() ) {
    log.trace( "scroll SQL query: " + customQuery.getSQL() );
  }
  CustomLoader loader = new CustomLoader( customQuery, getFactory() );
  autoFlushIfRequired( loader.getQuerySpaces() );
  dontFlushFromFind++; //stops flush being called multiple times if this method is recursively called
  try {
    return loader.scroll(queryParameters, this);
  }
  finally {
    dontFlushFromFind--;
  }
}

public void forceFlush(EntityEntry e) throws HibernateException {
  if ( log.isDebugEnabled() ) {
    log.debug(
      "flushing to force deletion of re-saved object: " +
      MessageHelper.infoString( e.getPersister(), e.getId(), getFactory() )
    );
  }
  if ( persistenceContext.getCascadeLevel() > 0 ) {
    throw new ObjectDeletedException(
      "deleted object would be re-saved by cascade (remove deleted object from associations)",
      e.getId(),
      e.getPersister().getEntityName()
    );
  }
  flush();
}

public int delete(String query, Object[] values, Type[] types) throws HibernateException {
  if ( query == null ) {
    throw new IllegalArgumentException("attempt to perform delete-by-query with null query");
  }
  if ( log.isTraceEnabled() ) {
    log.trace( "delete: " + query );
    if ( values.length != 0 ) {
      log.trace( "parameters: " + StringHelper.toString( values ) );
    }
  }
  List list = find( query, values, types );
  int deletionCount = list.size();
  for ( int i = 0; i < deletionCount; i++ ) {
    delete( list.get( i ) );
  }
  return deletionCount;
}

  @SuppressWarnings("unchecked")
  @Transactional
  public void createSequence(String sequenceName, Integer initialValue,
      Integer incrementSize) {
    SessionImpl imp = (SessionImpl) entityManager.getDelegate();
    String sa = imp.getFactory().getDialect().getQuerySequencesString();
    List<String> sequences = entityManager.createNativeQuery(sa)
        .getResultList();
    for (String sequence : sequences) {
      if (sequence.toLowerCase().equals(sequenceName.toLowerCase())) {
        return;
      }
    }
    String sql = imp.getFactory().getDialect().getCreateSequenceStrings(
        sequenceName, initialValue, incrementSize)[0];
    entityManager.createNativeQuery(sql).executeUpdate();
  }
}

/**
 * Load the data for the object with the specified id into a newly created object.
 * This is only called when lazily initializing a proxy.
 * Do NOT return a proxy.
 */
public Object immediateLoad(String entityName, Serializable id) throws HibernateException {
  if ( log.isDebugEnabled() ) {
    EntityPersister persister = getFactory().getEntityPersister(entityName);
    log.debug( "initializing proxy: " + MessageHelper.infoString( persister, id, getFactory() ) );
  }
  
  LoadEvent event = new LoadEvent(id, entityName, true, this);
  fireLoad(event, LoadEventListener.IMMEDIATE_LOAD);
  return event.getResult();
}