public async Task UnconstrainedNoCacheAsync()
{
ISession session = OpenSession();
ITransaction tx = session.BeginTransaction();
Person p = new Person("gavin");
p.EmployeeId = "123456";
await(session.SaveAsync(p));
await(tx.CommitAsync());
session.Close();
await(Sfi.EvictAsync(typeof(Person)));
session = OpenSession();
tx = session.BeginTransaction();
p = (Person)await(session.GetAsync(typeof(Person), "gavin"));
Assert.IsNull(p.Employee);
p.Employee = new Employee("123456");
await(tx.CommitAsync());
session.Close();
await(Sfi.EvictAsync(typeof(Person)));
session = OpenSession();
tx = session.BeginTransaction();
p = (Person)await(session.GetAsync(typeof(Person), "gavin"));
Assert.IsNotNull(p.Employee);
Assert.IsTrue(NHibernateUtil.IsInitialized(p.Employee));
await(session.DeleteAsync(p));
await(tx.CommitAsync());
session.Close();
}
public async Task ExtraLazyWithWhereClauseAsync()
{
using (ISession s = OpenSession())
using (ITransaction t = s.BeginTransaction())
{
await(s.CreateSQLQuery("insert into Users (Name,Password) values('gavin','secret')")
.UniqueResultAsync());
await(s.CreateSQLQuery("insert into Photos (Title,Owner) values('PRVaaa','gavin')")
.UniqueResultAsync());
await(s.CreateSQLQuery("insert into Photos (Title,Owner) values('PUBbbb','gavin')")
.UniqueResultAsync());
await(t.CommitAsync());
}
using (ISession s = OpenSession())
{
var gavin = await(s.GetAsync <User>("gavin"));
Assert.AreEqual(1, gavin.Photos.Count);
Assert.IsFalse(NHibernateUtil.IsInitialized(gavin.Documents));
}
using (ISession s = OpenSession())
using (ITransaction t = s.BeginTransaction())
{
await(s.CreateSQLQuery("delete from Photos")
.UniqueResultAsync());
await(s.CreateSQLQuery("delete from Users")
.UniqueResultAsync());
await(t.CommitAsync());
}
await(Sfi.EvictAsync(typeof(User)));
await(Sfi.EvictAsync(typeof(Photo)));
}
public async System.Threading.Tasks.Task InsertShouldNotDependOnEntityEqualsImplementationAsync()
{
var person = new PersonWithWrongEquals {
Name = "AnimalOwner"
};
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
await(s.SaveAsync(person));
await(t.CommitAsync());
}
await(Sfi.EvictAsync(typeof(PersonWithWrongEquals)));
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var personProxy = await(s.GetAsync <PersonWithWrongEquals>(person.Id));
await(s.SaveAsync(new Cat {
Name = "Felix", Owner = personProxy
}));
await(s.SaveAsync(new Cat {
Name = "Loustic", Owner = personProxy
}));
Assert.DoesNotThrowAsync(() => { return(t.CommitAsync()); });
}
}
public async System.Threading.Tasks.Task InsertShouldNotInitializeManyToOneProxyAsync()
{
var person = new Person {
Name = "AnimalOwner"
};
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
await(s.SaveAsync(person));
await(t.CommitAsync());
}
await(Sfi.EvictAsync(typeof(Person)));
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var personProxy = await(s.LoadAsync <Person>(person.Id));
Assert.That(NHibernateUtil.IsInitialized(personProxy), Is.False, "Person proxy already initialized after load");
await(s.SaveAsync(new Cat {
Name = "Felix", Owner = personProxy
}));
await(s.SaveAsync(new Cat {
Name = "Loustic", Owner = personProxy
}));
Assert.That(NHibernateUtil.IsInitialized(personProxy), Is.False, "Person proxy initialized after saves");
await(t.CommitAsync());
Assert.That(NHibernateUtil.IsInitialized(personProxy), Is.False, "Person proxy initialized after commit");
}
}
public async Task TestAsync()
{
Guid a_id;
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
// Create an A and save it
ClassA a = new ClassA();
a.Name = "a1";
await(s.SaveAsync(a));
a_id = a.Id;
a.Childs = new List <WebImage>();
a.Childs.Add(new WebImage()
{
ImageUrl = "http://blabla/bla1.jpg", ImageData = new byte[] { 11 }
});
a.Childs.Add(new WebImage()
{
ImageUrl = "http://blabla/bla2.jpg", ImageData = new byte[] { 13 }
});
await(tx.CommitAsync());
}
// Clear the cache
await(Sfi.EvictAsync(typeof(ClassA)));
await(Sfi.EvictAsync(typeof(WebImage)));
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
// Load a so we can use it to load b
ClassA a = await(s.GetAsync <ClassA>(a_id));
Assert.That(a.Childs, Has.Count.EqualTo(2));
var firstElement = a.Childs[0];
//I'm expect an object to be equal to itself
Assert.That(firstElement.Equals(firstElement));
//expect a list to contain the first element
Assert.That(a.Childs.Contains(a.Childs[0]));
await(tx.CommitAsync());
}
}
public async Task EntitySubselectAsync()
{
var s = OpenSession();
var t = s.BeginTransaction();
Human gavin = new Human();
gavin.Name = "gavin";
gavin.Sex = 'M';
gavin.Address = "Melbourne, Australia";
Alien x23y4 = new Alien();
x23y4.Identity = "x23y4$$hu%3";
x23y4.Planet = "Mars";
x23y4.Species = "martian";
await(s.SaveAsync(gavin));
await(s.SaveAsync(x23y4));
await(s.FlushAsync());
var beings = await(s.CreateQuery("from Being").ListAsync <Being>());
Assert.That(beings, Has.Count.GreaterThan(0));
foreach (var being in beings)
{
Assert.That(being.Location, Is.Not.Null.And.Not.Empty);
Assert.That(being.Identity, Is.Not.Null.And.Not.Empty);
Assert.That(being.Species, Is.Not.Null.And.Not.Empty);
}
s.Clear();
await(Sfi.EvictAsync(typeof(Being)));
Being gav = await(s.GetAsync <Being>(gavin.Id));
Assert.That(gav.Location, Is.Not.Null.And.Not.Empty);
Assert.That(gav.Identity, Is.Not.Null.And.Not.Empty);
Assert.That(gav.Species, Is.Not.Null.And.Not.Empty);
s.Clear();
//test the <synchronized> tag:
gavin = await(s.GetAsync <Human>(gavin.Id));
gavin.Address = "Atlanta, GA";
gav = await(s.CreateQuery("from Being b where b.Location like '%GA%'").UniqueResultAsync <Being>());
Assert.That(gav.Location, Is.EqualTo(gavin.Address));
await(s.DeleteAsync(gavin));
await(s.DeleteAsync(x23y4));
Assert.That(await(s.CreateQuery("from Being").ListAsync <Being>()), Is.Empty);
await(t.CommitAsync());
s.Close();
}
public async Task UnconstrainedOuterJoinFetchAsync()
{
ISession session = OpenSession();
ITransaction tx = session.BeginTransaction();
Person p = new Person("gavin");
p.EmployeeId = "123456";
await(session.SaveAsync(p));
await(tx.CommitAsync());
session.Close();
await(Sfi.EvictAsync(typeof(Person)));
session = OpenSession();
tx = session.BeginTransaction();
p = (Person)await(session.CreateCriteria(typeof(Person))
.Fetch("Employee")
.Add(Expression.Eq("Name", "gavin"))
.UniqueResultAsync());
Assert.IsNull(p.Employee);
p.Employee = new Employee("123456");
await(tx.CommitAsync());
session.Close();
await(Sfi.EvictAsync(typeof(Person)));
session = OpenSession();
tx = session.BeginTransaction();
p = (Person)await(session.CreateCriteria(typeof(Person))
.Fetch("Employee")
.Add(Expression.Eq("Name", "gavin"))
.UniqueResultAsync());
Assert.IsTrue(NHibernateUtil.IsInitialized(p.Employee));
Assert.IsNotNull(p.Employee);
await(session.DeleteAsync(p));
await(tx.CommitAsync());
session.Close();
}
public async System.Threading.Tasks.Task InsertShouldNotInitializeOneToManyProxyAsync()
{
var cat = new Cat {
Name = "Felix"
};
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
await(s.SaveAsync(cat));
await(t.CommitAsync());
}
await(Sfi.EvictAsync(typeof(Cat)));
using (var s = OpenSession())
using (var t = s.BeginTransaction())
{
var catProxy = await(s.LoadAsync <Cat>(cat.Id));
Assert.That(NHibernateUtil.IsInitialized(catProxy), Is.False, "Cat proxy already initialized after load");
var owner = new Person {
Name = "AnimalOwner"
};
owner.AnimalsGeneric.Add(catProxy);
// Following assert would fail if the collection was changed for a set.
Assert.That(NHibernateUtil.IsInitialized(catProxy), Is.False, "Cat proxy initialized after collection add");
await(s.SaveAsync(owner));
Assert.That(NHibernateUtil.IsInitialized(catProxy), Is.False, "Cat proxy initialized after save");
await(t.CommitAsync());
Assert.That(NHibernateUtil.IsInitialized(catProxy), Is.False, "Cat proxy initialized after commit");
// The collection being inverse, the cat owner is not actually set in this test, but that is enough
// to check the trouble. The ordering logic does not short-circuit on inverse collections. (It could
// be an optimization, but it may cause regressions for some edge case mappings, like one having an
// inverse one-to-many with no matching many-to-one but a basic type property for the foreign key
// instead.)
}
}
public async Task SubclassCollectionAsync()
{
ISession s = OpenSession();
SubMulti sm = new SubMulti();
SubMulti sm1 = new SubMulti();
SubMulti sm2 = new SubMulti();
sm.Children = new List <SubMulti> {
sm1, sm2
};
sm.MoreChildren = new List <SubMulti> {
sm1, sm2
};
sm.ExtraProp = "foo";
sm1.Parent = sm;
sm2.Parent = sm;
object id = await(s.SaveAsync(sm));
await(s.SaveAsync(sm1));
await(s.SaveAsync(sm2));
await(s.FlushAsync());
s.Close();
await(Sfi.EvictAsync(typeof(SubMulti)));
s = OpenSession();
// TODO: I don't understand why h2.0.3/h2.1 issues a select statement here
Assert.AreEqual(2,
(await(s.CreateQuery(
"select s from SubMulti as sm join sm.Children as s where s.Amount>-1 and s.Name is null").ListAsync())).
Count);
Assert.AreEqual(2, (await(s.CreateQuery("select elements(sm.Children) from SubMulti as sm").ListAsync())).Count);
Assert.AreEqual(1,
(await(s.CreateQuery(
"select distinct sm from SubMulti as sm join sm.Children as s where s.Amount>-1 and s.Name is null")
.ListAsync())).Count);
sm = (SubMulti)await(s.LoadAsync(typeof(SubMulti), id));
Assert.AreEqual(2, sm.Children.Count);
ICollection filterColl =
await((await(s.CreateFilterAsync(sm.MoreChildren, "select count(*) where this.Amount>-1 and this.Name is null"))).ListAsync());
foreach (object obj in filterColl)
{
Assert.AreEqual(2, obj);
// only want the first one
break;
}
Assert.AreEqual("FOO", sm.Derived, "should have uppercased the column in a formula");
IEnumerator enumer =
(await(s.CreateQuery("select distinct s from s in class SubMulti where s.MoreChildren[1].Amount < 1.0").EnumerableAsync())).
GetEnumerator();
Assert.IsTrue(enumer.MoveNext());
Assert.AreSame(sm, enumer.Current);
Assert.AreEqual(2, sm.MoreChildren.Count);
await(s.DeleteAsync(sm));
foreach (object obj in sm.Children)
{
await(s.DeleteAsync(obj));
}
await(s.FlushAsync());
s.Close();
}
public async Task TestAsync()
{
int a_id;
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
// Create an A and save it
ClassA a = new ClassA();
a.Name = "a1";
await(s.SaveAsync(a));
// Create a B and save it
ClassB b = new ClassB();
b.Id = new ClassBId("bbb", a);
b.SomeProp = "Some property";
await(s.SaveAsync(b));
// Create a C and save it
ClassC c = new ClassC();
c.B = b;
await(s.SaveAsync(c));
await(tx.CommitAsync());
a_id = a.Id;
}
// Clear the cache
await(Sfi.EvictAsync(typeof(ClassA)));
await(Sfi.EvictAsync(typeof(ClassB)));
await(Sfi.EvictAsync(typeof(ClassC)));
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
// Load a so we can use it to load b
ClassA a = await(s.GetAsync <ClassA>(a_id));
// Load b so b will be in cache
ClassB b = await(s.GetAsync <ClassB>(new ClassBId("bbb", a)));
await(tx.CommitAsync());
}
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
using (SqlLogSpy sqlLogSpy = new SqlLogSpy())
{
IList <ClassC> c_list = await(s.CreateCriteria(typeof(ClassC)).ListAsync <ClassC>());
// make sure we initialize B
await(NHibernateUtil.InitializeAsync(c_list[0].B));
Assert.AreEqual(1, sqlLogSpy.Appender.GetEvents().Length,
"Only one SQL should have been issued");
}
await(tx.CommitAsync());
}
}
public async Task HandSQLAsync()
{
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
Organization ifa = new Organization("IFA");
Organization jboss = new Organization("JBoss");
Person gavin = new Person("Gavin");
Employment emp = new Employment(gavin, jboss, "AU");
object orgId = await(s.SaveAsync(jboss));
await(s.SaveAsync(ifa));
await(s.SaveAsync(gavin));
await(s.SaveAsync(emp));
await(t.CommitAsync());
t = s.BeginTransaction();
Person christian = new Person("Christian");
await(s.SaveAsync(christian));
Employment emp2 = new Employment(christian, jboss, "EU");
await(s.SaveAsync(emp2));
await(t.CommitAsync());
s.Close();
await(Sfi.EvictAsync(typeof(Organization)));
await(Sfi.EvictAsync(typeof(Person)));
await(Sfi.EvictAsync(typeof(Employment)));
s = OpenSession();
t = s.BeginTransaction();
jboss = (Organization)await(s.GetAsync(typeof(Organization), orgId));
Assert.AreEqual(jboss.Employments.Count, 2);
emp = (Employment)GetFirstItem(jboss.Employments);
gavin = emp.Employee;
Assert.AreEqual(gavin.Name, "GAVIN");
Assert.AreEqual(s.GetCurrentLockMode(gavin), LockMode.Upgrade);
emp.EndDate = DateTime.Today;
Employment emp3 = new Employment(gavin, jboss, "US");
await(s.SaveAsync(emp3));
await(t.CommitAsync());
s.Close();
s = OpenSession();
t = s.BeginTransaction();
IEnumerator iter = (await(s.GetNamedQuery("allOrganizationsWithEmployees").ListAsync())).GetEnumerator();
Assert.IsTrue(iter.MoveNext());
Organization o = (Organization)iter.Current;
Assert.AreEqual(o.Employments.Count, 3);
foreach (Employment e in o.Employments)
{
await(s.DeleteAsync(e));
}
foreach (Employment e in o.Employments)
{
await(s.DeleteAsync(e.Employee));
}
await(s.DeleteAsync(o));
Assert.IsFalse(iter.MoveNext());
await(s.DeleteAsync(ifa));
await(t.CommitAsync());
s.Close();
}
public async Task MergeDeepTreeWithGeneratedIdAsync()
{
ClearCounts();
NumberedNode root;
NumberedNode child;
NumberedNode grandchild;
using (ISession s = OpenSession())
{
ITransaction tx = s.BeginTransaction();
root = new NumberedNode("root", RoundForDialect(DateTime.Now));
child = new NumberedNode("child", RoundForDialect(DateTime.Now));
grandchild = new NumberedNode("grandchild", RoundForDialect(DateTime.Now));
root.AddChild(child);
child.AddChild(grandchild);
root = (NumberedNode)await(s.MergeAsync(root));
await(tx.CommitAsync());
}
AssertInsertCount(3);
AssertUpdateCount(0);
ClearCounts();
IEnumerator <NumberedNode> rit = root.Children.GetEnumerator();
rit.MoveNext();
child = rit.Current;
IEnumerator <NumberedNode> cit = child.Children.GetEnumerator();
cit.MoveNext();
grandchild = cit.Current;
grandchild.Description = "the grand child";
var grandchild2 = new NumberedNode("grandchild2", RoundForDialect(DateTime.Now));
child.AddChild(grandchild2);
using (ISession s = OpenSession())
{
ITransaction tx = s.BeginTransaction();
root = (NumberedNode)await(s.MergeAsync(root));
await(tx.CommitAsync());
}
AssertInsertCount(1);
AssertUpdateCount(1);
ClearCounts();
await(Sfi.EvictAsync(typeof(NumberedNode)));
var child2 = new NumberedNode("child2", RoundForDialect(DateTime.Now));
var grandchild3 = new NumberedNode("grandchild3", RoundForDialect(DateTime.Now));
child2.AddChild(grandchild3);
root.AddChild(child2);
using (ISession s = OpenSession())
{
ITransaction tx = s.BeginTransaction();
root = (NumberedNode)await(s.MergeAsync(root));
await(tx.CommitAsync());
}
AssertInsertCount(2);
AssertUpdateCount(0);
ClearCounts();
using (ISession s = OpenSession())
{
ITransaction tx = s.BeginTransaction();
await(s.DeleteAsync("from NumberedNode where name like 'grand%'"));
await(s.DeleteAsync("from NumberedNode where name like 'child%'"));
await(s.DeleteAsync("from NumberedNode"));
await(tx.CommitAsync());
}
}
private async Task EvictAsync(ISession session, GridWidget widget, CancellationToken cancellationToken = default(CancellationToken))
{
await(session.EvictAsync(widget, cancellationToken));
await(Sfi.EvictAsync(widget.GetType(), cancellationToken));
}