/// <summary>
/// 锁定一个给定的聚合根，数据库级别的锁;
/// 该方法内部不需要考虑事务，因为框架在调用该方法之前已经确保当前事务是开启的;
/// 默认实现是通过ROWLOCK+UPDLOCK的方式实现行级锁;
/// </summary>
protected virtual long LockAggregateRootAfterTransactionStarted(string aggregateRootId)
{
var aggregateRootEventType = _aggregateRootEventTypeProvider.GetAggregateRootEventType(typeof(T));
var aggregateRootName = GetAggregateRootName();
DetachedCriteria detachedCriteria = DetachedCriteria.For(aggregateRootEventType)
.Add(Restrictions.Eq("AggregateRootName", aggregateRootName))
.Add(Restrictions.Eq("AggregateRootId", aggregateRootId))
.Add(Subqueries.PropertyEq("Version",
DetachedCriteria.For(aggregateRootEventType)
.SetProjection(Projections.Max("Version"))
.Add(Restrictions.Eq("AggregateRootName", aggregateRootName))
.Add(Restrictions.Eq("AggregateRootId", aggregateRootId))));
detachedCriteria.SetLockMode(LockMode.Upgrade);
var criteria = detachedCriteria.GetExecutableCriteria(OpenSession());
var eventList = typeof(EventQueryHelper).GetMethod("GetList").MakeGenericMethod(aggregateRootEventType).Invoke(new EventQueryHelper(), new object[] { criteria }) as IList;
if (eventList != null && eventList.Count > 0)
{
return((long)((AggregateRootEvent)eventList[0]).Version);
}
return(0);
}
protected static IList <T> LoadAll <T>()
{
DetachedCriteria criteria = DetachedCriteria.For <T>();
criteria.SetResultTransformer(new DistinctRootEntityResultTransformer());
return(criteria.GetExecutableCriteria(UnitOfWork.CurrentSession).List <T>());
}
protected virtual ICriteria BuildCriteria(ISession session)
{
if (cachedCriteria == null)
{
if (detachedCriteria != null)
{
cachedCriteria = detachedCriteria.GetExecutableCriteria(session);
}
else
{
cachedCriteria = session.CreateCriteria(targetType);
if (criterions != null)
{
foreach (var queryCriteria in criterions)
{
cachedCriteria.Add(queryCriteria);
}
}
}
if (orders != null)
{
foreach (var order in orders)
{
cachedCriteria.AddOrder(order);
}
}
}
return(cachedCriteria);
}
public async Task BugAsync()
{
using (ISession session = OpenSession())
using (ITransaction t = session.BeginTransaction())
{
await(session.PersistAsync(new Foo("Foo1", DateTime.Today.AddDays(5))));
await(session.PersistAsync(new Foo("Foo2", DateTime.Today.AddDays(1))));
await(session.PersistAsync(new Foo("Foo3", DateTime.Today.AddDays(3))));
await(t.CommitAsync());
}
DetachedCriteria criteria = DetachedCriteria.For(typeof(Foo));
criteria.Add(Restrictions.Like("Name", "Foo", MatchMode.Start));
criteria.AddOrder(Order.Desc("Name"));
criteria.AddOrder(Order.Asc("BirthDate"));
using (ISession session = OpenSession())
{
ICriteria icriteria = criteria.GetExecutableCriteria(session);
icriteria.SetFirstResult(0);
icriteria.SetMaxResults(2);
Assert.That(2, Is.EqualTo((await(icriteria.ListAsync <Foo>())).Count));
}
using (ISession session = OpenSession())
using (ITransaction t = session.BeginTransaction())
{
await(session.DeleteAsync("from Foo"));
await(t.CommitAsync());
}
}
/// <summary>
/// Executes the query.
/// </summary>
/// <param name="session">The <c>NHibernate</c>'s <see cref="ISession"/></param>
/// <returns><c>System.Int32</c> as object</returns>
protected override object InternalExecute(ISession session)
{
if (detachedCriteria != null)
{
ICriteria criteria = detachedCriteria.GetExecutableCriteria(session);
criteria.SetProjection(Projections.RowCount());
Int32 count = Convert.ToInt32(criteria.UniqueResult());
// clear the projection, so our caller can re-use the DetachedCriteria
criteria.SetProjection(new IProjection[] { null });
return(count);
}
else if (criterias != null)
{
ICriteria criteria = session.CreateCriteria(RootType);
CriteriaHelper.AddCriterionToCriteria(criteria, criterias);
criteria.SetProjection(Projections.RowCount());
return(Convert.ToInt32(criteria.UniqueResult()));
}
else
{
return(Convert.ToInt32(base.CreateQuery(session).UniqueResult()));
}
}
public List <T> Find <T>()
{
var criteria = DetachedCriteria.For <T>()
.CreateAlias("HomeRegion", "hr");
if (!String.IsNullOrEmpty(SearchText))
{
criteria.Add(Expression.Like("Name", SearchText, MatchMode.Anywhere));
}
DetachedCriteria countSubquery = NHibernate.CriteriaTransformer.TransformToRowCount(criteria);
_lastRowsCount = ArHelper.WithSession <int>(
s => countSubquery.GetExecutableCriteria(s).UniqueResult <int>());
criteria.AddOrder(Order.Asc("Name"));
criteria.AddOrder(Order.Asc("hr.Name"));
if (CurrentPage > 0)
{
criteria.SetFirstResult(CurrentPage * PageSize);
}
criteria.SetMaxResults(PageSize);
var list = ArHelper.WithSession(
s => criteria.GetExecutableCriteria(s).List <T>())
.ToList();
return(list);
}
/// <summary> Create a query (ICriteria) </summary>
public ICriteria CreateCountQuery(DetachedCriteria detachedCriteria)
{
ICriteria executableCriteria = detachedCriteria.GetExecutableCriteria(_session);
executableCriteria.ClearOrders();
return(executableCriteria.SetFirstResult(0).SetProjection(Projections.RowCount()));
}
public IList <T> get_with_criteria <T>(DetachedCriteria detachedCriteria)
{
if (detachedCriteria == null)
{
Log.bound_to(this).log_a_warning_event_containing("Please ensure you send in a criteria when you want to limit records. Otherwise please consider using GetAll(). Returning empty list.");
return(null);
}
IList <T> list;
bool not_running_outside_session = session == null;
if (not_running_outside_session)
{
start(false);
}
ICriteria criteria = detachedCriteria.GetExecutableCriteria(session);
list = criteria.List <T>();
if (not_running_outside_session)
{
finish();
}
Log.bound_to(this).log_a_debug_event_containing("Repository found {0} records of type {1} with criteria {2}.", list.Count, typeof(T).Name, detachedCriteria.ToString());
return(list);
}
public void DeleteAll(DetachedCriteria criteria)
{
foreach (Entity entity in criteria.GetExecutableCriteria(_session).List())
{
_session.Update(entity.Delete());
}
}
public IList <T> get_transformation_with_criteria <T>(DetachedCriteria detachedCriteria)
{
if (detachedCriteria == null)
{
Log.bound_to(this).log_a_warning_event_containing("Please ensure you send in a criteria when you want to get transformed records. Otherwise please consider using GetAll(). Returning empty list.");
return(null);
}
IList <T> list;
bool running_long_session = session == null;
if (!running_long_session)
{
start(false);
}
ICriteria criteria = detachedCriteria.GetExecutableCriteria(session);
list = criteria
.SetResultTransformer(new AliasToBeanResultTransformer(typeof(T)))
.List <T>();
if (!running_long_session)
{
finish();
}
Log.bound_to(this).log_a_debug_event_containing("Repository found {0} records of type {1} with criteria {2}.", list.Count, typeof(T).Name, detachedCriteria.ToString());
return(list);
}
public int GetCount <T>() where T : DomainEntity
{
DetachedCriteria q = DetachedCriteria.For(typeof(T));
q.SetProjection(Projections.Count("Id"));
return(q.GetExecutableCriteria(Session).UniqueResult <int>());
}
public void WillReturnNothingIfOperationNotDefined_WithDetachedCriteria()
{
DetachedCriteria detachedCriteria = DetachedCriteria.For <Account>();
authorizationService.AddPermissionsToQuery(user, "/Account/Delete", detachedCriteria);
Assert.Empty(detachedCriteria.GetExecutableCriteria(session).List());
}
public void AggregatingHirearchyWithCount()
{
var root = new Key {
Id = 1, Area = 2
};
DetachedCriteria projection = DetachedCriteria.For <TreeNode>("child")
.Add(Restrictions.Eq("Parent.id", root))
.Add(Restrictions.Gt("Key.Id", 0))
.Add(Restrictions.Eq("Type", NodeType.Blue))
.CreateAlias("DirectChildren", "grandchild")
.SetProjection(
Projections.ProjectionList()
.Add(Projections.GroupProperty("child.Key.Id"))
.Add(Projections.GroupProperty("child.Key.Area"))
.Add(Projections.Count(Projections.Property("grandchild.Key.Id")))
);
using (var s = sessions.OpenSession())
using (var tx = s.BeginTransaction())
{
var criteria = projection.GetExecutableCriteria(s);
var list = criteria.List();
Assert.AreEqual(1, list.Count);
var tuple = (object[])list[0];
Assert.AreEqual(11, tuple[0]);
Assert.AreEqual(2, tuple[1]);
Assert.AreEqual(1, tuple[2]);
tx.Commit();
}
}
protected void DeleteAll(DetachedCriteria criteria)
{
foreach (var entity in criteria.GetExecutableCriteria(_session).List <TEntity>())
{
_session.Delete(entity);
}
}
public void ProdsWDate()
{
ISession session = GetConfiguration().BuildSessionFactory().OpenSession();
Category category = new Category()
{
Id = 1
};
DetachedCriteria criteria = DetachedCriteria.For <Income>();
criteria.CreateAlias("Product", "p");
criteria.CreateAlias("p.Category", "c");
criteria.SetProjection(
Projections.ProjectionList()
.Add(Projections.GroupProperty("Product"))
.Add(Projections.GroupProperty("c.Name"))
.Add(Projections.Max("Date")));
//criteria.Add(Restrictions.Eq("p.Category", category));
criteria.AddOrder(NHibernate.Criterion.Order.Asc("c.Name"));
var list = criteria.GetExecutableCriteria(session).List();
foreach (var VARIABLE in list)
{
}
}
public void WillReturnNothingForUsersGroupIfOperationNotDefined_WithDetachedCriteria()
{
UsersGroup usersgroup = authorizationRepository.GetUsersGroupByName("Administrators");
DetachedCriteria detachedCriteria = DetachedCriteria.For <Account>();
authorizationService.AddPermissionsToQuery(usersgroup, "/Account/Delete", detachedCriteria);
Assert.Empty(detachedCriteria.GetExecutableCriteria(session).List());
}
public IList <TEntity> FindAll(DetachedCriteria criteria, params Order[] orders)
{
var executableCriteria = criteria.GetExecutableCriteria(_session);
Array.ForEach(orders, order => executableCriteria.AddOrder(order));
return(executableCriteria.List <TEntity>());
}
/// <summary>
/// Get all objects of T that match the given criteria.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="criteria">NHibernate DetachedCriteria instance.</param>
/// <returns></returns>
/// <remarks>
/// Be careful to not use this one from the UI layer beacuse it ties the UI to NHibernate.
/// </remarks>
public IList <T> GetAllByCriteria <T>(DetachedCriteria criteria)
{
using (ISession session = SessionFactory.OpenSession(_AssemblyName))
{
ICriteria crit = criteria.GetExecutableCriteria(session);
return(crit.List <T>());
}
}
public long Count(DetachedCriteria criteria)
{
var executableCriteria = criteria.GetExecutableCriteria(_session);
var count = executableCriteria.SetProjection(Projections.RowCount()).UniqueResult();
return(Convert.ToInt64(count));
}
public T GetUniqueByCriteria(DetachedCriteria aCriteria)
{
using (var session = SessionFactory.OpenSession()) {
ICriteria criteria = aCriteria.GetExecutableCriteria(session.SessionImpl);
criteria.Add(Expression.Eq("IsDelete", false));
return(criteria.UniqueResult <T>());
}
}
/// <summary>
/// 動態查詢
/// </summary>
/// <typeparam name="T">類型</typeparam>
/// <param name="detachedcriteria">搜尋條件</param>
/// <returns>搜尋結果</returns>
public IList <T> SearchByDetachedCriteria <T>(DetachedCriteria detachedcriteria)
{
ISession session = HibernateTemplate.SessionFactory.GetCurrentSession();
//ISession session = NHibernateHelper.GetCurrentSession();
ICriteria criteria = detachedcriteria.GetExecutableCriteria(session);
return(criteria.List <T>());
}
/// <summary>
/// Get all objects of T that match the given criteria.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="criteria">NHibernate DetachedCriteria instance.</param>
/// <returns></returns>
/// <remarks>
/// Be careful to not use this one from the UI layer beacuse it ties the UI to NHibernate.
/// </remarks>
public IList <T> GetAllByCriteria <T>(DetachedCriteria criteria)
{
using (ISession session = this._sessionManager.OpenSession())
{
ICriteria crit = criteria.GetExecutableCriteria(session);
return(crit.List <T>());
}
}
public int Count(DetachedCriteria searchParameters)
{
var count = searchParameters.GetExecutableCriteria(session)
.SetProjection(Projections.RowCount())
.FutureValue <int>();
return(count.Value);
}
public IList <T> FindAll <T>(DetachedCriteria criteria, int firstRow, int maxRows)
{
ICriteria c = criteria.GetExecutableCriteria(GetSession());
c.SetFirstResult(firstRow);
c.SetMaxResults(maxRows);
return(c.List <T>());
}
public T FindByFieldScalarOrThrow <T>(string name, object value) where T : DomainEntity
{
DetachedCriteria q = DetachedCriteria.For(typeof(T));
q.Add(Restrictions.Eq(name, value));
IList <T> list = q.GetExecutableCriteria(Session).List <T>();
return(getScalarResult(list));
}
/// <summary>
/// 執行預先定義好的DetachedCriteria並傳回一筆資料
/// </summary>
/// <typeparam name="T">轉型型別</typeparam>
/// <param name="detachedcriteria">預先準備好的條件</param>
/// <returns></returns>
public T GetVOByDetachedCriteria <T>(DetachedCriteria detachedcriteria)
{
ISession session = HibernateTemplate.SessionFactory.GetCurrentSession();
//ISession session = NHibernateHelper.GetCurrentSession();
ICriteria criteria = detachedcriteria.GetExecutableCriteria(session);
criteria.SetMaxResults(1);
return(criteria.UniqueResult <T>());
}
public ICollection <T> FindAll(DetachedCriteria criteria, int firstResult, int numberOfResults)
{
ICriteria crit = criteria.GetExecutableCriteria(Uow.Session);
crit.SetFirstResult(firstResult);
crit.SetMaxResults(numberOfResults);
return(crit.List <T> ());
}
public IMultiCriteria Add <T>(string key, DetachedCriteria detachedCriteria)
{
ThrowIfKeyAlreadyExists(key);
criteriaQueries.Add(detachedCriteria.GetExecutableCriteria(session));
criteriaResultPositions.Add(key, criteriaQueries.Count - 1);
resultCollectionGenericType.Add(typeof(T));
return(this);
}
public IList <T> GetByCriteria(DetachedCriteria aCriteria)
{
using (var session = SessionFactory.OpenSession()) {
ICriteria criteria = aCriteria.GetExecutableCriteria(session.SessionImpl);
criteria.Add(Expression.Eq("IsDelete", false));
IList <T> rs = criteria.List <T>();
return(rs);
}
}
public IMultiCriteria Add <T>(DetachedCriteria detachedCriteria)
{
criteriaQueries.Add(
detachedCriteria.GetExecutableCriteria(session)
);
resultCollectionGenericType.Add(typeof(T));
return(this);
}
public IList Criteria(DetachedCriteria criteria)
{
return criteria.GetExecutableCriteria(session).List();
}
/// <summary>
/// Returns all instances found for the specified type according to the criteria
/// </summary>
/// <param name="targetType">The target type.</param>
/// <param name="detachedCriteria">The criteria.</param>
/// <param name="orders">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
/// <returns>The <see cref="Array"/> of results.</returns>
protected internal static Array FindAll(Type targetType, DetachedCriteria detachedCriteria, params Order[] orders)
{
EnsureInitialized(targetType);
ISession session = holder.CreateSession(targetType);
try
{
ICriteria criteria = detachedCriteria.GetExecutableCriteria(session);
AddOrdersToCriteria(criteria, orders);
return SupportingUtils.BuildArray(targetType, criteria.List());
}
catch(ValidationException)
{
holder.FailSession(session);
throw;
}
catch(Exception ex)
{
holder.FailSession(session);
throw new ActiveRecordException("Could not perform FindAll for " + targetType.Name, ex);
}
finally
{
holder.ReleaseSession(session);
}
}
/// <summary>
/// Returns a portion of the query results (sliced)
/// </summary>
/// <param name="targetType">The target type.</param>
/// <param name="firstResult">The number of the first row to retrieve.</param>
/// <param name="maxResults">The maximum number of results retrieved.</param>
/// <param name="orders">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
/// <param name="criteria">The criteria expression</param>
/// <returns>The sliced query results.</returns>
protected internal static Array SlicedFindAll(Type targetType, int firstResult, int maxResults,
Order[] orders, DetachedCriteria criteria)
{
EnsureInitialized(targetType);
ISession session = holder.CreateSession(targetType);
try
{
ICriteria executableCriteria = criteria.GetExecutableCriteria(session);
AddOrdersToCriteria(executableCriteria, orders);
executableCriteria.SetFirstResult(firstResult);
executableCriteria.SetMaxResults(maxResults);
return SupportingUtils.BuildArray(targetType, executableCriteria.List());
}
catch(ValidationException)
{
holder.FailSession(session);
throw;
}
catch(Exception ex)
{
holder.FailSession(session);
throw new ActiveRecordException("Could not perform SlicedFindAll for " + targetType.Name, ex);
}
finally
{
holder.ReleaseSession(session);
}
}
private void DeleteAll(DetachedCriteria criteria)
{
foreach (object entity in criteria.GetExecutableCriteria(applicationSession).List())
{
applicationSession.Delete(entity);
}
}
public IMultiCriteria Add(DetachedCriteria detachedCriteria)
{
criteriaQueries.Add(
detachedCriteria.GetExecutableCriteria(session)
);
return this;
}
public NHibernateCountQuery(DetachedCriteria criteria, ISession session)
{
executableCriteria = criteria.GetExecutableCriteria(session);
}
private Permission FindResult(DetachedCriteria criteria)
{
Permission permission = criteria.GetExecutableCriteria(session)
.SetCacheable(true).
UniqueResult<Permission>();
if (permission == null)
{
permission = new Permission();
session.Save(permission);
}
return permission;
}
private Permission[] FindResults(DetachedCriteria criteria)
{
ICollection<Permission> permissions = criteria.GetExecutableCriteria(session)
.AddOrder(Order.Desc("Level"))
.AddOrder(Order.Asc("Allow"))
.SetCacheable(true)
.List<Permission>();
return permissions.ToArray();
}
