Object relational mapping (ORM) tools like Hibernate map objects to relational databases to reduce code and improve productivity. While ORMs can simplify development, they may impact performance or control. NoSQL databases offer alternative data models like key-value, document, and graph structures suited for certain applications.

1. HÖNNUN OG SMÍÐI HUGBÚNAÐAR 2015
L18 Object Relational Mapping

2. Reading
▪ Hibernate (Wikipedia)
▪ ORMHate
▪ Introduction to NoSQL

3. Agenda
▪ Object Relational Mapping – ORM
▪ NoSQL
▪ Hibernate

4. Object Relational Mapping – ORM

5. Object Relational Mapping (ORM)
▪ Use a mapping layer to map between objects and tables
– Mapping a data representation from an object model to a
relational data model with a SQL-based schema
▪ Mapping requires
metadata
– XML
▪ Authoring and
maintaining
metadata is less work than maintaining SQL

6. Advantages of ORM
▪ Can radically reduce the amount of code you need to write
– 30% compared to JDBC for server side application
▪ More Productivity
▪ Applications are easier to maintain
▪ Fosters thinking about an OO domain model

7. Disadvantages of ORM
▪ Some loss of control over the persistence process
▪ May be more difficult to tune queries
▪ Performance characteristics of the tool may affect your application’s
performance

8. When to use ORM?
▪ Well-suited to ORM
– Read-modify-write lifecycle
– Little requirement for stored procedures
▪ Poorly suited to ORM
– “Window on data” application
– Significant use of stored procedures
– Write centric apps, where data is seldom read

9. When to use ORM?
▪ Typical server-side applications are fairly well suited for ORM
– 90%-95% of applications
– But there are always some special cases
– Mix and match as needed

10. Hibernate

11. Hibernate
▪ Object/relational mapping tool
– A persistence service that stores Java objects in relational
databases
– Provides an object oriented view of existing relational data
▪ Uses reflection and XML mapping files to persist POJOs
– No changes to business domain objects
– The goal is to relieve the developer from a significant amount of
common data persistence-related programming tasks

12. Architecture
▪ High-level architecture
Properties
file define
data access
Mapping
definition
maps classes
to tables

13. Architecture

14. Database Properties
▪ File
– hibernate.properties
▪ Contains information to access the database
– Username and password
– URL
– Database driver
▪ Hibernate will automatically read the file from the classpath
hibernate.connection.username=andri
hibernate.connection.password=abc123
hibernate.connection.url=jdbc:jtds:sqlserver://honn.ru.is:1433
hibernate.connection.driver_class=net.sourceforge.jtds.jdbc.Driver

15. Mapping File
▪ File
– hibernate-mapping
– In the same package as Nemandi class
<hibernate-mapping>
<class name="org.ru.honn.domain.Nemandi" table="NEMENDUR">
<id name="kennitala" column="kennitala" type="string">
</id>
<property name="nafn" column="nafn" type="string"
length="64" not-null="false"/>
<property name="netfang" column="netfang" type="string"
length="64" not-null="false"/>
<property name="hopur" column="hopur" type="string"
length="32" not-null="false" />
</class>
</hibernate-mapping>

16. Using Hibernate
▪ Usually an application will
– Create a single Configuration
– Build a single instance of SessionFactory
– Then instantiate Session objects
Configuration cfg = new Configuration();
cfg.addClass(theClass);
SessionFactory factory = cfg.buildSessionFactory();
Session session = factory.openSession();

17. Using Hibernate
▪ Configuration
– Allows the application to specify properties and mapping
documents to be used when creating a SessionFactor
▪ SessionFactory
– Factory class to create Session objects
▪ Session
– Interface that represents a transaction
– The main function is to offer create, read and delete operations for
instances of mapped entity classes

18. Example
▪ NemandiGateway
public interface NemandiGateway
{
public Nemandi findNemandi(String kennitala);
public Collection getNemendur();
public void addNemandi(Nemandi nemandi);
}

19. Example
▪ NemandiData
– Constructor creates the configuration and the factory
– Variable factory is used when a Session is needed
public class NemandiData implements NemandiGateway
{
SessionFactory factory = null;
public NemandiData()
{
Configuration cfg = new Configuration();
cfg.addClass(Nemandi.class);
factory = cfg.buildSessionFactory();
}

20. Example
▪ NemandiData
– findNemandi
public Nemandi findNemandi(String kennitala)
{
Session session = factory.openSession();
Nemandi nem = (Nemandi)session.get(Nemandi.class, kennitala);
session.close();
return nem;
}

21. Example
▪ NemandiData
– getNemendur
– Uses the Hibernate Query Language, HQL
public Collection getNemendur()
{
Session session = factory.openSession();
List l = session.createQuery(
"SELECT n FROM is.ru.honn.domain.Nemandi AS n").list();
session.close();
return l;
}

22. Example
▪ NemandiData
– addNemandi
public void addNemandi(Nemandi nemandi)
{
Session session = factory.openSession();
Transaction tx = session.beginTransaction();
session.save(nemandi);
tx.commit();
session.close();
}

23. NoSQL Databases

24. Matin Fowler on NoSQL

26. Data Model

27. Key-Value
▪ Basically Map<String, Object>
▪ They are also referred to as "schema on read" as one entry may be a
String, another a Date, a third PNG image
▪ Key-Value stores offer no indexes, and no querying capabilities
▪ Examples:
– Property files, Dynamo, Riak, Redis, Aerospike, Voldemort

28. Document Store
▪ Mesh of documents
– Documents can have any structure – “no schema” or implicit
schema
– Json is popular
▪ Examples
– MongoDB, MarkLogic, CouchDB, RavenDB,

29. Tablestyle Database
▪ The value stored is sort of a transposed table in it self
– Sort of like Map<String, Map<String, Object>>
– Such structures are extremely useful to store sparse data in
▪ Examples:
– Cassandra, Hadoop/HBase, Apache Fink, Monet

30. Graph Databases
▪ Graph or network structure of data: Entities and facts about these in
the relations on them
– Graph Databases resembles Prolog in their use to infer new insights
based upon facts and rules
▪ Really good at relation magic, e.g. if you have a "friends" relation on
"user" entities
▪ Examples:
– Neo4J, GraphBase, Trinity

31. Summary
▪ Object Relational Mapping – ORM
– Useful tools that work in most cases
– Still controversial
▪ Hibernate
– An example of a mapping tool
– One of the possible options
▪ NoSQL
– New bread of 21. century web databases