Introdução às APIs Java do OrientDB

1. Visão geral

OrientDB é uma tecnologia de banco de dados Multi-Model NoSQL de código aberto projetada para funcionar com os modelosGraph,Document,Key-Value,GeoSpatialeReactive durante o gerenciamento de consultas com sintaxeSQL.

Neste artigo, abordaremos a configuração e usaremos as APIs Java do OrientDB.

2. Instalação

Primeiramente, precisamos instalar o pacote binário.

Vamos baixar a versão estável mais recente deOrientDB (2.2.x no momento de escrever este artigo).

Em segundo lugar, precisamos descompactá-lo e mover seu conteúdo para um diretório conveniente (usandoORIENTDB_HOME). Certifique-se de adicionar a pastabin às variáveis de ambiente para qualquer uso fácil de linha de comando.

Finalmente, precisamos editar o arquivoorientdb.sh localizado em$ORIENTDB_HOME/bin preenchendo a localização (ORIENTDB_HOME) do diretório OrientDB no lugar de[.s1]#ORIENTDB_DIR #and also the system user we’d like to use instead of USER_YOU_WANT_ORIENTDB_RUN_WITH.

Agora temos um OrientDB totalmente funcional. Podemos usar oorientdb.sh <option> script with options:

start: para iniciar o servidor
status: para verificar o status
stop: para parar o servidor

Observe que as açõesstart estop exigem a senha do usuário (a que configuramos no arquivoorientdb.sh).

Assim que o servidor for iniciado, ele ocupará a porta 2480. Portanto, podemos acessá-lo localmente usando esteURL:

Mais detalhes da instalação manual podem ser encontradoshere.

Nota: OrientDB requerJava versão 1.7 ou superior.

As versões anteriores estão disponíveishere.

3. Configuração de APIs OrientDB Java

O OrientDB permite que os desenvolvedores Java trabalhem com três APIs diferentes, como:

API do Graph - bancos de dados de gráficos
API de documentos - bancos de dados orientados a documentos
API de objeto - objetos vinculados diretamente ao documento do OrientDB

Podemos usar todos esses tipos em uma única base de código apenas integrando e usando o OrientDB.

Vamos dar uma olhada em alguns jars disponíveis que podemos incluir no classpath do projeto:

orientdb-core-*.jar: traz a biblioteca principal
blueprints-core-*.jar: para trazer os componentes principais dos adaptadores
orientdb-graphdb-*.jar: fornece a API do banco de dados Graph
orientdb-object-*.jar: fornece a API do banco de dados de objetos
orientdb-distributed-*.jar: fornece o plugin de banco de dados distribuído para trabalhar com um cluster de servidor
orientdb-tools-*.jar: entrega o comando do console
orientdb-client-*.jar: fornece o cliente remoto
orientdb-enterprise-*.jar: ativa o protocolo e as classes de rede compartilhadas pelo cliente e servidor

Os dois últimos são necessários apenas se estivermos gerenciando nossos dados em um servidor remoto.

Vamos começar com um projeto Maven e usar as seguintes dependências:


    com.orientechnologies
    orientdb-core
    2.2.31


    com.orientechnologies
    orientdb-graphdb
    2.2.31


    com.orientechnologies
    orientdb-object
    2.2.31


    com.tinkerpop.blueprints
    blueprints-core
    2.6.0

Verifique o repositório Maven Central para as versões mais recentes das APIsCore,GraphDB,Object do OrientDB eBlueprints-Core.

4. Uso

O OrientDB está usando a implementaçãoTinkerPop Blueprints para trabalhar com gráficos.

TinkerPop é um Graph Computing Framework que fornece muitas maneiras de construir bancos de dados de gráficos, onde cada um deles tem suas implementações:

Além disso, o OrientDB permite trabalhar com os três tipos deSchemas independentemente do tipo de API:

Esquema completo - o modo estrito está ativado, portanto, todos os campos são especificados durante a criação da classe
Schema-Less - as classes são criadas sem nenhuma propriedade específica, portanto podemos adicioná-las como quisermos; it’s the default mode
Schema-Hybrid - é a mistura de schema-full e schema-less, onde podemos criar uma classe com campos pré-definidos, mas deixar o registro definir outros personalizados

4.1. API do gráfico

Como este é um banco de dados baseado em gráficos, os dados são representados como uma rede contendoVertices (nós) interconectados porEdges (arcos).

Como uma primeira etapa, vamos usar a IU para criar um banco de dados Graph chamadoexampleDB com um usuárioadmine senhaadmin.

