El documento describe DEX, un sistema de base de datos de grafos de alto rendimiento. DEX permite el almacenamiento y manejo eficiente de grandes grafos mediante un modelo basado en bitmaps y enlaces. El documento explica la arquitectura de DEX, su modelo lógico de grafos etiquetados y atributos, y sus principales operaciones como la creación y consulta de nodos, aristas y atributos. Finalmente, se incluye un ejemplo de cómo modelar una base de datos bibliográfica como un grafo en DEX.

1. DEX
Osvaldo Salinas-Martínez

2. Technical Seminar (April, 2011)

3. New solutions for new needs

4. DEX es un sistema [ administrador | manejador ] de base de
datos de grafos de alto [ desempeño | rendimiento ] que permite
un eficiente almacenamiento y manejo de grafos de gran tamaño.
Que además permite la integración de múltiples fuentes de
datos.
DAMA Group Web Site: www.dama.upc.edu
Sparsity Web Site: www.sparsity-technologies.com
4

5. Escenarios de aplicación:
 Redes sociales:
Twitter, Facebook, Linkedin, Flickr, Delicious, MySpace.
 Información:
DBLP, IMDB.
 Seguridad y detección de fraudes:
Transacciones económicas.
 Recomendaciones:
Ecommerce, Retailer coupon analysis.
 Redes físicas:
Logística, Transporte, redes de telecomunicación.
 Redes biológicas:
interacción de las proteínas.

6. DEX esta basado en un modelo de base de datos de grafo, el cual
tiene tres características básicas y que DEX cumple completamente:
● La representación de los datos y esquema son como un grafo.
● Las operaciones sobre los datos son basadas en grafos; los
resultados de las consultas se encuentran en forma de grafos.
● Integridad en las relaciones basadas en grafos.

7. Modelo lógico
Etiquetado: Los nodos y arcos son identificados mediante etiquetas.
Dirigido: Los orcos pueden tener una dirección fija.
Atributos: Los nodos y arcos pueden tener múltiples atributos.
Multigrafo: Dos nodos pueden estar conectados por múltiples arcos.

8. Representación interna
Map + Bitmaps → Link
Link: Es una asociación bidireccional entre valores y OIDs,
cuenta con dos funcionalidades:
● Dado un valor ──► una serie de OIDs (Bitmaps).
● Dado un OID ──► el valor.

9. Un grafo es una combinación de Bitmaps:
● 1 Bitmap para cada nodo o arco.
● 1 Link para cada atributo.
● 2 Links para cada arco de tipo bidireccional.

10. Arquitectura
DEX core:
● C++
● Administración de datos.
● Resolución de consultas.
DEX API:
Es una interfaz de Java
para compatibilidad con
el DEX core.

11. DEX core
DEX core
● I/O:
● Segment: Logical space of pages
● Pool: Groups of segments
● Storage: I/O device
● Cache: I/O management
• Replacement policy
Data:
● Bitmaps, Maps, Links
Grapth:
● A combination of structures.
● DbGraph and Rgraphs.
DEX:
● Database and Session management

12. Desktop Web application
application
Browser
Presentation
HTML + Javascript
Java Swing
Application INTERNET
Network
Load Servlet
and Query Query
Application Logic
API
API DE
DE X
X
DEX DEX
Data
Data Data
Sources Sources Graphs
Graphs

13. DEX, SESSION y GraphPool
Una instancia de DEX es un sistema de gestión de base de datos de grafos que
maneja una o más bases de datos de grafos. Cada base de datos de grafos es
manejada por una instancia de la clase GraphPool, la cual es responsable del
manejo de memoria, I/O y la administración de la base de datos de grafos.
La base de datos de grafos persistente está almacenada en un archivo DEX. Durante
la actividad regular de una instancia de DEX los datos generados, como Rgraph,
Gaphs y DbGraph están almacenados en diferentes archivos temporales los cuales
son eliminados cuando el objeto GraphPool es cerrado.
Así una instancia de GraphPool vacía puede ser creada o cargada de archivo DEX
persistente, de esta manera toda las actividades de la base de datos de grafos
pueden ser realizadas con sesiones del usuario, las cuales son creadas con el
método GraphPool.newSession(). Una Sesión almacena y maneja todos los datos
temporales, los cuales son exclusivos para esa sesión.
13

