Brincando com bancos do tipo Grafos com Java

 

 

   Os bancos NoSQL estão cada vez mais populares e em diversos segmentos, dentre os seus tipos definidos está o banco do tipo grafos. O banco de grafos tem uma estrutura consideravelmente diferente se comparado aos bancos relacionais, dentre os maiores cases de uso estão as recomendações em sistemas de redes sociais, por exemplo, facebook e linkedin compras e entretenimento inclusive em setores mais conservadores como o financeiro que está o utilizando com objetivo de evitar fraudes bancárias. O objetivo desse artigo é explorar os conceitos dos grafos e como utilizar de maneira bastante simples com Java.

 

Estrutura do Banco do Grafo

O Banco de grafos é composto, basicamente por três elementos:

  • Property: É o menor elemento dentro do grafo, ele é uma tupla, ou seja, é composta por uma chave e valor em que a chave é o nome e o valor é a informação em si.
  • Vertex: Seria semelhante a uma tabela num banco relacional, ele é composto por uma ou mais propriedades.
  • Edge: é o elemento que representa a relação entre os Vertex, seria um elemento de relação comparado com um banco relacionado, porém, esse elemento também é composto por propriedades. O fato do Edge ter propriedades traz uma nova dimensão.

O sentido do grafo é algo muito importante, afinal, o fato de você conhecer uma pessoa não significa que ela te conheça. Assim, de uma maneira geral podemos pensar da seguinte forma:

  • Out: Vertex → action → Vertex o “out” é o sentido da ação, ou seja, eu conheço o homem de ferro, assim: Me → knows → Iron man.
  • In: Vertex ← passive verb ← o “in” é o sentido oposto, ou seja, da reação essa operação é “automaticamente” salva quando você realizar uma operação de ação, por exemplo, o homem de ferro é conhecido por me, assim: Iron man → is known → me.

Provedores de banco de dados

 

O banco de Grafos são compostos por diversos provedores, sendo o mais popular o Neo4J. Assim temos:

Certamente uns dos grandes problemas no grande número de servidores de grafos está no grande número de APIs, uma vez que cada banco tem a sua própria API, por exemplo, faz com que seja muito difícil aprender cada uma delas, sem falar no problema do lock-in, ou seja, caso você opte por um banco de dados caso faça a mudança você perderá toda a sua camada de persistência, sem falar na curva de aprendizado uma vez que para cada novo banco será necessário aprender uma nova API.

 

TinkerPop criando um padrão para os bancos de grafos

Com o objetivo de evitar os problemas mencionados anteriormente, nasceu o TinkerPop. O TinkerPop é um projeto da Apache Foundation que cria uma API comum para realizar as operações de bancos de dados além das Queries. Com o TinkerPop é muito simples realizar queries e sem se preocupar com o Vendor. Atualmente o TinkerPop suporta mais de 30 bancos de dados do tipo grafo.

 

Exemplos que demonstram a vantagem do Grafos em relação ao banco relacional

 

Imagine uma simples estrutura hierárquica, por exemplo, uma cadeia alimentar uma hierarquia empresarial. Como mostra a figura abaixo:

Com o intuito de realizar a comparação, como você percorreria essa cadeia num banco relacional?

Possivelmente, teria que ter uma nova tabela para fazer essa lógica ou coisa semelhante. Então com o TinkerPop você precisaria executar uma query como essa:

g.V().repeat(out("eats")).times(3);//para percorrer a lista três vezes 
g.V().repeat(out("eats")) .until(has("name", "grass"));//para percorrer até achar um Vertez com o nome “grass”.

Simples não?

 

Tá e as minhas entidades?

TinkerPop tem suporte ao Java, com a sua própria API, no entanto, no nosso dia a dia nós trabalhamos com entidades, por exemplo, livros, pessoas dentre outras coisas e para realizar tal comunicação é necessário fazer um parse para cada entidade.

JNoSQL

O JNoSQL é uma ferramenta cujo o objetivo é facilitar a comunicação entre os bancos não relacionais e suas entidades Java, para isso, ele consta com uma API simples, porém, extensível, assim mesmo com uma API padrão é possível extende-la para usar um recurso específico de um banco de dados. O JNoSQL conta com duas sub APIs uma para comunicação, semelhante ao JDBC, e uma para mapeamento, semelhante ao JPA.

JNoSQL e Grafos

 

Para realizar tal integração o JNoSQL utiliza sua camada de mapeamento, aka Artemis, e realiza um parser para o TinkerPop. Assim, para retratar esse grafo no mundo JNoSQL.

1) Realizar o mapeamento das classes Pessoa e livro

@Entity
public class Book {

 

@Id
private Long id;

@Column
private String name;

//getter and setter
}

