Jump to: navigation, search

Difference between revisions of "EclipseLink/Examples/JPA/NoSQL"

(Step 2 : Map the data)
(Step 2 : Map the data)
Line 63: Line 63:
 
The @NoSQL annotation is used to map NoSQL data.  This tags the classes as mapping to NoSQL data instead of traditional relational data.  It is required in each persistence class, both entities and embeddables.  The @NoSQL annotation allows the dataType and the dataFormat to be set.
 
The @NoSQL annotation is used to map NoSQL data.  This tags the classes as mapping to NoSQL data instead of traditional relational data.  It is required in each persistence class, both entities and embeddables.  The @NoSQL annotation allows the dataType and the dataFormat to be set.
  
The dataType is the equivalent of the table in relational data, its meaning can differ depending on the NoSQL data-source being used.  With MongoDB the dataType refers to the collection used to store the data.  The dataType is defaulted to the entity name, which is the simple class name.
+
The dataType is the equivalent of the table in relational data, its meaning can differ depending on the NoSQL data-source being used.  With MongoDB the dataType refers to the collection used to store the data.  The dataType is defaulted to the entity name (as upper case), which is the simple class name.
  
 
The dataFormat depends on the type of data being stored.  Three formats are supported by EclipseLink, XML, Mapped, and Indexed.  XML is the default, but since MongoDB uses BSON, which is similar to a Map in structure, Mapped is used.  In summary, each class requires the @NoSql(dataFormat=DataFormatType.MAPPED) annotation.
 
The dataFormat depends on the type of data being stored.  Three formats are supported by EclipseLink, XML, Mapped, and Indexed.  XML is the default, but since MongoDB uses BSON, which is similar to a Map in structure, Mapped is used.  In summary, each class requires the @NoSql(dataFormat=DataFormatType.MAPPED) annotation.
 +
 +
===Step 3 : Define Ids===
 +
JPA requires that each Entity define an Id.  The Id can either be a natural id (application assign id) or a generated id (id is assign by EclipseLink).  MongoDB also requires an _id field in every document.  If no _id field is present, then Mongo will auto generate and assign the _id field using an OID (object identifier) which is similar to a UUID (universally unique identifier).
  
 
[[Category:EclipseLink/Example/JPA|NoSQL]]
 
[[Category:EclipseLink/Example/JPA|NoSQL]]

Revision as of 12:52, 26 March 2012

NoSQL

NoSQL is a classification of database systems that do not conform to the relational database or SQL standard. They have various roots, from distributed internet databases, to object databases, XML databases and even legacy databases. They have become recently popular because of their use in large scale distributed databases in Google, Amazon, and Facebook.

There are various NoSQL databases including:

  • Mongo DB
  • Oracle NoSQL
  • Cassandra
  • Google BigTable
  • Couch DB

As of EclipseLink 2.4, EclipseLink has added JPA support for NoSQL databases, initially with support for MongoDB and Oracle NoSQL.

EclipseLink's NoSQL support allow the JPA API and JPA annotations/xml to be used with NoSQL data. EclipseLink also supports several NoSQL specific annotations/xml including @NoSQL that defines a class to map NoSQL data.

EclipseLink's NoSQL support is based on previous EIS support offered since EclipseLink 1.0. EclipseLink's EIS support allowed persisting objects to legacy and non-relational databases. EclipseLink's EIS and NoSQL support uses the Java Connector Architecture (JCA) to access the data-source similar to how EclipseLink's relational support uses JDBC. EclipseLink's NoSQL support is expendable to other NoSQL databases, through the creation of an EclipseLink EISPlatform class and a JCA adapter.

Ordering Example

This example shows how to map and persist an Ordering system object model to a MongoDB NoSQL database.

The source for the example can be found here, or from the EclipseLink SVN repository.

The ordering system consists of four classes, Order, OrderLine, Address and Customer. The Order has a billing and shipping address, many order lines, and a customer.

Ordering object model

public class Order implements Serializable {
    private String id;
    private String description;
    private double totalCost = 0;
    private Address billingAddress;
    private Address shippingAddress;
    private List<OrderLine> orderLines = new ArrayList<OrderLine>();
    private Customer customer;
    ...
}
public class OrderLine implements Serializable {
    private int lineNumber;
    private String description;
    private double cost = 0;
    ...
}
public class Address implements Serializable {
    private String street;
    private String city;
    private String province;
    private String country;
    private String postalCode;
    ....
}
public class Customer implements Serializable {
    private String id;
    private String name;
    ...
}

Step 1 : Decide how to store the data

MongoDB stores data as BSON (binary JSON) documents. The first decision that must be made is how to store the objects. Normally each independent object would compose a single document, so a single document could contain Order, OrderLine and Address. Since customers can be shared amongst multiple orders, Customer would be its own document.

Step 2 : Map the data

The next step is to map the objects. Each root object in the document will be mapped as an @Entity in JPA. The objects that are stored by being embedded within their parent's document are mapped as @Embeddable. This is similar to how JPA maps relational data, but in NoSQL embedded data is much more common because of the hierarchical nature of the data format. In summary, Order and Customer are mapped as @Entity, OrderLine and Address are mapped as @Embeddable.

The @NoSQL annotation is used to map NoSQL data. This tags the classes as mapping to NoSQL data instead of traditional relational data. It is required in each persistence class, both entities and embeddables. The @NoSQL annotation allows the dataType and the dataFormat to be set.

The dataType is the equivalent of the table in relational data, its meaning can differ depending on the NoSQL data-source being used. With MongoDB the dataType refers to the collection used to store the data. The dataType is defaulted to the entity name (as upper case), which is the simple class name.

The dataFormat depends on the type of data being stored. Three formats are supported by EclipseLink, XML, Mapped, and Indexed. XML is the default, but since MongoDB uses BSON, which is similar to a Map in structure, Mapped is used. In summary, each class requires the @NoSql(dataFormat=DataFormatType.MAPPED) annotation.

Step 3 : Define Ids

JPA requires that each Entity define an Id. The Id can either be a natural id (application assign id) or a generated id (id is assign by EclipseLink). MongoDB also requires an _id field in every document. If no _id field is present, then Mongo will auto generate and assign the _id field using an OID (object identifier) which is similar to a UUID (universally unique identifier).