14. Core API – Diagrama de clases
Graph factory Persistent DB
DEX 1 GraphPool N Session 1 1 DbGraph
N 1
1 Graph
1
N RGraph
N
Objects
Set of OIDs
Temporary

16. Core API – métodos principales
GraphPool
DEX
newSession()  Session
open(filename)  GraphPool
create(filename)  GraphPool Session
close()
getDbGraph()  DbGraph
newGraph()  Rgraph
Objects close()
Graph
add(long)
exists(long) newNodeType(name)  int
newEdgeType(name)  int
copy(objs)
newNode(type)  long
union(objs)
newEdge(type)  long
Intersection(objs)
newAttribute(type, name) 
difference(objs)
long
setAttribute(oid, attr, value)
getAttribute(oid, attr)  value
Objects.Iterator
select(type)  Objects
hasNext()  boolean select(attr, op, value)  Objects
next()  long explode(oid, type)  Objects

17. Instalación
Requerimientos:

Java 5.0 o superior (se recomienda la JVM de Sun Microsystems).

Sistema operativo: [Windows | Linux] [32 | 64] bits.
Para instalar DEX, solo hay que añadir el archivo jdex.jar al classpath de
Java.

$JAVA_HOME/bin/java -cp ./dex/jdex.jar myprog
17

18. Operaciones básicas
Instanciación de grafos:

DEX.create(java.io.File img, java.lang.String alias) – Crea una
nueva base de datos vacía persistente. Crea un GraphPool.

DEX.open(java.io.File img) - Abre un GraphPool existente.

GraphPool.newSession( ) - Crea una nueva sesión.

Session.getDbGraph( ) - Obtiene el objeto DbGraph.

Session.newGraph( ) - Crea un Graph temporal.
Manipulación del esquema del grafo:
Graph.newNodeType(String) – Crea un tipo de nodo
Graph.newEdgeType(String,boolean) – Crea un tipo de arco
18

19. Operaciones básicas
Manipulación de datos:
Graph.newNode(int) – Crea una instancia del tipo de nodo dado
Graph.newEdge(long, long, int) – Crea una instancia de un arco entre
dos nodos de un tipo de arco dado.
Graph.getAttribute(long, long, Value) – Obtiene el valor de un nodo o
arco dado y el valor de un atributo dado.
Graph.setAttribute(long, long, Value) – Asigna o reemplaza el valor
deun nodo dado o una instancia de un atributo dado
Graph.drop(long) – Elimina un nodo o arco dado con todos los valores
de sus atributos.
19

20. Operaciones básicas
Selección:
Graph.select(int) – Selecciona la colección de objetos de un tipo dado
Graph.select(long, short, Value) – Selecciona la colección de objetos
que satisfagan la condición para un atributo dado como valor.
20

21. Ejemplo:
Crear un DbGraph
DEX dex = new DEX();
GraphPool gp = dex.create("image.dex");
Session sess = gp.newSession( );
DbGraph graph = sess.getDbGraph( );
…
…
sess.close( );
gp.close( );
dex.close( );

22. Creando tipos de nodos:
Primero es necesario crear los tipos de nodos y sus atributos.
Después de esto hay que crear los objetos de los nodos y asignar sus valores
para sus atributos.
sess.beginTx();
DbGraph dbg = sess.getDbGraph();
int person = dbg.newNodeType("PERSON");
long name = dbg.newAttribute(person, "NAME", STRING);
long age= dbg.newAttribute(person, "AGE", INT);
long p1 = dbg.newNode(person);
dbg.setAttribute(p1, name, "JOHN");
dbg.setAttribute(p1, age, 18);
long p2 = dbg.newNode(person);
dbg.setAttribute(p2, name, "KELLY");
long p3 = dbg.newNode(person);
dbg.setAttribute(p3, name, "MARY");
sess.commitTx();

23. Creando tipos de arcos
Para crear un nuevo arco (dirigido o no dirigido) y asignarle atributos,
primero hay que crear un objeto tipo arco y posteriormente asignarle los
valores a sus atributos
...
sess.beginTx();
DbGraph dbg = sess.getDbGraph();
int friend = dbg.newUndirectedEdgeType("FRIEND");
int since = dbg.newAttribute(friend, "SINCE", INT);
long e1 = dbg.newEdge(p1, p2, friend);
dbg.setAttribute(e1, since, 2000);
long e2 = dbg.newEdge(p2, p3, friend);
dbg.setAttribute(e2, since, 1995);
23