@Entity
public class Person {

@Id
private Long id;

@Column
private String name;

@Column
private int age;

@Column
private String occupation;

@Column
private Double salary;

//getter and setter
}

 

Injetar a classe GraphTemplate

 

@Inject
private GraphTemplate graph;

//caso você esteja utilizando CDI 2.0 no SE
GraphTemplate graph = container.select(GraphTemplate.class).get();

 

Salvar as entidades

 

Person poliana = Person.builder().withName("Poliana").withAge(25).build();

Book shack = Book.builder().withAge(2007).withName("The Shack").build();

graphTemplate.insert(poliana);
graphTemplate.insert(shack);

 

Criar a relação [Edge]

EdgeEntity<Person, Book> reads = graphTemplate.edge(poliana, "reads", shack);
reads.add("where", "Brazil");

Pronto, você fez sua primeira operação com um grafo.

 

Um caso prático com Grafo {Fazendo queries].

 

Imagine o seguinte cenário:

1) Trabalhamos para uma agência de marketing e queremos fazer uma campanha para um público específico que será:

 

  • Um engenheiro
  • Cujo salário seja maior que 3000
  • Tenha idade entre 20 e 25 anos

Para esse caso, seria simples fazer essa query tanto no banco relacional como no grafo, focando em grafos com o JNoSQL ficará da seguinte forma:

List<Person> developers = graph.getTraversalVertex()
.has("salary", gte(3_000D))
.has("age", between(20, 25))
.has("occupation", "Developer")
.<Person>stream().collect(toList());

 

2) Os amigos desse engenheiro

 

Uma vez definido o nosso target, o nosso engenheiro com características específicas, queremos também trazer seus amigos, afinal, eu mesmo não atendendo os requisitos posso indicar o produto para um amigo que também tenha essas características.

Fazer esse tipo de operação no banco relacional começa a ficar mais difícil, porém, no nosso caso será necessário apenas colocar uma condição, out(“knows”), uma vez que queremos todas as condições e queremos alguém que o engenheiro conheça.

List<Person> result = graph.getTraversalVertex()
.has("salary", gte(3_000D))
.has("age", between(20, 25))
.has("occupation", "Developer")
.out("knows");
3) A pessoa que o engenheiro ama

 

Nesse caso, queremos maior “profundidade” na pessoa que o engenheiro conhece, conhecer não é suficiente, é necessário que ele ama essa pessoa. Imagine que estamos fazendo uma campanha para os dias dos namorados. Nesse caso, utilizaremos um diferente item da query, outE(“knows”), semelhante ao out, porém, ele começa a mapear a relação, o Edge, assim dentro dessa relação eu quero que ele busque uma propriedade, nesse caso, o sentimento de amor.

 

List<Person> love = graph.getTraversalVertex()
.has("salary", gte(3_000D))
.has("age", between(20, 25))
.has("occupation", "Developer")
.outE("knows")
.has("feel", "love")
.bothV()
.<Person>stream()
.distinct()
.collect(toList());

 

 

Os exemplos completos se encontram aqui:

https://github.com/JNOSQL/artemis-demo/tree/master/artemis-demo-java-se

Como essa versão ela ainda está em snapshot é necessário adicionar esse repositório para realizar tests, para mais informações:

https://stackoverflow.com/questions/7715321/how-to-download-snapshot-version-from-maven-snapshot-repository

Com isso, fizemos uma rápida introdução dos bancos do tipo Grafo com Java. Como foi possível demonstrar, mesmo que de maneira bem superficial, é possível realizar diversas buscas que no mundo relacional dariam muito trabalho e demandaria muito tempo de uma maneira bem mais natural.

 

Referências:
Anúncios

[JNoSQL] Começando com Diana API de Colunas

Umas das API que existem no Diana, camada de comunicação do JNoSQL, é a camada de família de colunas. O objetivo desse artigo é falar rapidamente sobre essa API para esse tipo de banco de dados.

No nosso caso será utilizado o Cassandra, assim:

<dependency>
  <groupId>org.jnosql.diana</groupId>
  <artifactId>cassandra-driver</artifactId>
  <version>0.0.1</version>
</dependency>

p.s: Atualmente é necessário adicionar o repositório do JNoSQL para ter acesso as suas dependências:

<repositories>
  <repository>
    <id>jnsoql-repo</id>
    <name>JNoSQL Maven Repository</name>
    <url>https://dl.bintray.com/jnosql/maven/</url>
    <layout>default</layout>
  </repository>
</repositories>


