Design your application using Persistent Graphs and OrientDB

Design your application using Persistent
Graphs and OrientDB
Luca Garulli – Founder and CEO
NuvolaBase Ltd

May 2012 29 - 30 in Cologne, Germany
(c) Luca Garulli Licensed under a Creative Commons Attribution-NoDerivs 3.0 Unported License Page 1
www.orientechnologies.com

Usually NoSQL products are selected
because are fast and super scalable,
but at what price?


Can you really renounce to
Transactions, an expressive Query
language and all the features
available for years by RDBMS?


Can we have a fast and scalable NoSQL
product with flexible schema,
transactions, SQL, security and the
support for complex types ?


The answer is OrientDB,
the document-graph NoSQL dbms


The answer is OrientDB,
the document-graph NoSQL dbms
I never will
change my
RDBMS with
anything!


Mission?
Reduce to the minimum the compromises
on fitting the application domain to a
persistent database supporting
multiple models


OrientDB = {
flexibility of Document databases
+ complexity of the Graph model
+ Object Oriented concepts
+ fast Index
+ powerful SQL dialect }

+13 years
of research


+3 years
of design and development


Relationships
are direct links
no Relational JOINS to connect multiple tables
Load trees and graphs in few ms!


Ø config download, unzip, run!
cut & paste the db

150,000 records per second
(flat records, no index, on commodity hw)


Schema-less
schema is not mandatory, relaxed model,
collect heterogeneous documents all together


Schema-full
schema with constraints on fields and validation rules

Customer.age > 17
Customer.address not null
Customer.surname is mandatory
Customer.email matches 'b[A-Z0-9._%+-]+@[A-Z0-9.-]+.[A-Z]{2,4}b'


Schema-mixed
schema with mandatory and optional fields + constraints
the best of schema-less and schema-full modes


ACID Transactions
db.begin();
try{
// your code
...
db.commit();

} catch( Exception e ) {
db.rollback();
}


Complex types
native support for collections, maps (key/value)
and embedded documents
no more additional tables to handle them


SQL
select * from employee where name like '%Jay%' and status=0


Why reinvent
yet another language when
the 100% of developers already
know SQL?

OrientDB begins from SQL
but improves it with new
operators for graph manipulation

For the most of the queries
everyday a programmer needs
SQL is simpler,
more readable and
compact then
Scripting (Map/Reduce)

SELECT SUM(price) as prices, SUM(cost) as costs, prices-costs, margin/price
FROM Balance

VS
function (key, values) {
var price = 0.0, cost = 0.0, margin = 0.0, marginPercent = 0.0;
for (var i = 0; i < values.length; i++) {
price += values[i].price;
cost += values[i].cost;
}
margin = price - cost;
marginPercent = margin / price;
return {
price: price,
cost: cost,
margin: margin,
marginPercent: marginPercent
};
} Luca Garulli
(c) Licensed under a Creative Commons Attribution-NoDerivs 3.0 Unported License Page 22

Asynchronous Query
invoke callback when a record matches the condition
doesn't collect the result set
perfect for immediate results
useful to compute aggregates


Enhanced SQL
SQL is not enough for collections, maps, trees and graphs
need to enhance SQL syntax
Easy syntax derived from JDO/JPA standards


SQL & relationships
select from Account where address.city.country.name = 'Italy'

select from Account where addresses contains (city.country.name = 'Italy')


SQL & trees/graphs
select out[label='friend'].in from V where name = 'Luca' and surname = 'Garulli'

select out[@class='knows'].in from V where name = 'Jay' and surname = 'Miner'

traverse friends from Profile where $depth < 7


SQL sub queries
select from (
traverse friends from Profile where $depth < 7
) where home.city.name = ‘Cologne’


SQL & strings
select from Profile where name.toUpperCase() = 'LUCA'

select from City where country.name.substring(1,3).toUpperCase() = 'TAL'

select from Agenda where phones contains ( number.indexOf( '+39' ) > -1 )

select from Agenda where email matches 'bA-Z0-9._%+-?+@A-Z0-9.-?+.A-Z?{2,4}b'


SQL & schema-less
select from Profile where any() like '%Jay%'

