public void TestJoinedSubclass()
{
ISession s = OpenSession();
Employee mark = new Employee();
mark.Name = "Mark";
mark.Title = "internal sales";
mark.Sex = 'M';
mark.Address.Street = "buckhead";
mark.Address.Zip = "30305";
mark.Address.Country = "USA";
Customer joe = new Customer();
joe.Name = "Joe";
joe.Address.Street = "San Francisco";
joe.Address.Zip = "54353";
joe.Address.Country = "USA";
joe.Comments = "very demanding";
joe.Sex = 'M';
joe.Salesperson = mark;
Person mom = new Person();
mom.Name = "mom";
mom.Sex = 'F';
s.Save( mom );
s.Save( mark );
s.Save( joe );
s.Flush();
Assert.AreEqual( 3, s.CreateQuery( "from Person" ).List().Count );
IQuery query = s.CreateQuery( "from Customer" );
IList results = query.List();
Assert.AreEqual( 1, results.Count );
Assert.IsTrue( results[0] is Customer, "should be a customer" );
// in later versions of hibernate a Clear method was added to session
s.Close();
s = OpenSession();
IList customers = s.CreateQuery( "from Customer c left join fetch c.Salesperson" ).List();
foreach( Customer c in customers )
{
// when proxies is working this is important
Assert.IsTrue( NHibernateUtil.IsInitialized( c.Salesperson ) );
Assert.AreEqual( "Mark", c.Salesperson.Name );
}
Assert.AreEqual( 1, customers.Count );
s.Close();
s = OpenSession();
customers = s.CreateQuery( "from Customer" ).List();
foreach( Customer c in customers )
{
//TODO: proxies make this work
Assert.IsFalse( NHibernateUtil.IsInitialized( c.Salesperson ) );
Assert.AreEqual( "Mark", c.Salesperson.Name );
}
Assert.AreEqual( 1, customers.Count );
s.Close();
s = OpenSession();
mark = (Employee)s.Load( typeof(Employee), mark.Id );
joe = (Customer)s.Load( typeof(Customer), joe.Id );
mark.Address.Zip = "30306" ;
Assert.AreEqual( 1, s.CreateQuery( "from Person p where p.Address.Zip = '30306'" ).List().Count );
s.Delete( mom );
s.Delete( joe );
s.Delete( mark );
Assert.AreEqual( 0, s.CreateQuery( "from Person" ).List().Count );
s.Close();
}
public void TestHql()
{
// test the Save
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
Employee wally = new Employee();
wally.Name = "wally";
wally.Title = "Unmanaged Employee";
Employee dilbert = new Employee();
dilbert.Name = "dilbert";
dilbert.Title = "office clown";
Employee pointyhair = new Employee();
pointyhair.Name = "pointyhair";
pointyhair.Title = "clown watcher";
dilbert.Manager = pointyhair;
s.Save( wally );
s.Save( dilbert );
s.Save( pointyhair );
t.Commit();
s.Close();
// get a proxied - initialized version of manager
s = OpenSession();
pointyhair = (Employee) s.Load( typeof(Employee), pointyhair.Id );
NHibernateUtil.Initialize( pointyhair );
s.Close();
s = OpenSession();
IQuery q = s.CreateQuery( "from Employee as e where e.Manager = :theMgr" );
q.SetParameter( "theMgr", pointyhair );
IList results = q.List();
Assert.AreEqual( 1, results.Count, "should only return 1 employee.");
dilbert = (Employee)results[0];
Assert.AreEqual( "dilbert", dilbert.Name, "should have been dilbert returned.");
s.Delete( wally );
s.Delete( pointyhair );
s.Delete( dilbert );
s.Flush();
s.Close();
}
public void TestCRUD() {
// test the Save
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
Employee emp = new Employee();
emp.Name = "test one";
emp.Title = "office clown";
s.Save(emp);
Person person = new Person();
person.Name = "the test string";
s.Save(person);
t.Commit();
s.Close();
int empId = emp.Id;
int personId = person.Id;
// lets verify the correct classes were saved
s = OpenSession();
t = s.BeginTransaction();
// perform a load based on the base class
Person empAsPerson = (Person)s.Find( "from Person as p where p.id = ?", empId, NHibernateUtil.Int32 )[0];
person = (Person)s.Load( typeof(Person), personId );
// the object with id=2 was loaded using the base class - lets make sure it actually loaded
// the sublcass
Assert.AreEqual( typeof(Employee), empAsPerson.GetType(), "even though person was queried, should have returned correct subclass.");
emp = (Employee)s.Load( typeof(Employee), empId );
// lets update the objects
person.Name = "Did it get updated";
person.Sex = 'M';
// update the properties from the subclass and base class
emp.Name = "Updated Employee String";
emp.Title = "office dunce";
// verify the it actually changes the same object
Assert.AreEqual( emp.Name, empAsPerson.Name, "emp and empAsPerson should refer to same object." );
// save it through the base class reference and make sure that the
// subclass properties get updated.
s.Update( empAsPerson );
s.Update( person );
t.Commit();
s.Close();
// lets test the Criteria interface for subclassing
s = OpenSession();
t = s.BeginTransaction();
IList results = s.CreateCriteria( typeof(Person) )
.Add(Expression.Expression.In( "Name", new string[] {"Did it get updated", "Updated Employee String" }))
.List();
Assert.AreEqual( 2, results.Count);
person = null;
emp = null;
foreach(Person obj in results)
{
if(obj is Employee)
emp = (Employee)obj;
else
person = obj;
}
// verify the properties got updated
Assert.AreEqual( 'M', person.Sex );
Assert.AreEqual( "office dunce", emp.Title );
s.Delete( emp );
s.Delete( person );
t.Commit();
s.Close();
}
public void SelectByClass()
{
using (ISession s = OpenSession())
using (ITransaction t = s.BeginTransaction())
{
Person wally = new Person();
wally.Name = "wally";
Employee dilbert = new Employee();
dilbert.Name = "dilbert";
dilbert.Title = "office clown";
s.Save(wally);
s.Save(dilbert);
s.Flush();
Assert.AreSame(wally, s.CreateQuery("select p from Person p where p.class = Person").UniqueResult());
Assert.AreSame(dilbert, s.CreateQuery("select p from Person p where p.class = Employee").UniqueResult());
s.Delete(wally);
s.Delete(dilbert);
t.Commit();
}
}