As classes da API de documento seguem a seguinte estrutura:

  • ColumnConfiguration: Classe responsável pela configuração e conexão com o banco de dados, uma vez esse setup varia fortemente em cada banco de dados. Ela costuma ter formato variável
  • ColumnManagerFactory: classe responsável pela criação de uma interface Manager
  • ColumnManager: assim como no JPA, essa classe é a responsável pelo gerenciamento da entidade.
  • ColumnEntity: uma entidade de uma família de colunas
  • Column: Um ColumnEntity é composto por diversas colunas, ele é composto por uma tupla em que a chave é o nome e o valor é a informação propriamente dita. Essa informação poderá ser qualquer valor, variando de cada driver, inclusive uma coluna ou subcoluna.

 

Com o driver do Cassandra é possível realizar o CRUD de maneira simples:

public class App {

    public static final String KEY_SPACE = "newKeySpace";
    public static final String COLUMN_FAMILY = "newColumnFamily";

    public static void main(String[] args) {

        ColumnConfiguration condition = new CassandraConfiguration();

        try(ColumnFamilyManagerFactory managerFactory = condition.get()) {
            ColumnFamilyManager columnEntityManager = managerFactory.get(KEY_SPACE);
            ColumnEntity entity = ColumnEntity.of(COLUMN_FAMILY);
            Column id = Column.of("id", 10L);
            entity.add(id);
            entity.add(Column.of("version", 0.001));
            entity.add(Column.of("name", "Diana"));
            entity.add(Column.of("options", Arrays.asList(1, 2, 3)));

            columnEntityManager.save(entity);

            ColumnQuery query = ColumnQuery.of(COLUMN_FAMILY);
            query.and(ColumnCondition.eq(id));
            Optional<ColumnEntity> result = columnEntityManager.singleResult(query);
            System.out.println(result);

        }


    }
}

Vale salientar que é necessário existir um banco Cassandra instalado e rodando. Com o Cassandra é necessário também informar o IP para que o Diana consiga se conectar. Para isso, é necessário o arquivo diana-cassandra.properties no classpath, além do IP é possível configurar a estrutura inicial utilizando o CQL, Cassandra query language. Assim, ele terá as informações dos bancos que serão conectados. No nosso, exemplo:

cassandra-hoster-1=172.17.0.2
cassandra-threads-number=4
cassandra-initial-query-1=CREATE KEYSPACE IF NOT EXISTS newKeySpace WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};
cassandra-initial-query-2=DROP TABLE IF EXISTS newKeySpace.newColumnFamily;
cassandra-initial-query-3=CREATE COLUMNFAMILY IF NOT

Tip: uma maneira simples de instalar o Cassandra é utilizando o docker:
https://hub.docker.com/_/cassandra/

Especializações

O Cassandra possui recurso que irão além da simples API, recursos como nível de consistência e também o CQL.

public class CassandraApp {


    public static final String KEY_SPACE = "newKeySpace";
    public static final String COLUMN_FAMILY = "newColumnFamily";

    public static void main(String[] args) {

        CassandraConfiguration condition = new CassandraConfiguration();

        try(CassandraDocumentEntityManagerFactory managerFactory = condition.get()) {
            CassandraColumnFamilyManager columnEntityManager = managerFactory.get(KEY_SPACE);
            ColumnEntity entity = ColumnEntity.of(COLUMN_FAMILY);
            Column id = Column.of("id", 10L);
            entity.add(id);
            entity.add(Column.of("version", 0.001));
            entity.add(Column.of("name", "Diana"));
            entity.add(Column.of("options", Arrays.asList(1, 2, 3)));

            columnEntityManager.save(entity);

            //common implementation
            ColumnQuery query = ColumnQuery.of(COLUMN_FAMILY);
            query.and(ColumnCondition.eq(id));
            List&ltColumnEntity&gt columnEntities = columnEntityManager.find(query, ConsistencyLevel.LOCAL_QUORUM);

            //cassandra implementation
            columnEntityManager.save(entity, ConsistencyLevel.THREE);
            List&ltColumnEntity&gt entities = columnEntityManager.cql("select * from newKeySpace.newColumnFamily");
            CassandraPrepareStatment cassandraPrepareStatment = columnEntityManager.nativeQueryPrepare("select * from newKeySpace.newColumnFamily where id ?");
            List&ltColumnEntity&gt entityList = cassandraPrepareStatment.bind(10L).executeQuery();
            System.out.println(entities);

        }


    }

}

Com isso concluímos o artigo falando da camada de comunicação do projeto JNoSQL para colunas.

Referências:

[JNoSQL] Começando com Diana API de Documentos