select from Stock where all() is not null


SQL & collections
select from Tree where children contains ( married = true )

select from Tree where children containsAll ( married = true )

select from User where roles containsKey 'shutdown'

select from Graph where edges.size() > 0


runs
Java
everywhere is available JRE1.5+
®
robust engine

Language bindings
Java as native

JRuby, PHP, C, Scala, .NET,
Ruby, Clojure, Node.js,
Python and Javascript


Is your language
not supported (yet)?
Write an adapter using the
C, Java or HTTP binding

Binary protocol
Fast compressed JSON over tcp/ip
available for Java
and soon C, C++ and Ruby

HTTP RESTful
firewall friendly
use it from the web browser
use it from the ESB (SOA)

Native JSON
ODocument = new ODocument().fromJSON( "
{
'@rid' = '26:10',
'@class' = 'Developer',
'name' : 'Luca',
'surname' : 'Garulli',
'out' : [ #10:33, #10:232 ]
}“ );


Import/Export
uses JSON format
online operations (don't stop the database)

> export database demo


MVRB-Tree index

the best of B+Tree and RB-Tree
fast on browsing, low insertion cost
it's a new algorithm


Hooks
similar to triggers
catch events against records, database and transactions
implement custom cascade deletion algorithm
enforce constraints

Security
users and roles, encrypted passwords
fine grain privileges
(similar to what RDBMS offer)

Cache
You can avoid using 3°party caches
like Memcached

2 Level caches:
Level1: Database level, 1 per thread
Level2: Storage level, 1 per JVM

Inheritance
OGraphVertex (V) OGraphEdge (E)

Person Vehicle Works Resides Knows
Address : Address brand : BRANDS since : Date
since : Date till : Date Level : LEVELS

Customer Provider
totSold : float totBuyed : float


Polymorphic SQL Query
OgraphVertex (V)

Person Vehicle
Address : Address brand : BRANDS
select from Person
where city.name = 'Rome‘

Queries are polymorphics
Customer Provider and subclasses of Person can be
totSold : float totBuyed : float part of result set


Fetch plans
Choose what to fetch on query and vertexes/edges loading
Vertexes/Edges not fetched will be lazy-loaded on request
Optimizes network latency


Fetch plans
Load only the root vertex
Vertex = *:1
Luca
|
| lives city
+---------> Vertex ------------> Vertex
| 10th street Italy
| knows
+--------->* [Vertex Vertex Vertex ]
[ Marko John Nicholas]


Fetch plans
Load root + address
Vertex = *:1 lives:2
Luca
|
| lives city
+---------> Vertex ------------> Vertex
| 10th street Italy
| knows


Fetch plans
Load root + all known
Vertex = *:1 knows:1
Luca
|
| lives city
+---------> Vertex ------------> Vertex
| 10th street Italy
| knows


Fetch plans
Load up 3rd level of depth
Vertex = *:3
Luca
|
| lives city
+---------> Vertex ------------> Vertex
| 10th street Italy
| knows


Graph Database model
Built as wrapper on top of
The Document Database
Few simple concepts: Vertex, Edge,
Property and Index

Why OrientDB is so special on
handling Graphs?

Can I model a graph
on top of a RDBMS?

A GraphDB has an
“index-free adjacency”
mechanism to cross
the graph without any
index lookup

OrientDB doesn’t use JOIN
but the “link” to traverse
millions of elements per second
In Blueprints benchmark, with a hot cache,
traverses 29,6M of records in less than 5 seconds
= 5,92M of nodes traversed per sec!


2 different API
OGraphDatabase
Native, damn fast, not the most beautiful API All APIs
are compatible
among them!
So use the right one
for the right case

OrientGraph
TinkerPop Blueprints, slowest but:
common to other impls, Gremlin, SPARQL (via Sail)


What to choose?
OGraphDatabase
Native, damn fast, not the most beautiful API

OGraphDatabase if you need
performance at any cost.
Use it for massive insertion or
low resources

What to choose?
OrientGraph
TinkerPop Blueprints, slowest but:
common to other impls, Gremlin, SPARQL (Sail)

OrientGraph if you want to stay
Portable
at the cost of less speed and more memory used

or to use Gremlin language,
or as RDF store + SPARQL

TinkerPop technologies
sort of “standard” for GraphDB
a lot of free open-source projects

http://tinkerpop.com


TinkerPop Blueprints
basic API to interact with GraphDB
implements transactional and
indexable property graph model
bidirectional edges


GraphDB & Blueprints API

OrientGraph graph = new OrientGraph("local:/tmp/db/graph”);

Vertex actor = graph.addVertex(null);
actor.setProperty("name", "Leonardo");
actor.setProperty("surname", "Di Caprio");

Vertex movie = graph.addVertex(null);
movie.setProperty("name", "Inception");

Edge edge = graph.addEdge(null, actor, movie, "StarredIn");

graph.shutdown();


TinkerPop
scripting language
easy to learn and understand
Used for operations against graphs


graph-example-1.xml

www.orientechnologies.com

Load graph
Run the console, open the database and load a graph in xml format

marko:~/software/gremlin$ ./gremlin.sh

,,,/
(o o)
-----oOOo-(_)-oOOo-----

gremlin> $_g := orientdb:open('/tmp/graph/test')
==>orientgraph[/tmp/graph/test]

gremlin> g:load('data/graph-example-1.xml')
==>true

gremlin> $_g
==>orientgraph[/tmp/graph/test]

Search
Displays outgoing edges of vertices with name equals to 'marko',
then the name of inbound vertices

gremlin> g:key-v('name','marko')/outE
==>e[6:0][5:2-knows->5:1]
==>e[6:1][5:2-knows->5:4]
==>e[6:4][5:2-created->5:0]

gremlin> g:key-v('name','marko')/outE/inV/@name
==>vadas
==>josh
==>lop

gremlin> g:close()
==>true


High-Availability
Multi-Master replication

Servers can be heterogeneous with
different replicated databases


Where is the previous
OrientDB
Master/Slave
architecture?

Mas
only ter/sla
recy . Do no ve
cle! t


After first tests we decided to
throw away the old Master-Slave
architecture because it was
against the OrientDB philosophy:

(1) It didn't scale
and
(2) It was hard to configure


Console
ORIENT database v.0.9.23 www.orientechnologies.com
Type 'help' to display all the commands supported.

> connect remote:localhost/demo admin admin
Connecting to database [remote:localhost/demo] with user 'admin'...OK

> select from profile where nick.startsWith('L')
---+--------+--------------------+--------------------+--------------------+
#| REC ID |NICK |SEX |AGE |
---+--------+--------------------+--------------------+--------------------+
0| 10:0|Lvca |male |34
1| 10:3|Leo |male |22
2| 10:7|Luisa |female |27
3 item(s) found. Query executed in 0.013 sec(s).

> close
Disconnecting from the database [demo]...OK

> quit


OrientDB Studio/View graph


Multi-Model
use case

Always Free
Open Source Apache 2 license
free for any purposes,
even commercials


Do y o
Conta u want to
ct info be a
@nuv partn
olaba er?
se.co

Prof€$$ional
m

$€rvic€$
directly by NuvolaBase Ltd or partners
support, training, consulting, mentoring


OrientDB OrientDB
for Java developers Master Development
8 hours 14 hours

OrientDB OrientDB
for SOA and the power of graphs
6 hours 6 hours

OrientDB OrientPlanet
for DBA for Web Developers
6 hours 6 hours


Certification Program
to be part of the network
do courses
share revenues for support
work as consultant
info@ Contact
nuvo
labas
e.co m


“OrientDB in Action”
book
by Manning Publications
is coming: January 2013


NuvolaBase.com
The first
Graph Database
on the Cloud
always available
few seconds to setup it
use it from app & mobile

Luca Garulli
Author of CEO at

Document-Graph NoSQL
Open Source project
Ltd, London UK

www.twitter.com/lgarulli

Design your application using Persistent Graphs and OrientDB

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Design your application using Persistent Graphs and OrientDB

Similar to Design your application using Persistent Graphs and OrientDB (20)

More from Luca Garulli

More from Luca Garulli (11)

Recently uploaded

Recently uploaded (20)

Design your application using Persistent Graphs and OrientDB