24. Seleccionando objetos
Para seleccionar todos los objetos de un tipo de nodo específico e
iterar sobre ellos:
sess.beginTx();
DbGraph dbg = sess.getDbGraph();
Objects persons = dbg.select(person);
Objects.Iterator it = persons.iterator();
while (it.hasNext()) {
long p = it.next();
String name = dbg.getAttribute(p, name);
}
it.close();
persons.close();
sess.commitTx();
24

25. Ejemplo
DBLP ejemplo
DBLP Computer Science Bibliography
840MB
1.6 millones de publicaciones
25

26. Definiciones
public class Dex {
public final int no_nodos = 12;
public final String PAPER = "PAPER";
public final String PID = "PID";
public final String TITLE ="TITLE";
public final String AUTHOR ="AUTHOR";
public final String AID = "AID";
public final String NAME ="NAME";
//Declaracion para el nodo de papers
public int paper;
public long pid;
public long title;
//Declaracion para el nodo de autores
public int author;
public long aid;
public long name;
public DEX dex;
public GraphPool gp;
public Session sess;
public DbGraph graph;
public Value value;
26

27. Crear el grafo
public DEX dex;
public GraphPool gp;
public Session sess;
public DbGraph graph;
public Value value;
public Dex(){
try {
dex = new DEX();
value = new Value();
}
catch (Exception e)
{
System.out.println("Error al crear las estructura DEX");
e.printStackTrace();
}
}
27

28. Crear el grafo
public void crea_nuevo_grafo(){
try {
gp = dex.create("image.dex");
sess = gp.newSession();
graph = sess.getDbGraph();
}
catch (Exception e)
{
System.out.println("Error al crear la estructura del grafo");
e.printStackTrace();
}
}

29. Crear un nuevo grafo
public void procesa_grafo() throws Throwable{
crea_nuevo_grafo();
sess.beginTx();
crea_estructura_grafo();
inicializa_grafo();
sess.commitTx();
cierra_gafo();
}
public void cierra_gafo(){
try {
sess.close();
gp.close();
dex.close();
}
catch (Exception e)
{
System.out.println("Error al cerrar el grafo");
e.printStackTrace();
}
}
29

30. Crear la estructura del grafo
public void crea_estructura_grafo () {
paper = graph.newNodeType(PAPER);
pid = graph.newAttribute(paper,PID,Value.STRING);
title = graph.newAttribute(paper,TITLE,Value.STRING);
author = graph.newNodeType(AUTHOR);
aid = graph.newAttribute(author,AID,Value.STRING);
name = graph.newAttribute(author,NAME,Value.STRING);
}
30

31. Crear nuevo autor
public long nuevo_autor(String id, String nombre){
long node_id =graph.newNode(author);
value.setString(id);
graph.setAttribute(node_id,aid,value);
value.setString(nombre);
graph.setAttribute(node_id,name,value);
return node_id;
}
31

32. Crear nuevo artículo
public long nuevo_articulo (String id, String titulo){
long node_id = graph.newNode(paper);
value.setString(id);
graph.setAttribute(node_id,pid,value);
value.setString(titulo);
graph.setAttribute(node_id,title,value);
return node_id;
}
32

33. Inicializar el grafo con los datos
public void inicializa_grafo() {
long a1 = nuevo_autor("a1","shanmugasundaram");
long a2 = nuevo_autor("a2","guo");
long a3 = nuevo_autor("a3","hristidis");
long a4 = nuevo_autor("a4","papakonstantinou");
long a5 = nuevo_autor("a5","balmin");
long p1 = nuevo_articulo("p1","topology search over biological databases");
long p2 = nuevo_articulo("p2","xrank ranked keyword search over xml documents");
long p3 = nuevo_articulo("p3","bidirectional expansion for keyword search on graphs");
long p4 = nuevo_articulo("p4","finding topk answers in keyword proximity search");
long p5 = nuevo_articulo("p5","efficient irstyle keyword search over relational databases");
long p6 = nuevo_articulo("p6","keyword proximity search on xml graphs");
long p7 = nuevo_articulo("p7","discover keyword search in relational databases");
33

34. Crear los arcos
int paper_reference = graph.newUndirectedEdgeType("Paper-Reference");
long e1 = graph.newEdge(p1,p2,paper_reference);
long e2 = graph.newEdge(p2,p3,paper_reference);
long e3 = graph.newEdge(p3,p4,paper_reference);
long e4 = graph.newEdge(p4,p5,paper_reference);
long e5 = graph.newEdge(p5,p6,paper_reference);
int author_paper = graph.newUndirectedEdgeType("Author-Paper");
long e6 = graph.newEdge(a1,p1,author_paper);
long e7 = graph.newEdge(a1,p2,author_paper);
long e8 = graph.newEdge(a2,p1,author_paper);
long e9 = graph.newEdge(a3,p4,author_paper);
long e10= graph.newEdge(a3,p5,author_paper);
long e11= graph.newEdge(a4,p5,author_paper);
long e12= graph.newEdge(a4,p6,author_paper);
long e13= graph.newEdge(a4,p7,author_paper);
long e14= graph.newEdge(a5,p6,author_paper);
}
34

35. Consultar el grafo
public void consulta_grafo (String query) {
System.out.println("La consulta:" + query + " aparece en los nodos:");
Set set = graph.nodeTypes();
Iterator it =set.iterator();
Value value = new Value(query);
while(it.hasNext()) {
Integer tipo_nodo = (Integer)it.next();
set = graph.getAttributesFromType(tipo_nodo);
Iterator it2 = set.iterator();
while (it2.hasNext()){
Long tipo_atributo = (Long) it2.next();
Graph.AttributeData gad =graph.getAttributeData(tipo_atributo);
short tipo = gad.getDatatype();
if (tipo ==2) {
Objects obj = graph.select(tipo_atributo,graph.OPERATION_ILIKE,value);
Objects.Iterator iterator;
if (obj.size() >0 ) {
iterator = obj.iterator();
while(iterator.hasNext()){
long node_id = iterator.next();
imprime_nodo(node_id);
}
iterator.close();
}
obj.close();
}
}
}
System.out.println("-----------------------------------------");
}
35

36. Imprimir un nodo del grafo
public void imprime_nodo(long node_id) {
int tipo_nodo=graph.getType(node_id);
Set set = graph.getAttributesFromType(tipo_nodo);
Iterator it = set.iterator();
while (it.hasNext()){
Long tipo_atributo = (Long) it.next();
Graph.AttributeData atributo= graph.getAttributeData(tipo_atributo);
value=graph.getAttribute(node_id,tipo_atributo);
graph.getAttribute(node_id,tipo_atributo,value);
System.out.print (atributo.getName()+ ": " + value.getString()+” ＼ t");
}
System.out.println("");
}
36

37. Imprimir todo el grafo
public void imprime_grafo() {
System.out.println("El grafo contiene los datos:");
Set set = graph.nodeTypes();
Iterator it =set.iterator();
while(it.hasNext()) {
Integer tipo_nodo = (Integer)it.next();
Objects obj = graph.select(tipo_nodo);
Objects.Iterator iterator = obj.iterator();
while (iterator.hasNext()) {
long node_id = iterator.next();
System.out.print("Nodo "+ node_id + " - ");
imprime_nodo(node_id);
}
obj.close();
iterator.close();
}
}
37

38. Elegir todos los nodos de un tipo dado
public void elige_nodos (int tipo) {
Objects nodos = graph.select(tipo);
Objects.Iterator it = nodos.iterator();
while (it.hasNext()){
long nodo = it.next();
System.out.println(nodo);
}
}
38

39. Eliminar un nodo
public void elimina_nodo(long node_id){
try {
sess.beginTx();
graph.drop(node_id);
sess.commitTx();
}
catch (Exception e)
{
System.out.println("Error al eliminar el nodo " + node_id + " del grafo");
e.printStackTrace();
}
}
39

40. Eliminar un atributo
public void elimina_atributo(String nombre){
try {
sess.beginTx();
Set set = graph.nodeTypes();
Iterator it =set.iterator();
while(it.hasNext()) {
Integer tipo_nodo = (Integer)it.next();
set = graph.getAttributesFromType(tipo_nodo);
Iterator it2 = set.iterator();
while (it2.hasNext()){
Long tipo_atributo = (Long) it2.next();
Graph.AttributeData gad =graph.getAttributeData(tipo_atributo);
String nombre_att = gad.getName();
if (nombre_att.equalsIgnoreCase(nombre)) {
graph.removeAttribute(tipo_atributo);
return;
}
}
}
sess.commitTx();
}
catch (Exception e)
{
System.out.println("Error al eliminar el atributo con el nombre:" + nombre);
e.printStackTrace();
}
}
40

41. Encontrar la ruta mas corta entre 2 nodos
public ArrayList<Long> distancia(long origen, long destino) throws Throwable {
ArrayList<Long> nodos = new ArrayList<Long>();
SinglePairShortestPathBFS sp = new SinglePairShortestPathBFS(graph,origen,destino);
sp.addAllEdges(Algorithm.NAVIGATION_UNDIRECTED);
int dist = -1;
sp.setMaximumHops(no_nodos);
try {
sp.run();
}
catch (Exception e)
{
System.out.println("Error al encontrar la ruta mas corta entre el nodo " + origen + " y el nodo " + destino);
}
long[] spAsNodes;
if(sp.existsShortestPath()) {
spAsNodes = sp.getPathAsNodes();
dist = sp.getCost();
for (int i=0; i < dist; i++){
nodos.add(spAsNodes[i]);
}
}
sp.close();
return nodos;
}
41

42. Encontrar los vecinos de un nodo dado
public void obtiene_vecinos_nodo(long nodo){
Set set = graph.edgeTypes();
Iterator it =set.iterator();
while(it.hasNext()) {
Integer tipo_arco = (Integer)it.next();
Objects nodos = graph.neighbors(nodo,tipo_arco,Graph.EDGES_BOTH);
Objects.Iterator it2 = nodos.iterator();
while (it2.hasNext()){
long nodo_id = it2.next();
System.out.println(nodo_id);
}
}
}

44. Ejemplo completo
Mostraremos el funcionamiento completo del programa.
44

45. Comparación con MySQL
● Datasets:
● D1: Synthetic data, generated from R-MAT
– Scale factor = 16 (524K edges)
● D2: Synthetic data, generated from R-MAT
– Scale factor = 18 (2M edges)
● D1 and D2 both just nodes and edges, no attributes.
● R-MAT (Recursive MATrix) generates the graph by operating on its
adjacency matrix in a recursive manner.
● Queries:
● Q1: 3-hops from a given node.

46. Comparación con MySQL
● Test: Execute Q1
● These query nodes have a significant number of out-going edges.
– Scale factor 16: about some tens
– Scale factor 18: about some hundreds
● Results:
● Scale factor 16: reached about 160K nodes
● Scale factor 18: reached about 600K nodes

47. Comparación con MySQL
● Schema:
CREATE TABLE `edges` (
`src` int(11) NOT NULL,
`dst` int(11) NOT NULL,
INDEX `srcI` (`src`) USING BTREE,
INDEX `dstI` (`dst`) USING BTREE
) ENGINE=InnoDB;
● Query:
SELECT DISTINCT c.dst
FROM edges as a, edges as b, edges as c
WHERE (a.dst=b.src AND b.dst=c.src AND a.src=node);

48. Comparación con MySQL
● Platform test
● MacBook 2.4GHz Intel Core 2 Duo (Mac OS X 10.6)
● Up to 1GB memory for MySQL buffer pool.
● Results
Test T1 MySQL DEX
Dataset D1 1m 57s 9s
Dataset D2 13m 36s 34s

49. Comparación con Neo4j
Neo4j DEX4.0
Size (GB) 82 16.98
Load time (h) 8.22 2.25
Q1 (s) 32230.00 118.93
Q2 (s) 24832.00 205.97
Q3 (s) 2045.00 10.68
Q4 (s) 34882.00 146.77
Q5 (s) 32539.00 141.06
Q6 (s) > 1week 7518.06
Query 1: max-outdegree + SPT
Query 2: paper recommender (2-hops)
Query 3: pattern matching
Query 4: for each language: number of papers and images
Query 5: for each paper: materialize number of images
Query 6: delete papers with no images

50. Presentación basada en
DEX: High-Performance Exploration on Large Graphs for Information Retrieval.
Norbert Martínez-Bazan Victor Muntés-Mulero Sergio Gómez-Villamor
Jordi Nin Mario-A. Sánchez-Martínez Josep-L. Larriba-Pey

51. ¿Preguntas?