Os bancos documentos, é um dos tipos de bancos não relacionais que armazena e recupera a informação numa estrutura de documentos, semelhante a um documento XML, esse tipo de banco é uma especialização de um banco chave valor.  Umas das API que existem no Diana, camada de comunicação do JNoSQL, é a camada de Documentos. O objetivo desse artigo é falar rapidamente sobre essa API para esse tipo de banco de dados.

 

No nosso caso será utilizado o MongoDB, assim:

<dependency>
    <groupId>org.jnosql.diana</groupId>
    <artifactId>mongodb-driver</artifactId>
    <version>0.0.1</version>
</dependency>

p.s: Atualmente é necessário adicionar o repositório do JNoSQL para ter acesso as suas dependências:

<repositories>
    <repository>
        <id>jnsoql-repo</id>
        <name>JNoSQL Maven Repository</name>
        <url>https://dl.bintray.com/jnosql/maven/</url> 
        <layout>default</layout>
    </repository>
</repositories>

As classes da API de documento seguem a seguinte estrutura:

  • DocumentConfiguration: Classe responsável pela configuração e conexão com o banco de dados, uma vez esse setup varia fortemente em cada banco de dados.
  • DocumentManagerFactory: classe responsável pela criação de uma interface Manager
  • DocumentManager: assim como no JPA, essa classe é a responsável pelo gerenciamento da entidade.
  • DocumentEntity: uma entidade de uma coleção de documentos
  • Document: Um DocumentEntity é composto por diversos documentos, ele é composto por uma tupla em que a chave é o nome e o valor é a informação propriamente dita. Essa informação poderá ser qualquer valor, variando de cada driver, inclusive um outro documento ou subdocumento.

Com o driver do MongoDB é necessário é possível realizar o CRUD de maneira simples:

public class MongoDBApp {

    public static final String DATABASE = "default";
    public static final String DOCUMENT_COLLECTION = "person";

    public static void main(String[] args) {
        String idValue = UUID.randomUUID().toString();
        DocumentConfiguration configuration = new MongoDBDocumentConfiguration();
        try (DocumentCollectionManagerFactory collectionFactory = configuration.get();) {
            DocumentCollectionManager collectionManager = collectionFactory.get(DATABASE);

            DocumentEntity entity = DocumentEntity.of(DOCUMENT_COLLECTION);
            entity.add(Document.of("name", "Daniel Soro"));
            entity.add(Document.of("age", 26));
            entity.add(Document.of("_id", idValue));

            DocumentEntity entitySaved = collectionManager.save(entity);
            Optional<Document> id = entitySaved.find("_id");

            DocumentQuery query = DocumentQuery.of(DOCUMENT_COLLECTION);
            query.and(DocumentCondition.eq(id.get()));
            List<DocumentEntity> documentsFound = collectionManager.find(query);


        }
    }
}

Vale salientar que é necessário existir um banco MongoDB instalado e rodando. Com o MongoDB é necessário também informar o IP para que o Diana consiga se conectar. Para isso, é necessário o arquivo diana-mongodb.properties no classpath. Assim, ele terá as informações dos bancos que serão conectados. No nosso, exemplo:

mongodb-server-host-1=localhost:27017

Tip: uma maneira simples de instalar o mongodb é utilizando o docker: https://hub.docker.com/_/mongo/

Para demonstrar a facilidade de utilizar a API, utilizaremos também um segundo banco de dados, dessa vez, o Couchbase.

Ao utilizar a sua dependência:

<dependency>
    <groupId>org.jnosql.diana</groupId>
    <artifactId>couchbase-driver</artifactId>
    <version>0.0.1</version>
</dependency>

E no código:

public class CouchbaseApp {

    public static final String DATABASE = "default";
    public static final String DOCUMENT_COLLECTION = "person";

    public static void main(String[] args) {
        String idValue = UUID.randomUUID().toString();
        DocumentConfiguration configuration = new CouchbaseDocumentConfiguration();
        try (DocumentCollectionManagerFactory collectionFactory = configuration.get();) {
            DocumentCollectionManager collectionManager = collectionFactory.get(DATABASE);

            DocumentEntity entity = DocumentEntity.of(DOCUMENT_COLLECTION);
            entity.add(Document.of("name", "Daniel Soro"));
            entity.add(Document.of("age", 26));
            entity.add(Document.of("_id", idValue));
            DocumentEntity entitySaved = collectionManager.save(entity);
            Optional<Document> id = entitySaved.find("_id");

            DocumentQuery query = DocumentQuery.of(DOCUMENT_COLLECTION);
            query.and(DocumentCondition.eq(id.get()));
            List<DocumentEntity> documentsFound = collectionManager.find(query);


        }
    }
}

Assim, como no caso do MongoDB, é necessário que o Couchbase seja instalado e configurado é necessário configurar o arquivo diana-couchbase.properties com os Ips dentre outras informações:

