public void EntityProjectionLockMode()
{
if (Dialect is Oracle8iDialect)
{
Assert.Ignore("Oracle is not supported due to #1352 bug (NH-3902)");
}
var upgradeHint = Dialect.ForUpdateString;
if (string.IsNullOrEmpty(upgradeHint))
{
upgradeHint = this.Dialect.AppendLockHint(LockMode.Upgrade, string.Empty);
}
if (string.IsNullOrEmpty(upgradeHint))
{
Assert.Ignore($"Upgrade hint is not supported by dialect {Dialect.GetType().Name}");
}
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntitySimpleChild child1 = null;
child1 = session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1)
.Lock(() => child1).Upgrade
.Select(Projections.Entity(() => child1))
.Take(1).SingleOrDefault <EntitySimpleChild>();
Assert.That(child1, Is.Not.Null);
Assert.That(NHibernateUtil.IsInitialized(child1), Is.True, "Object must be initialized");
Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
Assert.That(sqlLog.Appender.GetEvents()[0].RenderedMessage, Does.Contain(upgradeHint));
}
}
public void EntityProjectionForEntityJoin()
{
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntitySimpleChild ejChild1 = null;
EntityComplex root = null;
EntityComplex st = null;
var r = session
.QueryOver(() => root)
.JoinAlias(c => c.SameTypeChild, () => st)
.JoinEntityAlias(() => ejChild1, () => ejChild1.Id == root.Child1.Id)
.Select(
Projections.RootEntity(),
Projections.Entity(() => st),
Projections.Entity(() => ejChild1)
)
.SingleOrDefault <object[]>();
var rootObj = (EntityComplex)r[0];
var mappedObj = (EntityComplex)r[1];
var entityJoinObj = (EntitySimpleChild)r[2];
Assert.That(rootObj, Is.Not.Null);
Assert.That(mappedObj, Is.Not.Null);
Assert.That(entityJoinObj, Is.Not.Null);
Assert.That(NHibernateUtil.IsInitialized(rootObj), Is.True);
Assert.That(NHibernateUtil.IsInitialized(mappedObj), Is.True);
Assert.That(NHibernateUtil.IsInitialized(entityJoinObj), Is.True);
}
}
protected override void OnSetUp()
{
using (var session = OpenSession())
using (var transaction = session.BeginTransaction())
{
var child1 = new EntitySimpleChild
{
Name = "Child1"
};
var child2 = new EntitySimpleChild
{
Name = "Child1"
};
var parent = new EntityComplex
{
Name = "ComplexEnityParent",
Child1 = child1,
Child2 = child2,
LazyProp = "SomeBigValue",
SameTypeChild = new EntityComplex()
{
Name = "ComplexEntityChild"
}
};
_entityWithCustomEntityName = new EntityCustomEntityName()
{
Name = "EntityCustomEntityName"
};
_entityWithCompositeId = new EntityWithCompositeId
{
Key = new CompositeKey
{
Id1 = 1,
Id2 = 2
},
Name = "Composite"
};
session.Save(child1);
session.Save(child2);
session.Save(parent.SameTypeChild);
session.Save(parent);
session.Save(_entityWithCompositeId);
session.Save(customEntityName, _entityWithCustomEntityName);
session.Flush();
transaction.Commit();
}
}
public async Task NullEntityProjectionAsync()
{
using (var session = OpenSession())
{
EntitySimpleChild child1 = null;
child1 = await(session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1, JoinType.LeftOuterJoin)
.Where(() => child1.Id == null)
.Select(Projections.Entity(() => child1))
.Take(1).SingleOrDefaultAsync <EntitySimpleChild>());
Assert.That(child1, Is.Null);
}
}
public async Task EntityProjectionAsSelectExpressionAsync()
{
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntitySimpleChild child1 = null;
child1 = await(session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1)
.Select(ec => child1.AsEntity())
.Take(1).SingleOrDefaultAsync <EntitySimpleChild>());
Assert.That(child1, Is.Not.Null);
Assert.That(NHibernateUtil.IsInitialized(child1), Is.True, "Object must be initialized");
Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
}
}
public void NullEntityProjection()
{
#pragma warning disable CS8073 //The result of the expression is always 'false'
using (var session = OpenSession())
{
EntitySimpleChild child1 = null;
child1 = session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1, JoinType.LeftOuterJoin)
.Where(() => child1.Id == null)
.Select(Projections.Entity(() => child1))
.Take(1).SingleOrDefault <EntitySimpleChild>();
Assert.That(child1, Is.Null);
}
#pragma warning restore CS8073 //The result of the expression is always 'false'
}
public void EntityProjectionAsSelectExpressionForArgumentAlias()
{
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntitySimpleChild child1 = null;
var complex = session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1)
.Select(ec => ec.AsEntity())
.Take(1).SingleOrDefault();
Assert.That(complex, Is.Not.Null);
Assert.That(NHibernateUtil.IsInitialized(complex), Is.True, "Object must be initialized");
Assert.That(NHibernateUtil.IsInitialized(complex.Child1), Is.False, "Object must be lazy");
Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
}
}
public void MixOfJoinsForAssociatedAndNotAssociatedEntities()
{
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntityComplex root = null;
EntityComplex ejLevel1 = null;
EntitySimpleChild customChildForEjLevel1 = null;
EntityComplex entityComplexForEjLevel1 = null;
EntitySimpleChild ejLevel2OnEntityComplexForEjLevel1 = null;
var obj = session
.QueryOver(() => root)
.JoinEntityAlias(() => ejLevel1, Restrictions.Where(() => ejLevel1.Id == root.SameTypeChild.Id && root.Id != null), JoinType.LeftOuterJoin)
.JoinAlias(() => ejLevel1.Child1, () => customChildForEjLevel1, JoinType.InnerJoin)
.JoinAlias(() => ejLevel1.SameTypeChild, () => entityComplexForEjLevel1, JoinType.LeftOuterJoin)
.JoinEntityAlias(() => ejLevel2OnEntityComplexForEjLevel1, () => entityComplexForEjLevel1.Id == ejLevel2OnEntityComplexForEjLevel1.Id)
.Where(() => customChildForEjLevel1.Id != null && ejLevel2OnEntityComplexForEjLevel1.Id != null)
.Take(1)
.SingleOrDefault <object>();
}
}
public async Task MultipleEntitiesProjectionsToResultTransformerAsync()
{
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
MultipleEntitiesResult r = null;
EntitySimpleChild child1 = null;
EntitySimpleChild child2 = null;
EntityComplex sameAsRootChild = null;
EntitySimpleChild nullListElem = null;
r = await(session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1)
.JoinAlias(ep => ep.Child2, () => child2)
.JoinAlias(ep => ep.SameTypeChild, () => sameAsRootChild)
.JoinAlias(ep => ep.ChildrenList, () => nullListElem, JoinType.LeftOuterJoin)
.Select(
Projections.RootEntity().WithAlias(nameof(r.Root)),
Projections.Entity(() => child1),
Projections.Property(() => child2.Name).As(nameof(r.Name)),
Projections.Entity(() => child2),
Projections.Property(() => child1.Id),
Projections.Entity(() => sameAsRootChild),
Projections.Entity(() => nullListElem)
)
.TransformUsing(Transformers.AliasToBean <MultipleEntitiesResult>())
.Take(1)
.SingleOrDefaultAsync <MultipleEntitiesResult>());
Assert.That(NHibernateUtil.IsInitialized(r.Root), Is.True, "Root must be initialized");
Assert.That(NHibernateUtil.IsInitialized(r.Child1), Is.True, "Child1 must be initialized");
Assert.That(NHibernateUtil.IsInitialized(r.Child2), Is.True, "Child2 must be initialized");
Assert.That(NHibernateUtil.IsInitialized(r.SameAsRootChild), Is.True, "SameAsRootChild must be initialized");
Assert.That(r.NullListElem, Is.Null, "NullListElem must be null");
Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
}
}
public async Task MultipleEntitiesProjectionsAsync()
{
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntityComplex root = null;
EntitySimpleChild child1 = null;
EntitySimpleChild child2 = null;
EntityComplex sameAsRootChild = null;
EntitySimpleChild nullListElem = null;
var objects = await(session
.QueryOver <EntityComplex>()
.JoinAlias(ep => ep.Child1, () => child1)
.JoinAlias(ep => ep.Child2, () => child2)
.JoinAlias(ep => ep.SameTypeChild, () => sameAsRootChild)
.JoinAlias(ep => ep.ChildrenList, () => nullListElem, JoinType.LeftOuterJoin)
.Select(
Projections.RootEntity(),
Projections.Entity(() => child1),
Projections.Entity(() => child2),
Projections.Entity(() => sameAsRootChild),
Projections.Entity(() => nullListElem)
)
.Take(1).SingleOrDefaultAsync <object[]>());
root = (EntityComplex)objects[0];
child1 = (EntitySimpleChild)objects[1];
child2 = (EntitySimpleChild)objects[2];
sameAsRootChild = (EntityComplex)objects[3];
nullListElem = (EntitySimpleChild)objects[4];
Assert.That(NHibernateUtil.IsInitialized(root), Is.True, "root must be initialized");
Assert.That(NHibernateUtil.IsInitialized(child1), Is.True, "child1 must be initialized");
Assert.That(NHibernateUtil.IsInitialized(child2), Is.True, "child2 must be initialized");
Assert.That(NHibernateUtil.IsInitialized(sameAsRootChild), Is.True, "sameAsRootChild must be initialized");
Assert.That(nullListElem, Is.Null, "nullListElem must be null");
Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
}
}
public async Task MixOfJoinsForAssociatedAndNotAssociatedEntitiesAsync()
{
#pragma warning disable CS8073 //The result of the expression is always 'false'
using (var sqlLog = new SqlLogSpy())
using (var session = OpenSession())
{
EntityComplex root = null;
EntityComplex ejLevel1 = null;
EntitySimpleChild customChildForEjLevel1 = null;
EntityComplex entityComplexForEjLevel1 = null;
EntitySimpleChild ejLevel2OnEntityComplexForEjLevel1 = null;
var obj = await(session
.QueryOver(() => root)
.JoinEntityAlias(() => ejLevel1, Restrictions.Where(() => ejLevel1.Id == root.SameTypeChild.Id && root.Id != null), JoinType.LeftOuterJoin)
.JoinAlias(() => ejLevel1.Child1, () => customChildForEjLevel1, JoinType.InnerJoin)
.JoinAlias(() => ejLevel1.SameTypeChild, () => entityComplexForEjLevel1, JoinType.LeftOuterJoin)
.JoinEntityAlias(() => ejLevel2OnEntityComplexForEjLevel1, () => entityComplexForEjLevel1.Id == ejLevel2OnEntityComplexForEjLevel1.Id)
.Where(() => customChildForEjLevel1.Id != null && ejLevel2OnEntityComplexForEjLevel1.Id != null)
.Take(1)
.SingleOrDefaultAsync <object>());
}
#pragma warning restore CS8073 //The result of the expression is always 'false'
}
public async Task MultipleLazyEntityProjectionsAsync()
{
using (var session = OpenSession())
{
EntitySimpleChild child1 = null;
EntityComplex root = null;
EntityComplex sameTypeChild = null;
EntitySimpleChild child2 = null;
var result = await(session
.QueryOver(() => root)
.JoinAlias(ep => ep.SameTypeChild, () => sameTypeChild)
.JoinAlias(ep => ep.Child1, () => child1)
.JoinAlias(ep => ep.Child2, () => child2)
.Select(
Projections.RootEntity().SetLazy(true),
Projections.Entity(() => child1).SetLazy(true),
Projections.Entity(() => sameTypeChild).SetLazy(true),
Projections.Entity(() => child2).SetLazy(true)
)
.Take(1).SingleOrDefaultAsync <object[]>());
root = (EntityComplex)result[0];
child1 = (EntitySimpleChild)result[1];
sameTypeChild = (EntityComplex)result[2];
child2 = (EntitySimpleChild)result[3];
Assert.That(NHibernateUtil.IsInitialized(root), Is.False, "root must be lazy loaded.");
Assert.That(NHibernateUtil.IsInitialized(sameTypeChild), Is.False, "sameTypeChild must be lazy loaded.");
Assert.That(NHibernateUtil.IsInitialized(child1), Is.False, "child1 must be lazy loaded.");
Assert.That(NHibernateUtil.IsInitialized(child2), Is.False, "child2 must be lazy loaded.");
//make sure objects are populated from different aliases for the same types
Assert.That(root.Id, Is.Not.EqualTo(sameTypeChild.Id), "Different objects are expected for root and sameTypeChild.");
Assert.That(child1.Id, Is.Not.EqualTo(child2.Id), "Different objects are expected for child1 and child2.");
}
}
