public SQLQueryCollectionReturn(string alias, string ownerClass, string ownerProperty, IDictionary propertyResults,
LockMode lockMode)
: base(alias, propertyResults, lockMode)
{
this.ownerEntityName = ownerClass;
this.ownerProperty = ownerProperty;
}
protected void InitAll(
SqlString whereString,
string orderByString,
LockMode lockMode)
{
WalkEntityTree(persister, Alias);
IList allAssociations = new ArrayList();
foreach (object obj in associations)
{
allAssociations.Add(obj);
}
allAssociations.Add(
new OuterJoinableAssociation(
persister.EntityType,
null,
null,
alias,
JoinType.LeftOuterJoin,
Factory,
CollectionHelper.EmptyMap
));
InitPersisters(allAssociations, lockMode);
InitStatementString(whereString, orderByString, lockMode);
}
private void wait(LockMode mode)
{
WaitContext ctx;
lock (typeof(PersistentResource))
{
ctx = freeContexts;
if (ctx == null)
{
ctx = new WaitContext();
}
else
{
freeContexts = ctx.next;
}
ctx.next = null;
}
if (queueStart != null)
{
queueEnd = queueEnd.next = ctx;
}
else
{
queueStart = queueEnd = ctx;
}
ctx.mode = mode;
Monitor.Exit(this);
ctx.evt.WaitOne();
lock (typeof(PersistentResource))
{
ctx.next = freeContexts;
freeContexts = ctx;
}
}
public EntityLoader(
IOuterJoinLoadable persister,
string[] uniqueKey,
IType uniqueKeyType,
int batchSize,
LockMode lockMode,
ISessionFactoryImplementor factory,
IDictionary enabledFilters)
: base(persister, uniqueKeyType, factory, enabledFilters)
{
JoinWalker walker = new EntityJoinWalker(
persister,
uniqueKey,
uniqueKeyType,
batchSize,
lockMode,
factory,
enabledFilters
);
InitFromWalker(walker);
PostInstantiate();
batchLoader = batchSize > 1;
log.Debug("Static select for entity " + entityName + ": " + SqlString);
}
protected void InitProjection(SqlString projectionString, SqlString whereString,
string orderByString, string groupByString, LockMode lockMode)
{
WalkEntityTree(persister, Alias);
Persisters = new ILoadable[0];
InitStatementString(projectionString, whereString, orderByString, groupByString, lockMode);
}
private void InitStatementString(SqlString projection,SqlString condition,
string orderBy,string groupBy,LockMode lockMode)
{
int joins = CountEntityPersisters(associations);
Suffixes = BasicLoader.GenerateSuffixes(joins + 1);
JoinFragment ojf = MergeOuterJoins(associations);
SqlString selectClause = projection
??
new SqlString(persister.SelectFragment(alias, Suffixes[joins]) + SelectString(associations));
SqlSelectBuilder select = new SqlSelectBuilder(Factory)
.SetLockMode(lockMode)
.SetSelectClause(selectClause)
.SetFromClause(Dialect.AppendLockHint(lockMode, persister.FromTableFragment(alias)) +persister.FromJoinFragment(alias, true, true))
.SetWhereClause(condition)
.SetOuterJoins(ojf.ToFromFragmentString,ojf.ToWhereFragmentString + WhereFragment)
.SetOrderByClause(OrderBy(associations, orderBy))
.SetGroupByClause(groupBy);
if (Factory.Settings.IsCommentsEnabled)
select.SetComment(Comment);
SqlString = select.ToSqlString();
}
public CollectionFetchReturn(string alias, NonScalarReturn owner, string ownerProperty,
ICollectionAliases collectionAliases, IEntityAliases elementEntityAliases,
LockMode lockMode) : base(owner, ownerProperty, alias, lockMode)
{
this.collectionAliases = collectionAliases;
this.elementEntityAliases = elementEntityAliases;
}
public SQLQueryJoinReturn(string alias, string ownerAlias, string ownerProperty, IDictionary propertyResults,
LockMode lockMode)
: base(alias, propertyResults, lockMode)
{
this.ownerAlias = ownerAlias;
this.ownerProperty = ownerProperty;
}
public RefreshEvent(object entity, LockMode lockMode, IEventSource source)
: this(entity, source)
{
if (lockMode == null)
throw new ArgumentNullException("lockMode", "Attempt to generate refresh event with null lock mode");
this.lockMode = lockMode;
}
public SimpleEntityLoader( ILoadable persister, SqlString sql, LockMode lockMode )
{
this.persister = new ILoadable[ ] {persister};
this.idType = persister.IdentifierType;
this.sql = sql;
this.lockMode = new LockMode[ ] {lockMode};
PostInstantiate();
}
public EntityLoader(
IOuterJoinLoadable persister,
LockMode lockMode,
ISessionFactoryImplementor factory,
IDictionary enabledFilters)
: this(persister, 1, lockMode, factory, enabledFilters)
{
}
private void InitStatementString(
SqlString condition,
string orderBy,
LockMode lockMode)
{
InitStatementString(null, condition, orderBy, "", lockMode);
}
public CollectionReturn(string alias, string ownerEntityName, string ownerProperty,
ICollectionAliases collectionAliases, IEntityAliases elementEntityAliases, LockMode lockMode)
: base(alias, lockMode)
{
this.ownerEntityName = ownerEntityName;
this.ownerProperty = ownerProperty;
this.collectionAliases = collectionAliases;
this.elementEntityAliases = elementEntityAliases;
}
public static LockMode[] FillArray(LockMode lockMode, int length)
{
LockMode[] result = new LockMode[length];
for (int i = 0; i < length; i++)
{
result[i] = lockMode;
}
return result;
}
public NonScalarReturn(string alias, LockMode lockMode)
{
this.alias = alias;
if (alias == null)
{
throw new HibernateException("alias must be specified");
}
this.lockMode = lockMode;
}
/**
* Construct a SetLockModeEvent
*
* @param methodSig tells us which overload of setLockMode to use
* @param lockMode the lock mode we'll set when the event fires
* @param alias the alias for which we'll set the lcok mode when the event
* fires. Can be null.
*/
private SetLockModeEvent(
MethodSig methodSig,
LockMode lockMode,
/*@Nullable*/ string alias)
{
this.methodSig = methodSig;
this.lockMode = lockMode;
this.alias = alias;
}
/// <summary>
/// .ctor
/// </summary>
/// <param name="alock">Lock to handle</param>
/// <param name="timeout">timeout to acquire lock</param>
/// <param name="mode">Lock mode</param>
public DisposableReaderWriterLock(ReaderWriterLock alock, TimeSpan timeout, LockMode mode = LockMode.Read)
{
ParametersValidator.IsNotNull(alock, ()=>alock);
_lock = alock;
_timeout = timeout;
_mode = mode;
AcquireLock();
Logger.TraceFormat("lock created timeout={0}, mode ={1}", timeout, mode);
}
/// <summary>
/// Performs a pessimistic lock upgrade on a given entity, if needed.
/// </summary>
/// <param name="entity">The entity for which to upgrade the lock.</param>
/// <param name="entry">The entity's EntityEntry instance.</param>
/// <param name="requestedLockMode">The lock mode being requested for locking. </param>
/// <param name="source">The session which is the source of the event being processed.</param>
protected virtual void UpgradeLock(object entity, EntityEntry entry, LockMode requestedLockMode, ISessionImplementor source)
{
if (requestedLockMode.GreaterThan(entry.LockMode))
{
// The user requested a "greater" (i.e. more restrictive) form of
// pessimistic lock
if (entry.Status != Status.Loaded)
{
throw new ObjectDeletedException("attempted to lock a deleted instance", entry.Id, entry.EntityName);
}
IEntityPersister persister = entry.Persister;
if (log.IsDebugEnabled)
{
log.Debug(string.Format("locking {0} in mode: {1}", MessageHelper.InfoString(persister, entry.Id, source.Factory), requestedLockMode));
}
ISoftLock slock;
CacheKey ck;
if (persister.HasCache)
{
ck = new CacheKey(entry.Id, persister.IdentifierType, persister.RootEntityName, source.EntityMode, source.Factory);
slock = persister.Cache.Lock(ck, entry.Version);
}
else
{
ck = null;
slock = null;
}
try
{
if (persister.IsVersioned && requestedLockMode == LockMode.Force)
{
// todo : should we check the current isolation mode explicitly?
object nextVersion = persister.ForceVersionIncrement(entry.Id, entry.Version, source);
entry.ForceLocked(entity, nextVersion);
}
else
{
persister.Lock(entry.Id, entry.Version, entity, requestedLockMode, source);
}
entry.LockMode = requestedLockMode;
}
finally
{
// the database now holds a lock + the object is flushed from the cache,
// so release the soft lock
if (persister.HasCache)
{
persister.Cache.Release(ck, slock);
}
}
}
}
public FetchReturn(
NonScalarReturn owner,
string ownerProperty,
string alias,
LockMode lockMode)
: base(alias, lockMode)
{
this.owner = owner;
this.ownerProperty = ownerProperty;
}
public EntityFetchReturn(
String alias,
IEntityAliases entityAliases,
NonScalarReturn owner,
String ownerProperty,
LockMode lockMode)
: base(owner, ownerProperty, alias, lockMode)
{
this.entityAliases = entityAliases;
}
public RootReturn(
String alias,
String entityName,
IEntityAliases entityAliases,
LockMode lockMode)
: base(alias, lockMode)
{
this.entityName = entityName;
this.entityAliases = entityAliases;
}
protected void InitAll(SqlString whereString,string orderByString,LockMode lockMode)
{
WalkEntityTree(persister, Alias);
IList<OuterJoinableAssociation> allAssociations = new List<OuterJoinableAssociation>(associations);
allAssociations.Add(
new OuterJoinableAssociation(persister.EntityType, null, null, alias, JoinType.LeftOuterJoin, Factory,
new CollectionHelper.EmptyMapClass<string, IFilter>()));
InitPersisters(allAssociations, lockMode);
InitStatementString(whereString, orderByString, lockMode);
}
/// <summary>
/// Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
///
/// Add the "hydrated state" (an array) of an uninitialized entity to the session. We don't try
/// to resolve any associations yet, because there might be other entities waiting to be
/// read from the JDBC result set we are currently processing
/// </summary>
public static void PostHydrate(IEntityPersister persister, object id, object[] values, object rowId, object obj, LockMode lockMode, bool lazyPropertiesAreUnfetched, ISessionImplementor session)
{
object version = Versioning.GetVersion(values, persister);
session.PersistenceContext.AddEntry(obj, Status.Loading, values, rowId, id, version, lockMode, true, persister, false, lazyPropertiesAreUnfetched);
if (log.IsDebugEnabled && version != null)
{
System.String versionStr = persister.IsVersioned ? persister.VersionType.ToLoggableString(version, session.Factory) : "null";
log.Debug("Version: " + versionStr);
}
}
private static int GetMatrixIndex(LockMode mode)
{
int idx = -1;
switch (mode)
{
case LockMode.Locked: idx = 0; break;
case LockMode.WriteLock: idx = 2; break;
case LockMode.ReadLock: idx = 3; break;
default: break;
}
return idx;
}
public EntityJoinWalker(IOuterJoinLoadable persister, string[] uniqueKey, int batchSize, LockMode lockMode,
ISessionFactoryImplementor factory, IDictionary<string, IFilter> enabledFilters)
: base(persister, factory, enabledFilters)
{
this.lockMode = lockMode;
SqlStringBuilder whereCondition = WhereString(Alias, uniqueKey, batchSize)
//include the discriminator and class-level where, but not filters
.Add(persister.FilterFragment(Alias, new CollectionHelper.EmptyMapClass<string, IFilter>()));
InitAll(whereCondition.ToSqlString(), SqlString.Empty, lockMode);
}
protected SQLQueryNonScalarReturn(string alias, IDictionary propertyResults, LockMode lockMode)
{
this.alias = alias;
if (alias == null)
{
throw new HibernateException("alias must be specified");
}
this.lockMode = lockMode;
if (propertyResults != null)
{
this.propertyResults = propertyResults;
}
}
/// <summary> Constructs some form of non-scalar return descriptor </summary>
/// <param name="alias">The result alias </param>
/// <param name="propertyResults">Any user-supplied column->property mappings </param>
/// <param name="lockMode">The lock mode to apply to the return. </param>
protected internal NativeSQLQueryNonScalarReturn(string alias, IDictionary<string, string[]> propertyResults, LockMode lockMode)
{
if (string.IsNullOrEmpty(alias))
throw new ArgumentNullException("alias", "A valid scalar alias must be specified.");
this.alias = alias;
this.lockMode = lockMode;
if (propertyResults != null)
{
ArrayHelper.AddAll(this.propertyResults, propertyResults);
}
}
/// <summary>
/// Tries to lock the items passed in LockBatch.
/// </summary>
/// <param name="login">The login of the user is our transaction id</param>
/// <param name="batch">The items to lock</param>
/// <param name="mode">The lock mode</param>
/// <returns>True on lock success, false on rollback</returns>
public bool Lock(String login, LockBatch batch, LockMode mode)
{
lock(locks)
{
foreach (LockItem item in batch.ItemsToLock)
{
if (SetLocks(login, batch, mode, item) == false)
{
return false;
}
}
return true;
}
}
/// <summary>
/// Initializes a new instance of EntityEntry.
/// </summary>
/// <param name="status">The current <see cref="Status"/> of the Entity.</param>
/// <param name="loadedState">The snapshot of the Entity's state when it was loaded.</param>
/// <param name="id">The identifier of the Entity in the database.</param>
/// <param name="version">The version of the Entity.</param>
/// <param name="lockMode">The <see cref="LockMode"/> for the Entity.</param>
/// <param name="existsInDatabase">A boolean indicating if the Entity exists in the database.</param>
/// <param name="persister">The <see cref="IClassPersister"/> that is responsible for this Entity.</param>
/// <param name="disableVersionIncrement"></param>
public EntityEntry(Status status, object[] loadedState, object id, object version, LockMode lockMode, bool existsInDatabase, IClassPersister persister, bool disableVersionIncrement )
{
this.status = status;
this.loadedState = loadedState;
this.id = id;
this.existsInDatabase = existsInDatabase;
this.version = version;
this.lockMode = lockMode;
this.isBeingReplicated = disableVersionIncrement;
this.persister = persister;
if ( persister != null )
{
className = persister.ClassName;
}
}
/// <summary>
/// Unlock the locks for given user and mode.
/// </summary>
/// <param name="login">The login name of the user the unlock should be processed for</param>
/// <param name="batch">The items to unlock</param>
/// <param name="mode">The lock mode to unlock</param>
/// <returns>True on all items could be unlocked. False if unlocking of at least one item has failed.</returns>
public bool Unlock(String login, LockBatch batch, LockMode mode)
{
lock(locks)
{
bool allLocksReleased = true;
foreach (LockItem item in batch.ItemsToLock)
{
if (ReleaseLocks(login, mode, item) == false)
{
allLocksReleased = false;
}
}
return allLocksReleased;
}
}
public ICriteria SetLockMode(string alias, LockMode lockMode)
{
root.SetLockMode(alias, lockMode);
return(this);
}
public object Get(Type clazz, object id, LockMode lockMode)
{
return(_Session.Get(clazz, id, lockMode));
}
public T Get <T>(object id, LockMode lockMode)
{
return(_Session.Get <T>(id, lockMode));
}
public object Load(string entityName, object id, LockMode lockMode)
{
throw new NotImplementedException();
}
public object Load(string entityName, object id, LockMode lockMode)
{
return(_backingSession.Load(entityName, id, lockMode));
}
public void Lock(object id, object version, object obj, LockMode lockMode, ISessionImplementor session)
{
throw new NotSupportedException();
}
public ICriteria SetLockMode(string alias, LockMode lockMode)
{
lockModes[alias] = lockMode;
return(this);
}
protected bool NeedsLockHint(LockMode lockMode)
{
return(lockMode.GreaterThan(LockMode.Read));
}
public Task <ConditionalValue <T> > TryPeekAsync(ITransaction tx, LockMode lockMode)
{
return(TryPeekAsync(tx));
}
public object Get(Type clazz, object id, LockMode lockMode)
{
throw new NotImplementedException();
}
public void Lock(object obj, LockMode lockMode)
{
_backingSession.Lock(obj, lockMode);
}
public void Lock(string entityName, object obj, LockMode lockMode)
{
_backingSession.Lock(entityName, obj, lockMode);
}
public T Load <T>(object id, LockMode lockMode)
{
return(_backingSession.Load <T>(id, lockMode));
}
/// <summary>
/// Applies locks to the specified source queryable.
/// </summary>
/// <typeparam name="TSource">The type of the source element.</typeparam>
/// <param name="source">The source sequence.</param>
/// <param name="lockMode">The lock mode.</param>
/// <param name="lockBehavior">The lock behavior.</param>
/// <returns>The same sequence, but with "apply lock" hint.</returns>
public static IQueryable <TSource> Lock <TSource>(this IQueryable <TSource> source, LockMode lockMode, LockBehavior lockBehavior)
{
ArgumentValidator.EnsureArgumentNotNull(source, "source");
ArgumentValidator.EnsureArgumentNotNull(lockMode, "lockMode");
ArgumentValidator.EnsureArgumentNotNull(lockBehavior, "lockBehavior");
var errorMessage = Strings.ExLockDoesNotSupportQueryProviderOfTypeX;
var providerType = source.Provider.GetType();
if (providerType != WellKnownOrmTypes.QueryProvider)
{
throw new NotSupportedException(String.Format(errorMessage, providerType));
}
var genericMethod = WellKnownMembers.Queryable.ExtensionLock.MakeGenericMethod(new[] { typeof(TSource) });
var expression = Expression.Call(null, genericMethod, new[] { source.Expression, Expression.Constant(lockMode), Expression.Constant(lockBehavior) });
return(source.Provider.CreateQuery <TSource>(expression));
}
public ICriteria SetLockMode(LockMode lockMode)
{
this.lockMode = lockMode;
return(this);
}
public void Lock(object obj, LockMode lockMode)
{
_session.Lock(obj, lockMode);
}
public ICriteria SetLockMode(LockMode lockMode)
{
return(SetLockMode(CriteriaSpecification.RootAlias, lockMode));
}
public void Refresh(object obj, LockMode lockMode)
{
_backingSession.Refresh(obj, lockMode);
}
public abstract IQuery SetLockMode(string alias, LockMode lockMode);
public Task <ConditionalValue <T> > TryPeekAsync(ITransaction tx, LockMode lockMode, TimeSpan timeout, CancellationToken cancellationToken)
{
return(TryPeekAsync(tx));
}
public void Refresh(object obj, LockMode lockMode)
{
_session.Refresh(obj, lockMode);
}
public Task <bool> ContainsKeyAsync(ITransaction tx, TKey key, LockMode lockMode, TimeSpan timeout, CancellationToken cancellationToken)
{
return(Task.FromResult(this.dictionary.ContainsKey(key)));
}
public object Load(Type theType, object id, LockMode lockMode)
{
throw new NotImplementedException();
}
public object Load(Type theType, object id, LockMode lockMode)
{
return(_backingSession.Load(theType, id, lockMode));
}
public Task <bool> ContainsKeyAsync(ITransaction tx, TKey key, LockMode lockMode)
{
return(Task.FromResult(this.dictionary.ContainsKey(key)));
}
public void Refresh(object obj, LockMode lockMode)
{
throw new NotImplementedException();
}
public Task <ConditionalValue <TValue> > TryGetValueAsync(ITransaction tx, TKey key, LockMode lockMode)
{
TValue value;
bool result = this.dictionary.TryGetValue(key, out value);
return(Task.FromResult(new ConditionalValue <TValue>(result, value)));
}
public void Lock(string entityName, object obj, LockMode lockMode)
{
throw new NotImplementedException();
}
private LockingHints(LockMode lockingHintAnalog)
{
LockingModeAnalog = lockingHintAnalog;
}
public T Get <T>(object id, LockMode lockMode)
{
throw new NotImplementedException();
}