couchbase-host-1=localhost
couchbase-user=root
couchbase-password=123456

Tip: Seguindo a mesma dica do MongoDB, uma boa estratégia é utilizar docker: https://hub.docker.com/_/couchbase/

Especializações

Como mencionado, a extensibilidade dos bancos não relacionais é muito importante uma vez que os bancos têm comportamentos específicos. Por exemplo, o Couchbase tem o N1SQL que é uma query específica realizada em cima do JSON que atualmente, apenas o mesmo possui.

public class CouchbaseApp2 {

    public static final String DATABASE = "default";
    public static final String DOCUMENT_COLLECTION = "person";

    public static void main(String[] args) {
        String idValue = UUID.randomUUID().toString();
        CouchbaseDocumentConfiguration configuration = new CouchbaseDocumentConfiguration();
        try (CouhbaseDocumentCollectionManagerFactory collectionFactory = configuration.get();) {
            CouchbaseDocumentCollectionManager collectionManager = collectionFactory.get(DATABASE);

            DocumentEntity entity = DocumentEntity.of(DOCUMENT_COLLECTION);
            entity.add(Document.of("name", "Daniel Soro"));
            entity.add(Document.of("age", 26));
            entity.add(Document.of("_id", idValue));
            DocumentEntity entitySaved = collectionManager.save(entity);
            Optional<Document> id = entitySaved.find("_id");

            JsonObject params = JsonObject.create();
            params.put("id", id.get().get());
            List<DocumentEntity> entities = collectionManager.n1qlQuery("select * from " + DATABASE + " where _id = $id", params);
            System.out.println(entities);
        }
    }
}

Com isso concluímos o artigo falando da camada de comunicação do projeto JNoSQL para documentos, mesmo com a API comum as implementações serão diferentes, por exemplo, a forma de armazenar o valor, json ou bjson, ou a criação automática do campo “_id” ou não, caso ele não tenha sido informado

Referências:

JNoSQL – Diana Release 0.0.1

O JNoSQL é uma tecnologia Java cujo o foco é criar um API comum para comunicação para os bancos não relacionais, não esquecendo também da diversidade que eles possuem. Com o intuito de atender esse objetivo ele é subdividido em duas camadas: A camada de comunicação, aka Diana, responsável pela comunicação Java com o banco de dados, fazendo uma relação com o mundo relacional, ele teria um papel semelhante ao JDBC. A camada de abstração, aka Artemis, responsável pela abstração é responsável por converter uma entidade ou objeto da aplicação para um modelo de baixo nível. Realizando a analogia com o mundo relacional, seria o que o JPA ou um ORM para o NoSQL. O objetivo desse artigo será falar sobre a camada de comunicação, aka Diana.

Dividir e conquistar é uma estratégia comum no mundo Java. Cada uma dessas camadas tem quatro APIs independentes, uma para cada tipo de banco de dados.

AFINAL, VALE A PENA CRIAR UMA API COMUM?

Se olharmos, por exemplo, para as APIs de alguns bancos de dados de Documentos teremos as seguintes classes:

  • BaseDocument para o ArangoDB
  • JsonDocument para o couchbase
  • Json serializador para o Elasticsearch
  • org.bson.Document para o MongoDB
  • ODocument para o OrientDB

Repararemos que eles não tem muita coisa em comum com relação a nomenclatura e compatibilidade de classe ou nome e parâmetros de métodos, etc.. Porém, ao verificar profundamente sua estrutura:

//orientDB
ODocument document = new ODocument(“collection”);
document.field(name, value);

//mongodb
Document document = new Document();
document.append(name, value);

//couchbase
JsonObject jsonObject = JsonObject.create();
jsonObject.put(name, value);

//arangodb
BaseDocument baseDocument = new BaseDocument();
baseDocument.addAttribute(name, value);

É possível perceber eles possuem uma inspiração semelhante, afinal, uma coleção de documento possui um ou mais documentos no qual é uma tupla composta pelo valor e o seu respectivo nome.

Esse tipo de problema acontece também com outras definições, por exemplo, com o TTL, além das operações de CRUD.

Os bancos NoSQL, assim como os bancos de dados, possuem operações básicas que fazem parte do CRUD, ou seja, criar, recuperar atualizar e deletar informações. O problema nesse caso além da estrutura a ser recuperada está na nomenclatura utilizada, por exemplo:

  • insert ou save
  • delete ou remove
  • find ou search
  • callback para realizar operações assíncronas

Para o time to live, de uma informação:

  • long para segundos
  • int para segundos
  • long para milissegundos
  • int para milissegundos