Como podemos ver na imagem subsequente, ograph foi selecionado como tipo de banco de dados, portanto, consequentemente, seus dados estarão acessíveis noGRAPH Tab:

Vamos agora conectar ao banco de dados desejado, sabendo queORIENTDB_HOME é uma variável de ambiente que corresponde à pasta de instalação deOrientDB:

@BeforeClass
public static void setup() {
    String orientDBFolder = System.getenv("ORIENTDB_HOME");
    graph = new OrientGraphNoTx("plocal:" + orientDBFolder +
      "/databases/exampleDB", "admin", "admin");
}

Vamos iniciar as classesArticle,Author eEditor - enquanto mostramos como adicionar validação aos seus campos:

@BeforeClass
public static void init() {
    graph.createVertexType("Article");

    OrientVertexType writerType
      = graph.createVertexType("Writer");
    writerType.setStrictMode(true);
    writerType.createProperty("firstName", OType.STRING);
    // ...

    OrientVertexType authorType
      = graph.createVertexType("Author", "Writer");
    authorType.createProperty("level", OType.INTEGER).setMax("3");

    OrientVertexType editorType
      = graph.createVertexType("Editor", "Writer");
    editorType.createProperty("level", OType.INTEGER).setMin("3");

    Vertex vEditor = graph.addVertex("class:Editor");
    vEditor.setProperty("firstName", "Maxim");
    // ...

    Vertex vAuthor = graph.addVertex("class:Author");
    vAuthor.setProperty("firstName", "Jerome");
    // ...

    Vertex vArticle = graph.addVertex("class:Article");
    vArticle.setProperty("title", "Introduction to ...");
    // ...

    graph.addEdge(null, vAuthor, vEditor, "has");
    graph.addEdge(null, vAuthor, vArticle, "wrote");
}

No snippet de código acima, fizemos uma representação simples do nosso banco de dados simples, onde:

Article é a classe sem esquema que contém artigos
Writer é uma superclasse de esquema completo que contém as informações necessárias do escritor
Writer é um subtipo deAuthor que contém seus detalhes
Editor é um subtipo sem esquema deWriter que contém detalhes do editor
O campolastName não foi preenchido com o autor salvo, mas ainda aparece no gráfico a seguir
temos uma relação entre todas as classes: umAuthor pode escreverArticlee precisa ter umEditor
Vertex representa uma entidade com alguns campos
Edge é uma entidade que liga doisVertices

Observe que, ao tentar adicionar outra propriedade a um objeto de uma classe completa, terminaremos comOValidationException.

Depois de nos conectar ao nosso banco de dados usandoOrientDB studio, veremos a representação gráfica de nossos dados:

Vamos ver como ter o número de todos os registros (vértices) do banco de dados:

long size = graph.countVertices();

Agora, vamos mostrar apenas o número de objetosWriter (Author & Editor):

@Test
public void givenexampleDB_checkWeHaveTwoWriters() {
    long size = graph.countVertices("Writer");

    assertEquals(2, size);
}

Na próxima etapa, podemos encontrar todos os dados deWriter, usando a seguinte instrução:

Iterable writers = graph.getVerticesOfClass("Writer");

Finalmente, vamos consultar todos osEditor comlevel 7; aqui temos apenas um que corresponde a:

@Test
public void givenexampleDB_getEditorWithLevelSeven() {
    String onlyEditor = "";
    for(Vertex v : graph.getVertices("Editor.level", 7)) {
        onlyEditor = v.getProperty("firstName").toString();
    }

    assertEquals("Maxim", onlyEditor);
}

O nome da classe é sempre especificado para procurar um vértice específico ao solicitar. Podemos encontrar mais detalheshere.

4.2. API de documento

A próxima opção é usar o modelo de documento do OrientDB. Isso expõe a manipulação de dados por meio de um registro simples com informações armazenadas em campos onde o tipo pode ser texto, figura ou forma binária.

Vamos usar a IU novamente para criar um banco de dados chamadoexampleDBTwo, mas agora comdocument como tipo:

Nota: da mesma forma, essa API também pode ser usada no modo cheio de esquema, sem esquema ou híbrido de esquema.

A conexão do banco de dados permanece direta, pois só precisamos instanciar um objetoODatabaseDocumentTx, fornecer a URL do banco de dados e as credenciais do usuário do banco de dados:

