public void CanRightOuterJoinNonCollection()
{
Setting setting = null;
IDetachedFlowQuery <UserEntity> query = Query <UserEntity>()
.Detached()
.RightOuter.Join(x => x.Setting, () => setting)
.Select(u => setting.Id);
FlowQuerySelection <Setting> settings = Query <Setting>()
.Where(s => s.Id, FqIs.In(query))
.Select();
Assert.That(settings.Count(), Is.EqualTo(6));
}
public void WhereWithCriterions()
{
IDetachedFlowQuery <UserEntity> query = Query <UserEntity>()
.Detached()
.Where(Restrictions.Eq("IsOnline", true), Restrictions.Like("Firstname", "%kl%"))
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(1));
Assert.That(users.Single().IsOnline);
Assert.That(users.Single().Firstname.Contains("kl"));
}
public void DoesNotSkipOrderByStatementsIfNecessaryInSubqueryTest1()
{
IDetachedFlowQuery <UserEntity> detached = Query <UserEntity>()
.Detached()
.Skip(1)
.OrderBy(x => x.IsOnline)
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(x => x.Id, FqIs.In(detached))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
Assert.That(users.All(x => x.IsOnline));
}
public void CanMakeDistinctDetachedQueryIndistinct()
{
IDetachedFlowQuery <UserEntity> detachedCount = Query <UserEntity>()
.Detached()
.Distinct()
.Indistinct()
.Count(u => u.IsOnline);
FlowQuerySelection <UserEntity> query = Query <UserEntity>()
.Where(x => x.Id, FqIs.In(detachedCount))
.Select();
Assert.That(query.Count(), Is.EqualTo(1));
Assert.That(query.First().Id, Is.EqualTo(4));
}
public void CanOrderAscending()
{
IDetachedFlowQuery <UserEntity> id = DetachedQuery <UserEntity>()
.OrderBy(x => x.Firstname)
.Take(1)
.Skip(1)
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(x => x.Id, FqIs.EqualTo(id))
.Select();
Assert.That(users.Count(), Is.EqualTo(1));
Assert.That(users.ElementAt(0).Firstname, Is.EqualTo("Lars"));
}
public void CanInnerJoinWithJoinUsingString()
{
UserGroupLinkEntity link = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Inner.Join("Groups", () => link)
.Distinct()
.Select(u => link.Group.Id);
FlowQuerySelection <GroupEntity> groups = Query <GroupEntity>()
.Where(g => g.Id, FqIs.In(query))
.Select();
Assert.That(groups.Count(), Is.EqualTo(2));
}
public void CanRestrictOnNotExistsNonGreedily()
{
UserEntity user = null;
IDetachedFlowQuery <UserEntity> subquery = DetachedQuery <UserEntity>()
.SetRootAlias(() => user)
.And(x => x.IsOnline && x.Id == user.Id)
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Session.FlowQuery(() => user)
.And(subquery, FqIs.Empty())
.Select();
Assert.That(users.Count(), Is.EqualTo(1));
}
public void CorrelatedSubQueriesWorks()
{
UserEntity user = null;
IDetachedFlowQuery <UserEntity> query = Query <UserEntity>()
.Detached()
.SetRootAlias(() => user)
.Where(x => x.Firstname == user.Firstname)
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Session.FlowQuery(() => user)
.Where(x => x.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(4));
}
public void CanRightOuterJoinWithProvidedRevealConvention()
{
UserGroupLinkEntity link = null;
GroupEntity group = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link)
.RightOuter.Join(u => link.Group, () => group, new CustomConvention(x => x))
.Select(u => group.Id);
FlowQuerySelection <GroupEntity> groups = Query <GroupEntity>()
.Where(g => g.Id, FqIs.In(query))
.Select();
Assert.That(groups.Count(), Is.EqualTo(2));
}
public virtual void TestReuseAsSubqueryForRootQuery()
{
IImmediateFlowQuery <UserEntity> query = Query <UserEntity>()
.Where(x => x.IsOnline);
IDetachedFlowQuery <UserEntity> detached = query
.Detached()
.Where(x => x.Lastname.StartsWith("K"))
.Select(x => x.Id);
query.Where(x => x.Id, FqIs.In(detached));
FlowQuerySelection <UserEntity> users = query.Select();
Assert.That(users.Count(), Is.EqualTo(1));
}
public void CanInnerJoinOnInnerJoinedEntity()
{
UserGroupLinkEntity link = null;
GroupEntity group = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Inner.Join(u => u.Groups, () => link)
.Inner.Join(u => link.Group, () => group)
.Distinct().Select(u => group.Name);
FlowQuerySelection <GroupEntity> groups = Query <GroupEntity>()
.Where(g => g.Name, FqIs.In(query))
.Select();
Assert.That(groups.Count(), Is.EqualTo(2));
}
public void AndBetweenWithIsHelper()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => u.Id, FqIs.Between(2, 3))
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(2));
foreach (UserEntity user in users)
{
Assert.That(user.Id, Is.InRange(2, 3));
}
}
public void AndLessThanOrEqualTo()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => u.Id <= 4)
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(4));
foreach (UserEntity user in users)
{
Assert.That(user.Id, Is.LessThanOrEqualTo(4));
}
}
public void AndInWithIsHelper()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => u.Id, FqIs.In(1, 3))
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(2));
foreach (UserEntity user in users)
{
Assert.That(new long[] { 1, 3 }, Contains.Item(user.Id));
}
}
public void AndWithStringAndIsHelper()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And("IsOnline", FqIs.EqualTo(true))
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
foreach (UserEntity u in users)
{
Assert.That(u.IsOnline);
}
}
public void WhereWithNegatedIsExpression()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Where(u => u.Firstname, FqIs.Not.EqualTo("Niklas"))
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
foreach (UserEntity user in users)
{
Assert.That(user.Firstname, Is.Not.EqualTo("Niklas"));
}
}
public void AndGreaterThan()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => u.Id > 1)
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
foreach (UserEntity user in users)
{
Assert.That(user.Id, Is.GreaterThan(1));
}
}
public void Where()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Where(u => u.IsOnline)
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
foreach (UserEntity user in users)
{
Assert.That(user.IsOnline, Is.True);
}
}
public void CanInnerJoinWithJoinInCombinationWithRevealFramework()
{
UserGroupLinkEntity link = null;
IRevealer <UserEntity> r = Reveal.CreateRevealer <UserEntity>(new CustomConvention(s => s));
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Inner.Join(r.Reveal(x => x.Groups), () => link)
.Distinct()
.Select(u => link.Group.Id);
FlowQuerySelection <GroupEntity> groups = Query <GroupEntity>()
.Where(g => g.Id, FqIs.In(query))
.Select();
Assert.That(groups.Count(), Is.EqualTo(2));
}
public void AndWithNotNullCheck()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => u.LastLoggedInStamp != null)
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
foreach (UserEntity user in users)
{
Assert.That(user.LastLoggedInStamp, Is.Not.Null);
}
}
public void WhereInSubqueryWithIsHelper()
{
IDetachedFlowQuery <UserEntity> subquery = DetachedQuery <UserEntity>()
.Where(x => x.Id == 1 || x.Id == 4)
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(subquery))
.Select();
Assert.That(users.Count(), Is.EqualTo(2));
foreach (UserEntity user in users)
{
Assert.That(new long[] { 1, 4 }, Contains.Item(user.Id));
}
}
public void AndWithMultipleBinaryExpressions()
{
// ReSharper disable once RedundantBoolCompare
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => (u.Id == 1 || u.Id > 3) && u.IsOnline == true)
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(1));
foreach (UserEntity user in users)
{
Assert.That((user.Id == 1 || user.Id > 3) && user.IsOnline);
}
}
public void AndWithDoubleNegation()
{
// ReSharper disable once NegativeEqualityExpression, DoubleNegationOperator, RedundantBoolCompare
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.And(u => !!(u.IsOnline == true))
.Select(u => u.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(3));
foreach (UserEntity user in users)
{
Assert.That(user.IsOnline, Is.True);
}
}
public void DelayedCanAnyWithSubquery()
{
IDetachedFlowQuery <UserEntity> subquery = DetachedQuery <UserEntity>()
.Select(x => x.Id);
Lazy <bool> any = Query <UserEntity>()
.Delayed()
.Any(x => x.Id, FqIs.In(subquery));
var sessionImpl = (ISessionImplementor)Session;
int count = 0;
Assert.That(() => count = sessionImpl.FutureCriteriaBatch.Results.Count, Throws.Nothing);
Assert.That(count, Is.EqualTo(1));
Assert.That(any.Value, Is.True);
}
public virtual void TestDetachedCopy()
{
IDetachedFlowQuery <UserEntity> subquery1 = Query <UserEntity>()
.Detached()
.Select(x => x.Id);
IDetachedFlowQuery <UserEntity> subquery2 = subquery1.Copy()
.Where(x => x.IsOnline);
FlowQuerySelection <UserEntity> users1 = Query <UserEntity>()
.Where(x => x.Id, FqIs.In(subquery1))
.Select();
FlowQuerySelection <UserEntity> users2 = Query <UserEntity>()
.Where(x => x.Id, FqIs.In(subquery2))
.Select();
Assert.That(users1.Count(), Is.EqualTo(4));
Assert.That(users2.Count(), Is.EqualTo(3));
}
public void WhereWithExclusiveOr()
{
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Where(u => u.IsOnline ^ (u.Firstname == "Niklas"))
.Select(x => x.Id);
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(u => u.Id, FqIs.In(query))
.Select();
Assert.That(users.Count(), Is.EqualTo(2));
foreach (UserEntity u in users)
{
if (u.IsOnline)
{
Assert.That(u.Firstname, Is.Not.EqualTo("Niklas"));
}
}
}
public void CanRightOuterJoinWithRevealAndLambdas()
{
Reveal.SetDefaultConvention(x => x);
UserGroupLinkEntity link = null;
GroupEntity group = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link)
.RightOuter.Join(u => link.Group, () => group)
.Select(u => group.Id);
FlowQuerySelection <GroupEntity> groups = Query <GroupEntity>()
.Where(g => g.Id, FqIs.In(query))
.Select();
Assert.That(groups.Count(), Is.EqualTo(2));
Reveal.ClearDefaultConvention();
}
public void CanRightOuterJoinCollectionWithRevealAndLambdas()
{
Reveal.SetDefaultConvention(x => x);
UserGroupLinkEntity link = null;
GroupEntity group = null;
CustomerGroupLinkEntity customerLink = null;
CustomerEntity customer = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link)
.RightOuter.Join(u => link.Group, () => group)
.RightOuter.Join(u => group.Customers, () => customerLink)
.RightOuter.Join(u => customerLink.Customer, () => customer)
.Distinct()
.Select(u => customer.Name);
FlowQuerySelection <CustomerEntity> customers = Query <CustomerEntity>()
.Where(g => g.Name, FqIs.In(query))
.Select();
Assert.That(customers.Count(), Is.EqualTo(4));
IDetachedFlowQuery <UserEntity> query2 = DetachedQuery <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link, () => link.Id == 0)
.RightOuter.Join(x => link.Group, () => group, () => group.Id == 0)
.RightOuter.Join(u => group.Customers, () => customerLink, () => customerLink.Id == 0, null)
.RightOuter.Join(u => customerLink.Customer, () => customer, () => customer.Id == 0)
.Distinct()
.Select(u => customer.Name);
FlowQuerySelection <CustomerEntity> customers2 = Query <CustomerEntity>()
.Where(g => g.Name, FqIs.In(query2))
.Select();
Assert.That(customers2.Count(), Is.EqualTo(4));
Reveal.ClearDefaultConvention();
}
public void DoesNotSkipOrderByStatementsIfNecessaryInSubqueryTest3()
{
IDetachedFlowQuery <UserEntity> detached = Query <UserEntity>()
.Detached()
.Limit(2, 2)
.OrderByDescending(x => x.IsOnline)
.Select(x => x.Id);
Assert
.That
(
() =>
{
FlowQuerySelection <UserEntity> users = Query <UserEntity>()
.Where(x => x.Id, FqIs.In(detached))
.Select();
Assert.That(users.Count(), Is.EqualTo(2));
Assert.That(users.All(x => x.IsOnline), Is.False);
},
Throws.Nothing
);
}
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"));
}