Com essa API, é possível converter para a implementação desejada sem que haja impacto algum nas operações de banco de dados, além de não ser necessário aprender uma nova nomenclatura.

Document document = Document.of(name, value);
DocumentEntity entity = DocumentEntity.of(“collection”);
entity.add(document);

A diversidade nos bancos não relacionais

Certamente a diversidade, seja do tipo e o comportamento único que um banco de dados pode oferecer não pode ficar de fora em uma API desse tipo. Assim, o Diana permite realizar operações de um banco específico como live query do OrientDB, N1ql do couchbase, CQL do Cassandra, recurso de search engine do Elasticsearch dentre outros. Com a vantagem de que a estrutura de dados retornada será uma padronizada.

Drivers disponíveis

Nessa primeira versão o diana terá suporte nos seguintes drivers:

  • ArangoDB
  • Cassandra
  • Coucbase
  • Elasticsearch
  • Hazelcast
  • Hbase
  • MongoDB
  • OrientDB
  • Redis
  • Riak
  • ScyllaDB

Referências:

Vamos falar de Padrões NoSQL [Q&A]

duke-diana-min

Com a evolução da tecnologia da persistência, termo como “persistência poliglota” vem se tornando cada vez mais comum para o vocábulo do desenvolvedor. Atualmente, não basta utilizar a linguagem de programação mais apropriada para o problema, mas também utilizar o melhor banco e a melhor forma de persistir tais informações. Uma boa escolha trará certamente uma facilidade na leitura, elasticidade além de performance tanto na leitura quanto na escrita, isso variará de acordo com o objetivo e interesse de cada programa. Com isso, nem todas as aplicações utilizam ou utilizarão as soluções clássicas para persistência, os bancos relacionais. Os bancos NoSQL se tornaram uma solução muito comum para isso. O objetivo desse artigo é esclarecer algumas sobre o mais recente projeto criado, o JNoSQL, dúvidas com relação aos próximos passos dos bancos NoSQL focando na linguagem mais utilizada no mundo, Java, no formato de perguntas e respostas.

Para os detalhes iniciais como definição, já realizei um post sobre isso:

https://otaviojava.wordpress.com/2016/09/10/nosql-java/

O que é o JNoSQL?

O projeto JNoSQL é um projeto que visa a criação de ferramentas para o desenvolvimento de bancos não relacionais, os NoSQL, seu foco será padronizar os bancos NoSQL olhando para sua diversidade, ou seja, criando mecanismo para que o mesmo seja extensivo. Para facilitar o desenvolvimento dessa ferramenta foram criadas duas camadas abaixo do JNoSQL:

A camada de comunicação (aka Diana): Essa camada é responsável por realizar a comunicação entre a aplicação Java e o banco de dados. Essa API será dividida em quatro partes, uma para cada tipo de banco NoSQL. Ele será semelhante ao JDBC do mundo relacional.

A camada de abstração (aka Artemis): semelhante ao ORM ele é responsável por facilitar a abstração para o desenvolvedor Java, ela será orientada a anotações e realizará integrações com outras tecnologias como, por exemplo, o bean validation. O seu coração será o CDI.