@BeforeClass
public static void setup() {
    String orientDBFolder = System.getenv("ORIENTDB_HOME");
    db = new ODatabaseDocumentTx("plocal:"
      + orientDBFolder + "/databases/exampleDBTwo")
      .open("admin", "admin");
}

Vamos começar salvando um documento simples que contém informações deAuthor.

Aqui podemos ver que a classe foi criada automaticamente:

@Test
public void givenDB_whenSavingDocument_thenClassIsAutoCreated() {
    ODocument doc = new ODocument("Author");
    doc.field("name", "Paul");
    doc.save();

    assertEquals("Author", doc.getSchemaClass().getName());
}

Assim, para contar o número deAuthors, podemos usar:

long size = db.countClass("Author");

Vamos consultar os documentos novamente usando um valor de campo, para pesquisar os objetosAuthor comlevel 7:

@Test
public void givenDB_whenSavingAuthors_thenWeGetOnesWithLevelSeven() {
    for (ODocument author : db.browseClass("Author")) author.delete();

    ODocument authorOne = new ODocument("Author");
    authorOne.field("firstName", "Leo");
    authorOne.field("level", 7);
    authorOne.save();

    ODocument authorTwo = new ODocument("Author");
    authorTwo.field("firstName", "Lucien");
    authorTwo.field("level", 9);
    authorTwo.save();

    List result = db.query(
      new OSQLSynchQuery("select * from Author where level = 7"));

    assertEquals(1, result.size());
}

Da mesma forma, para deletar todos os registros da classeAuthor, podemos usar:

for (ODocument author : db.browseClass("Author")) {
    author.delete();
}

NoBROWSE Tab do estúdio OrientDB, podemos fazer uma consulta para obter todos os nossos objetosAuthor's:

4.3. API de objeto

OrientDB não tem o tipo de objeto de banco de dados. Portanto, a API de objetos depende de um banco de dados de documentos.

No tipo de API de objeto, todos os outros conceitos permanecem os mesmos, com apenas uma adição -binding ao POJO.

Vamos começar conectando aoexampleDBThree usando a classeOObjectDatabaseTx:

@BeforeClass
public static void setup() {
    String orientDBFolder = System.getenv("ORIENTDB_HOME");
    db = new OObjectDatabaseTx("plocal:"
      + orientDBFolder + "/databases/exampleDBThree")
      .open("admin", "admin");
}

Em seguida, assumindo queAuthor é o POJO usado para conter os dadosAuthor, precisamos registrá-lo:

db.getEntityManager().registerEntityClass(Author.class);

Author tem getters e setters para os seguintes campos:

primeiro nome
último nome
nível

Vamos criar umAuthor com instruções multilinhas se reconhecermos um construtor sem arg:

Author author = db.newInstance(Author.class);
author.setFirstName("Luke");
author.setLastName("Sky");
author.setLevel(9);
db.save(author);

Por outro lado, se tivermos outro construtor que levafirstName,lastName elevel deAuthor respectivamente, a instanciação é apenas uma linha:

Author author = db.newInstance(Author.class, "Luke", "Sky", 9);
db.save(author);

As seguintes linhas estão sendo usadas para procurar e excluir todos os registros da classe Autor:

for (Author author : db.browseClass(Author.class)) {
    db.delete(author);
}

Para contar todos os autores, apenas precisamos fornecer a classe e a instância do banco de dados sem a necessidade de escrever uma consulta SQL:

long authorsCount = db.countClass(Author.class);

Da mesma forma, consultamos autores comlevel 7 assim:

@Test
public void givenDB_whenSavingAuthors_thenWeGetOnesWithLevelSeven() {
    for (Author author : db.browseClass(Author.class)) {
        db.delete(author);
    }

    Author authorOne
      = db.newInstance(Author.class, "Leo", "Marta", 7);
    db.save(authorOne);

    Author authorTwo
      = db.newInstance(Author.class, "Lucien", "Aurelien", 9);
    db.save(authorTwo);

    List result
      = db.query(new OSQLSynchQuery(
      "select * from Author where level = 7"));

    assertEquals(1, result.size());
}

Finalmente, este é oofficial guide que apresenta alguns usos avançados da API Object.

5. Conclusão

Neste artigo, vimos como usar o OrientDB como um sistema de gerenciamento de banco de dados com suas APIs Java. Também aprendemos como adicionar validação nos campos e escrever algumas consultas simples.

Como sempre, o código-fonte deste artigo pode ser encontradoover on GitHub.

TOC

Introdução às APIs Java do OrientDB