public CriteriaImpl(System.Type persistentClass, SessionImpl session)
{
this.persistentClass = persistentClass;
this.session = session;
this.classByAlias[CriteriaUtil.RootAlias] = persistentClass;
this.cacheable = false;
}
protected override object ProcessCollection(object collection, PersistentCollectionType type)
{
SessionImpl session = Session;
object key = Key;
ICollectionPersister persister = session.GetCollectionPersister(type.Role);
session.RemoveCollection(persister, key);
if (collection != null && (collection is PersistentCollection))
{
PersistentCollection wrapper = collection as PersistentCollection;
wrapper.SetCurrentSession(session);
if (wrapper.WasInitialized)
{
session.AddNewCollection(wrapper, persister);
}
else
{
session.ReattachCollection(wrapper, wrapper.CollectionSnapshot);
}
}
else
{
// otherwise a null or brand new collection
// this will also (inefficiently) handle arrays, which
// have no snapshot, so we can't do any better
//processArrayOrNewCollection(collection, type);
}
return(null);
}
protected override object ProcessCollection(object collection, PersistentCollectionType type)
{
if (collection != null)
{
SessionImpl session = Session;
PersistentCollection coll;
if (type.IsArrayType)
{
coll = session.GetArrayHolder(collection);
// if no array holder we found an unwrappered array (this can't occur,
// because we now always call wrap() before getting to here)
// return (ah==null) ? true : searchForDirtyCollections(ah, type);
}
else
{
// if not wrappered yet, its dirty (this can't occur, because
// we now always call wrap() before getting to here)
// return ( ! (obj is PersistentCollection) ) ?
// true : SearchForDirtyCollections( (PersistentCollection) obj, type );
coll = (PersistentCollection)collection;
}
if (session.CollectionIsDirty(coll))
{
_dirty = true;
return(null); // NOTE: early exit
}
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiCriteriaImpl"/> class.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="factory">The factory.</param>
internal MultiCriteriaImpl(SessionImpl session, ISessionFactoryImplementor factory)
{
IDriver driver = session.Factory.ConnectionProvider.Driver;
dialect = session.Factory.Dialect;
resultSetsCommand = driver.GetResultSetsCommand(session);
this.session = session;
this.factory = factory;
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiCriteriaImpl"/> class.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="factory">The factory.</param>
internal MultiCriteriaImpl(SessionImpl session, SessionFactoryImpl factory)
{
dialect = session.Factory.Dialect;
if (!session.Factory.ConnectionProvider.Driver.SupportsMultipleQueries)
{
throw new NotSupportedException(
string.Format("The dialect {0} does not support multiple queries.", dialect.GetType().FullName));
}
this.session = session;
this.factory = factory;
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiCriteriaImpl"/> class.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="factory">The factory.</param>
internal MultiCriteriaImpl(SessionImpl session, ISessionFactoryImplementor factory)
{
IDriver driver = session.Factory.ConnectionProvider.Driver;
if (!driver.SupportsMultipleQueries)
{
throw new NotSupportedException(
string.Format("The driver {0} does not support multiple queries.", driver.GetType().FullName));
}
dialect = session.Factory.Dialect;
this.session = session;
this.factory = factory;
}
private SessionImpl OpenSession(IDbConnection connection, bool autoClose, long timestamp, IInterceptor sessionLocalInterceptor)
{
SessionImpl session = new SessionImpl(connection, this, autoClose, timestamp, sessionLocalInterceptor ?? interceptor,
settings.DefaultEntityMode, settings.IsFlushBeforeCompletionEnabled,
settings.IsAutoCloseSessionEnabled, settings.ConnectionReleaseMode);
if (sessionLocalInterceptor != null)
{
// NH specific feature
sessionLocalInterceptor.SetSession(session);
}
return(session);
}
protected override object ProcessCollection(object collection, PersistentCollectionType type)
{
ICollectionPersister persister = Session.GetCollectionPersister(type.Role);
if (collection == null)
{
// Do nothing
}
else if (collection is PersistentCollection)
{
PersistentCollection coll = (PersistentCollection)collection;
if (coll.SetCurrentSession(Session))
{
ICollectionSnapshot snapshot = coll.CollectionSnapshot;
if (SessionImpl.IsOwnerUnchanged(snapshot, persister, this.Key))
{
// a "detached" collection that originally belonged to the same entity
if (snapshot.Dirty)
{
throw new HibernateException("reassociated object has dirty collection");
}
Session.ReattachCollection(coll, snapshot);
}
else
{
// a "detached" collection that belonged to a different entity
throw new HibernateException("reassociated object has dirty collection reference");
}
}
else
{
// a collection loaded in the current session
// can not possibly be the collection belonging
// to the entity passed to update()
throw new HibernateException("reassociated object has dirty collection reference");
}
}
else
{
// brand new collection
//TODO: or an array!! we can't lock objects with arrays now??
throw new HibernateException("reassociated object has dirty collection reference");
}
return(null);
}
private SessionImpl OpenSession(IDbConnection connection, bool autoClose, long timestamp, IInterceptor sessionLocalInterceptor)
{
#pragma warning disable 618
var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled;
#pragma warning restore 618
SessionImpl session = new SessionImpl(connection, this, autoClose, timestamp, sessionLocalInterceptor ?? interceptor,
settings.DefaultEntityMode, settings.IsFlushBeforeCompletionEnabled,
settings.IsAutoCloseSessionEnabled, isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled,
settings.ConnectionReleaseMode);
if (sessionLocalInterceptor != null)
{
// NH specific feature
sessionLocalInterceptor.SetSession(session);
}
return(session);
}
protected override object ProcessCollection(object collection, PersistentCollectionType type)
{
ICollectionPersister persister = Session.GetCollectionPersister(type.Role);
if (collection is PersistentCollection)
{
PersistentCollection wrapper = (PersistentCollection)collection;
if (wrapper.SetCurrentSession(Session))
{
//a "detached" collection!
ICollectionSnapshot snapshot = wrapper.CollectionSnapshot;
if (!SessionImpl.IsOwnerUnchanged(snapshot, persister, Key))
{
// if the collection belonged to a different entity,
// clean up the existing state of the collection
Session.RemoveCollection(persister, Key);
}
Session.ReattachCollection(wrapper, snapshot);
}
else
{
// a collection loaded in the current session
// can not possibly be the collection belonging
// to the entity passed to update()
Session.RemoveCollection(persister, Key);
}
}
else
{
// null or brand new collection
// this will also (inefficiently) handle arrays, which have
// no snapshot, so we can't do any better
Session.RemoveCollection(persister, Key);
//processArrayOrNewCollection(collection, type);
}
return(null);
}
/// <summary>
/// Copy all the internal attributes of the given CriteriaImpl
/// except alter the root persistent class type to be the given one.
/// </summary>
/// <param name="persistentClass"></param>
/// <param name="original"></param>
public CriteriaImpl(System.Type persistentClass, CriteriaImpl original)
{
this.persistentClass = persistentClass;
this.classByAlias = original.classByAlias;
this.classByAlias[CriteriaUtil.RootAlias] = persistentClass;
this.criteria = original.criteria;
this.orderings = original.orderings;
this.fetchModes = original.fetchModes;
this.associationPathByAlias = original.associationPathByAlias;
this.aliasByAssociationPath = original.aliasByAssociationPath;
this.lockModes = original.lockModes;
this.maxResults = original.maxResults;
this.firstResult = original.firstResult;
this.timeout = original.timeout;
this.fetchSize = original.fetchSize;
this.session = original.session;
this.resultTransformer = original.resultTransformer;
this.counter = original.counter;
this.cacheable = original.cacheable;
this.cacheRegion = original.cacheRegion;
}
private ISession OpenSession(IDbConnection connection, long timestamp, IInterceptor interceptor,
ConnectionReleaseMode connectionReleaseMode)
{
SessionImpl sessionImpl = new SessionImpl(connection, this, timestamp, interceptor, connectionReleaseMode);
bool isSessionScopedInterceptor = this.interceptor!=interceptor;
if(isSessionScopedInterceptor)
interceptor.SetSession(sessionImpl);
return sessionImpl;
}
public ProxyVisitor(SessionImpl session) : base(session)
{
}
public ReattachVisitor(SessionImpl session, object key)
: base(session)
{
_key = key;
}
public WrapVisitor(SessionImpl session) : base(session)
{
}
private SessionImpl OpenSession(IDbConnection connection, bool autoClose, long timestamp, IInterceptor sessionLocalInterceptor)
{
#pragma warning disable 618
var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled;
#pragma warning restore 618
SessionImpl session = new SessionImpl(connection, this, autoClose, timestamp, sessionLocalInterceptor ?? interceptor,
settings.DefaultEntityMode, settings.IsFlushBeforeCompletionEnabled,
settings.IsAutoCloseSessionEnabled, isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled,
settings.ConnectionReleaseMode, settings.DefaultFlushMode);
if (sessionLocalInterceptor != null)
{
// NH specific feature
sessionLocalInterceptor.SetSession(session);
}
return session;
}
public EvictVisitor(SessionImpl session)
: base(session)
{
}
public DirtyCollectionSearchVisitor(SessionImpl session)
: base(session)
{
}
public FlushVisitor(SessionImpl session, object owner)
: base(session)
{
_owner = owner;
}
private SessionImpl OpenSession(IDbConnection connection, bool autoClose, long timestamp, IInterceptor sessionLocalInterceptor)
{
SessionImpl session = new SessionImpl(connection, this, autoClose, timestamp, sessionLocalInterceptor ?? interceptor,
settings.DefaultEntityMode, settings.IsFlushBeforeCompletionEnabled,
settings.IsAutoCloseSessionEnabled, settings.ConnectionReleaseMode);
if (sessionLocalInterceptor != null)
{
// NH specific feature
sessionLocalInterceptor.SetSession(session);
}
return session;
}
protected FutureBatch(SessionImpl session)
{
this.session = session;
}
public WrapVisitor(SessionImpl session) : base(session)
{
}
public ReattachVisitor(SessionImpl session, object key)
: base( session )
{
_key = key;
}
public DirtyCollectionSearchVisitor(SessionImpl session)
: base( session )
{
}
protected AbstractVisitor(SessionImpl session)
{
_session = session;
}
public DirtyCollectionSearchVisitor(SessionImpl session, bool[] propertyVersionability)
: base(session)
{
_propertyVersionability = propertyVersionability;
}
public OnReplicateVisitor( SessionImpl session, object key ) : base( session, key )
{
}
public OnLockVisitor(SessionImpl session, object key)
: base(session, key)
{
}
public OnUpdateVisitor(SessionImpl session, object key)
: base(session, key)
{
}
public EvictVisitor(SessionImpl session)
: base( session )
{
}
public FutureCriteriaBatch(SessionImpl session) : base(session)
{
}
public ProxyVisitor(SessionImpl session) : base(session)
{
}
public FutureQueryBatch(SessionImpl session) : base(session)
{
}
protected AbstractVisitor(SessionImpl session)
{
_session = session;
}
public FlushVisitor(SessionImpl session, object owner)
: base(session)
{
_owner = owner;
}
public OnLockVisitor(SessionImpl session, object key)
: base(session, key)
{
}