Essa divisão tem algumas vantagens:

  • Divisão de problemas (Assim, os bancos de dados darão atenção apenas a camada de comunicação enquanto desenvolvedores de framework darão atenção numa camada superior.
  • Facilidade na implementação, uma vez um novo banco de dados interessado em implementar a API do JNoSQL será necessário apenas implementar a API de comunicação não se preocupando com as outras camadas.
  • Facilidade em componentização, com essa estratégia será possível trocar um dos dois componentes sem que necessariamente exista impacto no outro lado.

Vamos padronizar?

Sim, a ideia é que o resultado do trabalho dentro do JNoSQL seja o foco de padronização. Inicialmente, apenas a camada de comunicação será levada como uma JSR. Esse é um dos motivos que esse projeto tem como parcerias diversos provedores de banco de dados, por exemplo, Cassandra, Hazelcast, OrientDB, couchbase, ArangoDB, MongoDB, HBase além da participação da comunidade (SouJava, LondoJC, ThinkerPOP, dentre outros).

É possível padronizar 100%?

Mesmo os bancos relacionais que já estão a décadas no mercado, não é possível padronizar todo o processo. O mesmo acontece com os bancos NoSQL, inicialmente serão padronizadas as entidades, as hierarquias e algumas ações. Existirão quatro tipos de API, detalhado anteriormente. Mesmo com bancos de dados do mesmo tipo, por exemplo família de coluna com Cassandra e o hbase, existem comportamentos diferentes, por exemplo o nível de consistência e o Cassandra Query Language que existem apenas no Cassandra, para isso a API deverá fornecer a extensibilidade para que seja possível realizar tal operação, no entanto, mesmo com esses comportamentos diferentes o Cassandra continuará lidando as mesmas entidades que o Hbase (Família de Colunas, Colunas, chave da família de coluna, etc.). Por exemplo:

//both implementations (Hbase and Cassandra)
ColumnFamilyEntity entity = …/
entityManager.save(entity);
//just on Cassandra
cassandraEntityManager.save(entity, ConsistencyLevel.ALL);
List entities = entityManager.cql(¨select * from entity¨);

Existirão casos também na qual a API retornará uma exceção de operação não suportada, caso o banco de dados não suporte algumas operações.

Quais métodos serão padronizados?

Nessa primeira versão o foco será padronizar apenas os modelos além de métodos de operação básicas, são eles:

  • Inserir de maneira síncrona, assíncrona, assíncrona com calback além do uso de TTL
  • Atualizar de maneira síncrona, assíncrona, assíncrona com calback além do uso de TTL
  • Deletar de maneira síncrona, assíncrona, assíncrona com calback além do uso de TTL
  • Realizar queries de maneira síncrona e assíncrona

Ou seja, inicialmente as APIs conseguirão realizar as operações de CRUD.

A única exceção será a API de grafos, na verdade, o modelo de grafos já existe uma padronização já conhecida: o ThinkerPOP. A ideia é que a API contenha as partes mais estáveis desse projeto e sua implementação de referência seja uma simples adapter entre os projetos, em outras palavras, todos os bancos que suportam o ThinkerPOP, automaticamente suportarão o Diana.

Mesmo sem padronizar tudo ainda vale a pena?

Nós acreditamos, que sim! Será necessário realizar o primeiro passo e o JNoSQL realizará esse passo. Utilizaremos a estratégia incremental, ou seja, serão dados pequenos passos e pequenos releases para que recebemos rápidos feedbacks sobre a API.

O que acontece com um banco de dados que suporta dois tipos de bancos de dados?

Ele terá que implementar uma API para cada banco de dados que ele suporte. A ideia também é que existe um TCK, que terá como objetivo verificar se a banco de dados suporta ou não corretamente essa API.

Qual é o seu atual status?

O projeto foi recentemente aceito para Eclipse Foundation e estamos recebendo alguns feedbacks sobre a API. Também foi realizada uma apresentação do projeto para o JCP no F2F em Londres: https://goo.gl/2pKwrd

Como faço para ajudar?

Atualmente existem diversas maneiras de ajudar o projeto:

  • Documentação
  • Revisar a documentação já existente
  • Feedback na API
  • Encontrar bugs na implementação
  • Implementar novos drivers
  • Criar exemplos
  • Ajudar na tradução do material para o seu idioma
  • Realizar a palestra sobre esse projeto no seu JUG.

Quais referências estou utilizando?

Estamos utilizando como base diversos projetos existentes, inclusive, além da nomeclatura. Sempre que possível utilizaremos a mesma nomenclatura já existente em outras especificações para facilitar o aprendizado dos desenvolvedores Java.

Vamos de falar de padrões para o NoSQL em Java

duke-diana

JNoSQL Project

Os bancos NoSQL são bancos de dados que realizam operação de inserção e recuperação de dados utilizando outro modelo que não seja o relacional. Esses tipos de bancos se caracterizam pela velocidade e alta taxa de escalabilidade e vem sendo utilizado com maior frequência em diversos tipos de aplicações, inclusive, aplicações para as instituições financeiras. Como consequência, cresce também o número de vendors ou distribuidores para esse tipo de banco de dados.

Os bancos de dados NOSQL são definidos basicamente pelo seu modelo de armazenamento que são cinco:

Chave-valor: Possui uma estrutura muito semelhante à do java.util.Map, onde podemos armazenar uma chave e seu valor. Normalmente esse valor pode ser qualquer informação.

  • AmazonDynamo
  • AmazonS3
  • Redis
  • Scalaris
  • Voldemort

Orientado a documentos: Este modelo permite armazenar qualquer documento, sem ter a necessidade de definir previamente sua estrutura. O documento e composto por inúmeros campos, com tipos de dados diversos, inclusive um campo pode conter um outro documento, possui uma estrutura semelhante a um arquivo XML.

  • AmazonSimpleDb
  • ApacheCouchdb
  • MongoDb
  • Riak

Família de colunas: Esse modelo se tornou popular através do paper BigTable do Google, com o objetivo de montar um sistema de armazenamento de dados distribuído, projetado para ter um alto grau de escalabilidade e de volume de dados.

  • Hbase
  • Cassandra
  • Scylla
  • Clouddata
  • SimpleDb
  • DynamoDB

Grafos: é uma estrutura de dados que conecta um conjunto de vértices através de um conjunto de arestas. Os bancos de dados de grafo modernos suportam estruturas de grafo multi-relacionais, onde existem tipos diferentes vértices (representando pessoas, lugares, itens) e diferentes tipos de arestas.

  • Neo4j
  • InfoGrid
  • Sones
  • HyperGraphDB

Muli-model database: Alguns bancos de dados possuem a comum característica de ter suporte de um ou mais modelos apresentados anteriormente.

  • OrientDB
  • Couchbase

Comparando com as aplicações Java que utilizam bancos relacionais. É uma boa prática ter uma camada que é responsável por realizar a comunicação entre o banco de dados e o modelo, o bom e velho Data Acess Object ou DAO. Essa camada contém toda a API de comunicação com o banco de dados, olhando no mundo relacional, existem diversos vendors desse tipo de banco de dados, porém, com o padrão JPA o desenvolvedor Java tem algumas vantagens:

  • Não existe lock-in vendor, ou seja, com o padrão a mudança acontece de maneira bem simples e transparente, apenas é necessário trocar o driver.

  • Não é necessário aprender uma nova API para um novo banco de dados uma vez que a API é comum entre todos os bancos de dados.

  • Impacto praticamente zero em realizar a mudança de banco de dados, em alguns momentos é necessário utilizar um recurso específico de um banco de dados.

Nos bancos de dados NOSQL como não existe nenhum padrão pré estabelecido atualmente, assim os desenvolvedores Java enfrentam os seguintes problemas:

  • Lock-in verdor

  • Para um novo banco de dados é necessário aprender uma nova API.

  • Para qualquer mudança de banco de dados o impacto é altíssimo, se perde praticamente toda a camada DAO uma vez que a API muda completamente. Isso acontece mesmo que a mudança seja para o mesmo tipo de banco NOSQL, família de coluna para família de coluna.

Com esse problema, existe um grande esforço ao criar uma API comuns entre esses bancos de dados. É o caso do Spring Data, Hibernate ORM e o TopLink. Como a API JPA já é uma camada muito conhecida entre os desenvolvedores Java, ele é comumente utilizada para facilitar o mapeamento, porém, o seu foco é para os bancos relacionais, assim ele não é suficiente para cobrir todos os casos desses bancos, por exemplo, muitos bancos NOSQL não tem transação ou com essa API não é possível realizar a inserção de forma assíncrona. Assim, infelizmente apesar de o JPA ser uma boa Api ela não contempla todos os comportamentos existentes nos bancos não relacionais. A melhor analogia para esse caso é: Não se pode controlar um avião com os mesmos controles, uma API, de um carro.

A solução para esse caso seria finalmente criar uma especificação que visa cobrir os quatro tipos de bancos de dados citados. A ideia é que essa nova especificação possua sua API bem semelhante ao JPA, uma vez que o desenvolvedor java já está acostumado com o mesmo, além de adicionar novos recursos na API (Suporte a inserção e recuperação de forma assíncrona) e exceções (por exemplo, quando o banco de dados não suportar determinado recurso).

Além da API, a ideia é que exista também a integração com as outras especificações Java, é o caso do bean validation e CDI. Assim, será possível validar os modelos, realizar a injeção de controle de persistência além de criar ciclo de vida de persistência a partir de eventos.

Os bancos não relacionais ou NoSQL são uma tendência e muitos novos vendors existirão, porém, com a criação de uma nova API o desenvolvedor Java não precisará se preocupar em criar uma API e/ou perder toda uma camada quando isso acontecer.

O motivo de se criar uma API é que as já existentes como JPA e JDO não cobrem todo o comportamento esperado para os bancos não relacionais, por exemplo, inserção assíncrona, recuperação assíncrona. Porém, o objetivo é que essa nova API seja o mais próximo semântica mente com as já existentes.

Muitos bancos não relacionais vem surgindo no mundo do desenvolvimento de software, além do seu uso no mundo Java, por exemplo, na última pesquisa sobre Java EE o número de aplicações que usavam essa tecnologia para armazenamento chegava a quase 50%. Permitir a criação do padrão facilitará a visa do desenvolvedor Java, uma vez que não será necessário aprender uma nova API ou a facilitar em realizar a mudança do banco de dados sem ser necessário aprender uma nova API. Porém, assim como nos bancos relacionais, utilizar recursos específicos dos bancos de dados não trará suporte para API, mas o que acontece nas aplicações normais é que boa parte do código é padronizável, ou seja, mesmo que o custo da migração não seja zero, será um número bem menor comparado o atualmente.

Referências: