public void HowToExample1()
{
UserGroupLinkEntity linkAlias = null;
// ReSharper disable once ExpressionIsAlwaysNull
Assert.That(linkAlias, Is.Null);
}
public void CanRightOuterJoinCollectionWithRevealAndLambdas()
{
Reveal.SetDefaultConvention(x => x);
UserGroupLinkEntity link = null;
GroupEntity group = null;
CustomerGroupLinkEntity customerLink = null;
CustomerEntity customer = null;
FlowQuerySelection <string> groups1 = Query <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);
Assert.That(groups1.Count(), Is.EqualTo(4));
FlowQuerySelection <string> groups2 = Query <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link, () => link.Id == null)
.RightOuter.Join(u => link.Group, () => group, () => group.Id == null)
.RightOuter.Join(u => group.Customers, () => customerLink, () => customerLink.Id == null)
.RightOuter.Join(u => customerLink.Customer, () => customer, () => customer.Id == null)
.Distinct()
.Select(u => customer.Name);
Assert.That(groups2.Count(), Is.EqualTo(4));
Reveal.ClearDefaultConvention();
}
public void CanRightOuterJoinWithSpecifiedOnClause()
{
UserGroupLinkEntity link = null;
GroupEntity group = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link, () => link.Id == 2)
.RightOuter.Join(u => link.Group, () => group, () => group.Id == 2)
.Select(u => link.Group.Id);
FlowQuerySelection <GroupEntity> groups = Query <GroupEntity>()
.Where(g => g.Id, FqIs.In(query))
.Select();
Assert.That(groups.Count(), Is.EqualTo(1));
IDetachedFlowQuery <UserEntity> query2 = DetachedQuery <UserEntity>()
.RightOuter.Join("Groups", () => link, () => link.Id == 2)
.Select(u => link.Group.Id);
FlowQuerySelection <GroupEntity> groups2 = Query <GroupEntity>()
.Where(g => g.Id, FqIs.In(query2))
.Select();
Assert.That(groups2.Count(), Is.EqualTo(2));
}
public void HowToExample3WithOnClaus()
{
UserGroupLinkEntity linkAlias = null;
FlowQuerySelection <UserEntity> users = Session.FlowQuery <UserEntity>()
.Inner.Join(x => x.Groups, () => linkAlias, () => linkAlias.Group.Id == 1)
.Select();
Assert.That(users.Count(), Is.EqualTo(2));
}
public void CanLeftOuterJoin()
{
UserGroupLinkEntity link = null;
var groups = Query <UserEntity>()
.LeftOuter.Join(u => u.Groups, () => link)
.Select(u => new { link.Group });
Assert.That(groups.Count(), Is.EqualTo(6));
}
public void SetLockModeExample4()
{
UserGroupLinkEntity groupLink = null;
FlowQuerySelection <UserEntity> users = Session.FlowQuery <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Lock("groupLink").Write()
.Select();
Assert.That(users.Count(), Is.EqualTo(5));
}
public void WhereWithProjection1NotEqualProjection2()
{
UserGroupLinkEntity link = null;
var users = Query <UserEntity>()
.Inner.Join(u => u.Groups, () => link)
.Where(u => u.Id != link.Id)
.Select(u => new { u.Username, UserId = u.Id, LinkId = link.Id });
Assert.That(users.Count(), Is.EqualTo(4));
}
private void CanUseParameterAsAliasForJoin(GroupEntity group)
{
UserGroupLinkEntity groupLink = null;
FlowQuerySelection <long> groupIds = Query <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Inner.Join(x => groupLink.Group, () => group)
.Select(x => group.Id);
Assert.That(groupIds.Any());
}
public void CanJoinUsingString()
{
UserGroupLinkEntity link = null;
var groups = Query <UserEntity>()
.Inner.Join("Groups", () => link)
.Distinct()
.Select(u => new { link.Group });
Assert.That(groups.Count(), Is.EqualTo(2));
}
public void CanUseExternalStaticPropertyAsAliasForJoin()
{
UserGroupLinkEntity groupLink = null;
FlowQuerySelection <long> groupIds = Query <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Inner.Join(x => groupLink.Group, () => NhFq5Aliases.StaticGroupProperty)
.Select(x => NhFq5Aliases.StaticGroupProperty.Id);
Assert.That(groupIds.Any());
}
public void CanInnerJoinWithSpecifiedOnClause()
{
UserGroupLinkEntity link = null;
var groups = Query <UserEntity>()
.Inner.Join(u => u.Groups, () => link, () => link.Id == 0)
.Distinct()
.Select(u => new { link.Group });
Assert.That(groups.Count(), Is.EqualTo(0));
}
public void CanUsePrivateFieldAsAliasForJoin()
{
UserGroupLinkEntity groupLink = null;
FlowQuerySelection <long> groupIds = Query <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Inner.Join(x => groupLink.Group, () => _groupField)
.Select(x => _groupField.Id);
Assert.That(groupIds.Any());
}
public void AndWithJoinedEntityProjection()
{
UserGroupLinkEntity link = null;
var users = Query <UserEntity>()
.Inner.Join(u => u.Groups, () => link)
.And(u => u.Id == link.Id)
.Select(u => new { UserId = u.Id, LinkId = link.Id });
Assert.That(users.Count(), Is.EqualTo(1));
Assert.That(users.First().UserId, Is.EqualTo(users.First().LinkId));
}
public void CanUseExternalFieldAsAliasForJoin()
{
UserGroupLinkEntity groupLink = null;
var aliases = new NhFq5Aliases();
FlowQuerySelection <long> groupIds = Query <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Inner.Join(x => groupLink.Group, () => aliases._groupField)
.Select(x => aliases._groupField.Id);
Assert.That(groupIds.Any());
}
public void CanInnerJoinOnInnerJoinedEntityUsingString()
{
UserGroupLinkEntity link = null;
GroupEntity group = null;
var groups = Query <UserEntity>()
.Inner.Join("Groups", () => link)
.Inner.Join("link.Group", () => group)
.Distinct()
.Select(u => new { group.Name });
Assert.That(groups.Count(), Is.EqualTo(2));
}
public void CanFullJoinUsingString()
{
UserGroupLinkEntity link = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Full.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 CanRightOuterJoin()
{
UserGroupLinkEntity link = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link)
.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 SetFetchModeExample4()
{
UserGroupLinkEntity groupLink = null;
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery <UserEntity>()
.Fetch(x => x.Groups, () => groupLink).Eagerly()
.Fetch(x => groupLink.Group.Customers).Eagerly();
// ... code ...
FlowQuerySelection <UserEntity> users = query
.ClearFetches()
.Select();
Assert.That(users.Count(), Is.EqualTo(4));
}
private UserDto[] FetchUsersInGroupA1ByFilter(IQueryFilter <UserEntity> userFilter)
{
UserGroupLinkEntity userGroupLink = null;
UserEntity user = null;
return(Query <GroupEntity>()
.Inner.Join(x => x.Users, () => userGroupLink)
.Inner.Join(x => userGroupLink.User, () => user)
.And(x => x.Name == "A1")
.ApplyFilterOn(() => user, userFilter)
.Select(x => new UserDto
{
Id = user.Id
}));
}
public void HowToExample6ClearJoins()
{
UserGroupLinkEntity linkAlias = null;
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery <UserEntity>()
.Inner.Join(x => x.Groups, () => linkAlias, () => linkAlias.Group.Id == 1);
var morphable = (IMorphableFlowQuery)query;
Assert.That(morphable.Joins.Count, Is.EqualTo(1));
query.ClearJoins();
Assert.That(morphable.Joins.Count, Is.EqualTo(0));
}
public void CanRightOuterJoin()
{
UserGroupLinkEntity link = null;
var groups1 = Query <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link)
.Select(u => new { link.Group });
Assert.That(groups1.Count(), Is.EqualTo(5));
var groups2 = Query <UserEntity>()
.RightOuter.Join(u => u.Groups, () => link, () => link.Id == null)
.Select(u => new { link.Group });
Assert.That(groups2.Count(), Is.EqualTo(5));
}
public void SetLockModeExample5()
{
UserGroupLinkEntity groupLink = null;
IImmediateFlowQuery <UserEntity> query = Session.FlowQuery <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Lock().Write()
.Lock(() => groupLink).Write();
// ... code ...
FlowQuerySelection <UserEntity> users = query
.ClearLocks()
.Select();
Assert.That(users.Count(), Is.EqualTo(5));
}
public void CanFullJoinUsingString()
{
UserGroupLinkEntity link = null;
var groups1 = Query <UserEntity>()
.Full.Join("Groups", () => link)
.Select(u => new { link.Group });
Assert.That(groups1.Count(), Is.EqualTo(6));
var groups2 = Query <UserEntity>()
.Full.Join("Groups", () => link, () => link.Id == null)
.Select(u => new { link.Group });
Assert.That(groups2.Count(), Is.EqualTo(9));
}
public void TestSelectByAliasReturnsNull()
{
UserGroupLinkEntity groupLink = null;
GroupEntity group = null;
GroupEntity[] stuff1 = Query <UserEntity>()
.Inner.Join(x => x.Groups, () => groupLink)
.Inner.Join(x => groupLink.Group, () => group)
.Select(x => group)
.ToArray();
foreach (GroupEntity item in stuff1)
{
Assert.That(item, Is.Null);
}
}
public void CanLeftOuterJoinWithProvidedRevealConvention()
{
UserGroupLinkEntity link = null;
GroupEntity group = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.LeftOuter.Join(u => u.Groups, () => link)
.LeftOuter.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 void CanJoinWithoutInParameterAndWithoutConvention()
{
UserGroupLinkEntity link = null;
UserEntity user = null;
GroupEntity group = null;
var groups = Session.FlowQuery(() => user)
.Inner.Join(u => u.Groups, () => link)
.Inner.Join(u => link.Group, () => group)
.Distinct()
.Select(u => new { link.Group });
Assert.That(groups.Count(), Is.EqualTo(2));
}
public void CanInnerJoinOnInnerJoinedEntityUsingString()
{
UserGroupLinkEntity link = null;
GroupEntity group = null;
IDetachedFlowQuery <UserEntity> query = DetachedQuery <UserEntity>()
.Inner.Join("Groups", () => link)
.Inner.Join("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 CanJoinMultipleTimesWithSpecifiedOnClauses()
{
UserGroupLinkEntity link = null;
UserEntity user = null;
GroupEntity group = null;
var groups = Session.FlowQuery(() => user)
.Inner.Join(u => u.Groups, () => link, () => link.Id == user.Id)
.Inner.Join(u => link.Group, () => group, () => group.Name == "A1")
.Distinct()
.Select(u => new { link.Group });
Assert.That(groups.Count(), Is.EqualTo(1));
}
public void JoiningPropertyTwiceWithDifferentAliasesThrows()
{
UserGroupLinkEntity link = null, link2 = null;
Assert
.That
(
() =>
{
DetachedQuery <UserEntity>()
.Inner.Join(x => x.Groups, () => link)
.Inner.Join(x => x.Groups, () => link2)
.Select(x => x.Id);
},
Throws.InstanceOf <InvalidOperationException>()
);
}
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));
}
