The document provides an introduction to object-relational mapping (ORM) and NHibernate. It discusses ORM techniques for converting data between object-oriented programming languages and relational databases. It then provides an overview of NHibernate, an open source ORM framework for .NET, including its basic concepts, configuration, querying capabilities, and additional reading.

1. Samnang Chhun (samnang@wowkhmer.com)
Software Engineer,
http://tech.wowkhmer.com

2. Introduction to Object-Relational Mapping
Introduction to NHibernate
NHibernate Basics
Mapping Inheritance hierarchies
Advanced Querying
Additional Reading
2

3. 3

4. Object-relational mapping (aka ORM, O/RM, and O/R
mapping) is a programming technique for converting data
between incompatible type systems in relational databases
and object-oriented programming languages (Wikipedia)
Objects are hierarchical
Databases are relational
ORM
Relational
Objects
4

5. Performance or Scalability
Productivity: less code to write/maintain
Abstraction: transient to different DB technologies
Simplification and Consistency
Quality: depending on the product
5

6. ADO.NET Entity Framework (released with .NET 3.5 SP1)
Business Logic Toolkit for .NET
Castle ActiveRecord
IBatis.Net
LightSpeed
Linq (Language Integrated Query)
LLBLGen
LLBLGen Pro
NHibernate
Neo …etc
6

7. 7

8. Initially developed for Java
created in late 2001 by Gavin King
absorbed by the JBoss Group / Red Hat
Ported to .NET 1.1, 2.0, 3.5
Resulting product called “NHibernate”
All popular databases supported
Oracle, SQL Server, DB2, SQLite, PostgreSQL,
MySQL, Sybase, Firebird, …
XML-based configuration files
Good community support
Free/open source - NHibernate is licensed under the
LGPL (Lesser GNU Public License)
8

9. RDBMS
9

10. ISessionFactory
One per database (or application)
Expensive to create
Reads configuration
ISession
Portal to the database
Saves, retrieves
ITransaction
Encapsulates database transactions
SessionFactory
Session
Transaction
10

11. 11

12. 12

13. <class> declare a persistent class
<id> defines the mapping from that property to the
primary key column
Specifies strategy
<property> declares a persistent property of the class
<component> maps properties of a child object to
columns of the table of a parent class.
Associations
One-to-Many
Many-to-One
Many-to-Many
One-to-One (uncommon)
13

14. Element Description .NET Type
Iesi.Collections.ISet
<set> An unordered collection
Iesi.Collections.Generic.ISet<T>
that does not allow
duplicates.
System.Collections.IList
<list> An ordered collection that
System.Collections.Generic.IList<T>
allows duplicates
System.Collections.IList
<bag> An unordered collection
System.Collections.Generic.IList<T>
that allow duplicatd
14

15. 15

16. <class name=quot;Animalquot;>
<id name=quot;Idquot;>
<generator class=quot;nativequot; />
</id>
<discriminator column=quot;AnimalTypequot; length=quot;5quot; />
<property name=quot;Namequot; />
<subclass name=quot;Dogquot; discriminator-value=quot;Dogquot;>
<property name=quot;Breedquot; />
</subclass>
<subclass name=“Frogquot; discriminator-value=“Frogquot;>
<property name=“TongueLengthquot; />
</subclass>
</class>
16

17. Pros
Simple approach
Easy to add new classes, you just need to add new
columns for the additional data
Data access is fast because the data is in one table
Ad-hoc reporting is very easy because all of the data
is found in one table.
Cons
Coupling within the class hierarchy is increased
because all classes are directly coupled to the same
table. A change in one class can affect the table
which can then affect the other classes in the
hierarchy
Space potentially wasted in the database
Table can grow quickly for large hierarchies. 17

18. <class name=quot;Animalquot;>
<id name=quot;Idquot;>
<generator class=quot;nativequot; />
</id>
<property name=quot;Namequot; />
<joined-subclass name=quot;Dogquot;>
<key column=quot;Idquot; />
<property name=quot;Breedquot; />
</joined-subclass>
<joined-subclass name=quot;Frogquot;>
<key column=quot;Idquot; />
<property name=quot;TongueLengthquot; />
</joined-subclass>
</class>
18

19. Pros
Easy to understand because of the one-to-one
mapping
Very easy to modify superclasses and add new
subclasses as you merely need to modify/add one
table
Data size grows in direct proportion to growth in the
number of objects.
Cons
There are many tables in the database, one for every
class (plus tables to maintain relationships)
Potentially takes longer to read and write data using
this technique because you need to access multiple
tables
Ad-hoc reporting on your database is difficult, unless
you add views to simulate the desired tables. 19

20. <class name=quot;Frogquot;>
<id name=quot;Idquot;>
<generator class=quot;nativequot; />
</id>
<property name=quot;Namequot; />
<property name=quot;TongueLengthquot; />
</class>
<class name=quot;Dogquot;>
<id name=quot;Idquot;>
<generator class=quot;nativequot; />
</id>
<property name=quot;Namequot; />
<property name=quot;Breedquot; />
</class>
20

21. Pros
Easy to do ad-hoc reporting as all the data you need
about a single class is stored in only one table
Good performance to access a single object’s data.
Cons
When you modify a class you need to modify its table
and the table of any of its subclasses.
21

22. 22

23. 23

24. Object oriented querying
Increase compile-time syntax-checking
Easy to write
Hard to read
ICriteria crit = sess.CreateCriteria(typeof(Cat));
crit.SetMaxResults(50);
List topCats = crit.List();
IList cats = sess.CreateCriteria(typeof(Cat))
.Add( Restrictions.Like(quot;Namequot;, quot;Fritz%quot;))
.Add( Restrictions.Between(quot;Weightquot;, minWeight,
maxWeight))
.List();
24

25. String based querying
Object-Oriented SQL
Similar to SQL
Speak in terms of objects
Case sensitive
Very flexible
Zero compile-time syntax-checking
• from Customer c where c.Name like :name
• select count(*) from Customer c
25

26. Powerful way to (simply) return a group of like objects
from the DB.
Wonderfully simple to work with
Great way to quickly process a “…where
A=<something> and B=<something> and
C=<something>…”
Cat cat = new Cat();
cat.Sex = 'F';
cat.Color = Color.Black;
List results = session.CreateCriteria(typeof(Cat))
.Add( Example.Create(cat) )
.List();
26

27. You can submit SQL statements to NHibernate if the
other methods of querying a database do not fit your
needs
utilize database specific features
• sess.CreateSQLQuery(quot;SELECT * FROM CATSquot;)
.AddScalar(quot;IDquot;, NHibernateUtil.Int32)
.AddScalar(quot;NAMEquot;, NHibernateUtil.String)
.AddScalar(quot;BIRTHDATEquot;, NHibernateUtil.Date);
• sess.CreateSQLQuery(quot;SELECT * FROM CATSquot;)
.AddEntity(typeof(Cat));
27

28. 28

29. 29

30. Nhibernate.Contrib
Mapping.Attributes
Cache
Search
Validator
Burrow
LINQ to NHibernate
Shards
Fluent Interface to NHibernate
30

31. http://en.wikipedia.org/wiki/Object-relational_mapping
NHibernate in Action
NHibernate Reference Documentation 1.2.0
http://code.google.com/p/sharp-architecture/
http://www.codeproject.com/KB/database/Nhibernate_M
ade_Simple.aspx
http://www.codeproject.com/KB/architecture/NHibernate
BestPractices.aspx
www.hibernate.org
NHibernate FAQ
Summer of NHibernate
31