public void DefinitionExample1()
{
IDelayedFlowQuery <UserEntity> query = Session.FlowQuery <UserEntity>()
.Delayed()
.Where(x => x.IsOnline);
Lazy <int> count = query.Count();
FlowQuerySelection <UserEntity> users = query
.Take(10)
.Select();
var sessionImpl = (ISessionImplementor)Session;
Assert.That(sessionImpl, Is.Not.Null);
int queryCount = 0;
Assert.That(() => queryCount = sessionImpl.FutureCriteriaBatch.Results.Count, Throws.Nothing);
Assert.That(queryCount, Is.EqualTo(2));
Assert.That(count.Value, Is.EqualTo(3));
Assert.That(users.Count(), Is.EqualTo(3));
}
public void CanCreateStatelessDelayedFlowQueryWithOptions()
{
Assert.That(() => StatelessSession.DelayedFlowQuery <UserEntity>(new FlowQueryOptions()), Throws.Nothing);
IDelayedFlowQuery <UserEntity> query = StatelessSession.DelayedFlowQuery <UserEntity>(new FlowQueryOptions());
Assert.That(query != null);
}
public void CanCreateDelayedStatelessFlowQuery()
{
Assert.That(() => StatelessSession.DelayedFlowQuery <UserEntity>(), Throws.Nothing);
IDelayedFlowQuery <UserEntity> query = StatelessSession.DelayedFlowQuery <UserEntity>();
Assert.That(query != null);
}
public void CanCreateDelayedFlowQueryWithAliasAndOptions()
{
UserEntity user = null;
IDelayedFlowQuery <UserEntity> q = Session.DelayedFlowQuery(() => user, new FlowQueryOptions());
Assert.That(q, Is.Not.Null);
}
public void CanMorphImmediateToDelayed()
{
IImmediateFlowQuery <UserEntity> query = DummyQuery <UserEntity>();
Assert.That(query, Is.Not.Null);
IDelayedFlowQuery <UserEntity> morphed = query
.Delayed();
Assert.That(morphed, Is.Not.Null);
}
public void CanMorphDelayedToStreamed()
{
IDelayedFlowQuery <UserEntity> query = DummyQuery <UserEntity>()
.Delayed();
Assert.That(query, Is.Not.Null);
IStreamedFlowQuery <UserEntity> morphed = query
.Streamed();
Assert.That(morphed, Is.Not.Null);
}
public void CanCreateDelayedFlowQueryWithOptions()
{
FlowQueryOptions options = new FlowQueryOptions()
.Add(c => c.SetMaxResults(5));
IDelayedFlowQuery <UserEntity> q = Session.DelayedFlowQuery <UserEntity>(options);
Assert.That(q, Is.Not.Null);
ICriteria criteria = new CriteriaBuilder()
.Build <UserEntity, UserEntity>(QuerySelection.Create(q as IQueryableFlowQuery));
Assert.That(criteria.GetRootEntityTypeIfAvailable(), Is.EqualTo(typeof(UserEntity)));
}
public void CanCreateStatelessDelayedFlowQueryWithAlias()
{
UserEntity alias = null;
Assert.That(() => StatelessSession.DelayedFlowQuery(() => alias), Throws.Nothing);
IDelayedFlowQuery <UserEntity> query = StatelessSession.DelayedFlowQuery(() => alias);
Assert.That(query != null);
ICriteria criteria = new CriteriaBuilder()
.Build <UserEntity, UserEntity>(QuerySelection.Create(query as IQueryableFlowQuery));
Assert.That(criteria.Alias, Is.EqualTo("alias"));
}
public virtual void TestDelayedCopy()
{
IDelayedFlowQuery <UserEntity> query1 = Query <UserEntity>()
.Delayed();
IDelayedFlowQuery <UserEntity> query2 = query1.Copy()
.Where(x => x.IsOnline);
FlowQuerySelection <UserEntity> users1 = query1.Select();
FlowQuerySelection <UserEntity> users2 = query2.Select();
Assert.That(users1.Count(), Is.EqualTo(4));
Assert.That(users2.Count(), Is.EqualTo(3));
}
public void ReusabilityMechanismsClearRestrictions()
{
IDelayedFlowQuery <UserEntity> query = Session.DelayedFlowQuery <UserEntity>()
.OrderBy(x => x.Username);
FlowQuerySelection <UserEntity> onlineAdministrators = query
.Where(x => x.IsOnline && x.Role == RoleEnum.Administrator)
.Select();
FlowQuerySelection <UserEntity> onlineNonAdministrators = query
.ClearRestrictions()
.Where(x => x.IsOnline && x.Role != RoleEnum.Administrator)
.Select();
Assert.That(onlineAdministrators.Count(), Is.EqualTo(2));
Assert.That(onlineNonAdministrators.Count(), Is.EqualTo(1));
}
public void TransformingTrulyDetachedQueryToDelayedDoesNotThrowWhenProvidingStatelessSession()
{
var query = new DummyDetachedQuery();
Assert.That(query.CriteriaFactory, Is.Null);
IDelayedFlowQuery <UserEntity> delayed = null;
Assert.That(() => delayed = query.Delayed(StatelessSession), Throws.Nothing);
Assert.That(delayed, Is.Not.Null);
var queryInfo = delayed as IFlowQuery;
if (queryInfo == null)
{
Assert.Fail("queryInfo was null");
}
else
{
Assert.That(queryInfo.CriteriaFactory, Is.Not.Null);
}
}
public void Given_DelayedQueryWithModelBasedOrders_When_LaterUsedAsSubquery_IsSortedByAppropriateSourceProjection()
{
IDelayedFlowQuery <UserEntity> query = Query <UserEntity>()
.OrderBy <UserDto>(x => x.SomeValue)
.Delayed();
FlowQuerySelection <UserDto> allUsers = query
.Select(Projection);
IDetachedFlowQuery <UserEntity> subquery = query
.Detached()
.Limit(2, 1)
.Select(x => x.Id);
FlowQuerySelection <UserDto> subsetOfUsers = Query <UserEntity>()
.Delayed()
.Where(x => x.Id, NHibernate.FlowQuery.Is.In(subquery))
.Select(Projection);
Assert.That(allUsers.Count(), Is.EqualTo(4));
Assert.That(subsetOfUsers.Count(), Is.EqualTo(2));
Assert.That(subsetOfUsers.ElementAt(0).SomeValue, Is.EqualTo("Lars Wilk"));
Assert.That(subsetOfUsers.ElementAt(1).SomeValue, Is.EqualTo("Lotta Brak"));
}
public void CanCreateDelayedFlowQuery()
{
IDelayedFlowQuery <UserEntity> q = Session.DelayedFlowQuery <UserEntity>();
Assert.That(q, Is.Not.Null);
}
