ArangoDB - Guia Rápido
ArangoDB é saudado como um banco de dados multi-modelo nativo por seus desenvolvedores. Isso é diferente de outros bancos de dados NoSQL. Neste banco de dados, os dados podem ser armazenados como documentos, pares de chave / valor ou gráficos. E com uma única linguagem de consulta declarativa, qualquer um ou todos os seus dados podem ser acessados. Além disso, diferentes modelos podem ser combinados em uma única consulta. E, devido ao seu estilo multi-modelo, pode-se fazer aplicativos enxutos, que serão escalonáveis horizontalmente com qualquer um ou todos os três modelos de dados.
Bancos de dados multi-modelos em camadas vs. nativos
Nesta seção, destacaremos uma diferença crucial entre bancos de dados multimodelos nativos e em camadas.
Muitos fornecedores de banco de dados chamam seu produto de “multimodelo”, mas adicionar uma camada de gráfico a uma chave / valor ou armazenamento de documento não se qualifica como multimodelo nativo.
Com ArangoDB, o mesmo núcleo com a mesma linguagem de consulta, pode-se agrupar diferentes modelos de dados e recursos em uma única consulta, como já afirmamos na seção anterior. No ArangoDB, não há “troca” entre os modelos de dados, e não há troca de dados de A para B para executar consultas. Isso leva a vantagens de desempenho para ArangoDB em comparação com as abordagens “em camadas”.
A necessidade de banco de dados multimodal
A interpretação da ideia básica [de Fowler] nos leva a perceber os benefícios de usar uma variedade de modelos de dados apropriados para diferentes partes da camada de persistência, sendo a camada parte da arquitetura de software maior.
De acordo com isso, pode-se, por exemplo, usar um banco de dados relacional para persistir dados tabulares estruturados; um armazenamento de documentos para dados não estruturados e semelhantes a objetos; um armazenamento de chave / valor para uma tabela hash; e um banco de dados gráfico para dados referenciais altamente vinculados.
No entanto, a implementação tradicional desta abordagem levará a usar vários bancos de dados no mesmo projeto. Isso pode levar a algum atrito operacional (implantação mais complicada, atualizações mais frequentes), bem como a consistência de dados e problemas de duplicação.
O próximo desafio, após unificar os dados para os três modelos de dados, é conceber e implementar uma linguagem de consulta comum que pode permitir que os administradores de dados expressem uma variedade de consultas, como consultas de documentos, pesquisas de chave / valor, consultas gráficas e combinações arbitrárias destes.
De graphy queries, queremos dizer consultas envolvendo considerações teóricas de grafos. Em particular, isso pode envolver os recursos de conectividade específicos provenientes das bordas. Por exemplo,ShortestPath, GraphTraversal, e Neighbors.
Os gráficos são um ajuste perfeito como modelo de dados para relações. Em muitos casos do mundo real, como rede social, sistema de recomendação, etc., um modelo de dados muito natural é um gráfico. Ele captura relações e pode conter informações de rótulo com cada aresta e com cada vértice. Além disso, os documentos JSON são um ajuste natural para armazenar esse tipo de vértice e dados de borda.
ArangoDB ─ Recursos
Existem vários recursos notáveis do ArangoDB. Vamos destacar as características proeminentes abaixo -
- Paradigma Multi-modelo
- Propriedades ACID
- API HTTP
ArangoDB suporta todos os modelos de banco de dados populares. A seguir estão alguns modelos suportados pelo ArangoDB -
- Modelo de documento
- Modelo de chave / valor
- Modelo gráfico
Uma única linguagem de consulta é suficiente para recuperar dados do banco de dados
As quatro propriedades Atomicity, Consistency, Isolation, e Durability(ACID) descreve as garantias das transações do banco de dados. ArangoDB suporta transações compatíveis com ACID.
ArangoDB permite que clientes, como navegadores, interajam com o banco de dados com a API HTTP, a API sendo orientada a recursos e extensível com JavaScript.
A seguir estão as vantagens de usar ArangoDB -
Consolidação
Como um banco de dados multi-modelo nativo, ArangoDB elimina a necessidade de implantar vários bancos de dados e, portanto, diminui o número de componentes e sua manutenção. Conseqüentemente, reduz a complexidade da pilha de tecnologia para o aplicativo. Além de consolidar suas necessidades técnicas gerais, essa simplificação reduz o custo total de propriedade e aumenta a flexibilidade.
Escalonamento de desempenho simplificado
Com os aplicativos crescendo ao longo do tempo, ArangoDB pode lidar com o crescimento das necessidades de desempenho e armazenamento, escalando independentemente com diferentes modelos de dados. Como o ArangoDB pode ser dimensionado tanto vertical quanto horizontalmente, no caso de quando seu desempenho exigir uma diminuição (uma desaceleração deliberada e desejada), seu sistema de back-end pode ser facilmente dimensionado para economizar em hardware e também em custos operacionais.
Complexidade operacional reduzida
O decreto da Persistência Poliglota é empregar as melhores ferramentas para cada trabalho que você realizar. Certas tarefas precisam de um banco de dados de documentos, enquanto outras podem precisar de um banco de dados de gráficos. Como resultado do trabalho com bancos de dados de modelo único, isso pode levar a vários desafios operacionais. A integração de bancos de dados de modelo único é uma tarefa difícil em si. Mas o maior desafio é construir uma grande estrutura coesa com consistência de dados e tolerância a falhas entre sistemas de banco de dados separados e não relacionados. Pode ser quase impossível.
A Persistência Poliglota pode ser tratada com um banco de dados multi-modelo nativo, pois permite ter dados poliglotas facilmente, mas ao mesmo tempo com consistência de dados em um sistema tolerante a falhas. Com ArangoDB, podemos usar o modelo de dados correto para o trabalho complexo.
Forte consistência de dados
Se alguém usa vários bancos de dados de modelo único, a consistência dos dados pode se tornar um problema. Esses bancos de dados não foram projetados para se comunicarem uns com os outros, portanto, alguma forma de funcionalidade de transação precisa ser implementada para manter seus dados consistentes entre os diferentes modelos.
Suportando transações ACID, ArangoDB gerencia seus diferentes modelos de dados com um único back-end, fornecendo forte consistência em uma única instância e operações atômicas ao operar em modo de cluster.
Tolerância ao erro
É um desafio construir sistemas tolerantes a falhas com muitos componentes não relacionados. Esse desafio se torna mais complexo ao trabalhar com clusters. É necessária experiência para implantar e manter esses sistemas, usando diferentes tecnologias e / ou pilhas de tecnologia. Além disso, a integração de vários subsistemas, projetados para funcionar de forma independente, inflige grandes custos operacionais e de engenharia.
Como uma pilha de tecnologia consolidada, o banco de dados de vários modelos apresenta uma solução elegante. Projetado para permitir arquiteturas modulares e modernas com diferentes modelos de dados, o ArangoDB também funciona para o uso de cluster.
Custo total de propriedade mais baixo
Cada tecnologia de banco de dados requer manutenção contínua, correções de correção de bugs e outras alterações de código fornecidas pelo fornecedor. A adoção de um banco de dados com vários modelos reduz significativamente os custos de manutenção relacionados, simplesmente eliminando o número de tecnologias de banco de dados no projeto de um aplicativo.
Transações
Fornecer garantias transacionais em várias máquinas é um desafio real, e poucos bancos de dados NoSQL oferecem essas garantias. Sendo multi-modelo nativo, ArangoDB impõe transações para garantir a consistência dos dados.
Neste capítulo, discutiremos os conceitos básicos e terminologias para ArangoDB. É muito importante ter um conhecimento das terminologias básicas subjacentes ao tema técnico de que estamos tratando.
As terminologias para ArangoDB estão listadas abaixo -
- Document
- Collection
- Identificador de coleção
- Nome da coleção
- Database
- Nome do banco de dados
- Organização de Banco de Dados
Do ponto de vista do modelo de dados, ArangoDB pode ser considerado um banco de dados orientado a documentos, já que a noção de documento é a ideia matemática deste último. Bancos de dados orientados a documentos são uma das principais categorias de bancos de dados NoSQL.
A hierarquia é a seguinte: os documentos são agrupados em coleções e as coleções existem dentro de bancos de dados
Deve ser óbvio que Identificador e Nome são dois atributos para a coleção e o banco de dados.
Normalmente, dois documentos (vértices) armazenados em coleções de documentos são vinculados por um documento (borda) armazenado em uma coleção de bordas. Este é o modelo de dados gráficos do ArangoDB. Ele segue o conceito matemático de um gráfico direcionado e rotulado, exceto que as arestas não têm apenas rótulos, mas são documentos completos.
Tendo nos familiarizado com os termos básicos deste banco de dados, começamos a entender o modelo de dados de gráfico do ArangoDB. Neste modelo, existem dois tipos de coleções: coleções de documentos e coleções de borda. As coleções de borda armazenam documentos e também incluem dois atributos especiais: o primeiro é o_from atributo, e o segundo é o _toatributo. Esses atributos são usados para criar bordas (relações) entre documentos essenciais para banco de dados de grafos. As coleções de documentos também são chamadas de coleções de vértices no contexto de gráficos (consulte qualquer livro de teoria dos grafos).
Vamos agora ver como os bancos de dados são importantes. Eles são importantes porque as coleções existem dentro de bancos de dados. Em uma instância do ArangoDB, pode haver um ou vários bancos de dados. Bancos de dados diferentes são geralmente usados para configurações multilocatário, pois os diferentes conjuntos de dados dentro deles (coleções, documentos etc.) são isolados uns dos outros. O banco de dados padrão_systemé especial, porque não pode ser removido. Os usuários são gerenciados neste banco de dados e suas credenciais são válidas para todos os bancos de dados de uma instância do servidor.
Neste capítulo, discutiremos os requisitos de sistema para ArangoDB.
Os requisitos de sistema para ArangoDB são os seguintes -
- Um servidor VPS com instalação Ubuntu
- RAM: 1 GB; CPU: 2,2 GHz
Para todos os comandos neste tutorial, usamos uma instância do Ubuntu 16.04 (xenial) de RAM de 1 GB com uma cpu com capacidade de processamento de 2,2 GHz. E todos os comandos arangosh neste tutorial foram testados para o ArangoDB versão 3.1.27.
Como instalar o ArangoDB?
Nesta seção, veremos como instalar o ArangoDB. ArangoDB vem pré-construído para muitos sistemas operacionais e distribuições. Para mais detalhes, consulte a documentação do ArangoDB. Como já mencionado, para este tutorial usaremos Ubuntu 16.04x64.
O primeiro passo é baixar a chave pública para seus repositórios -
# wget https://www.arangodb.com/repositories/arangodb31/
xUbuntu_16.04/Release.keyResultado
--2017-09-03 12:13:24-- https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/Release.key
Resolving https://www.arangodb.com/
(www.arangodb.com)... 104.25.1 64.21, 104.25.165.21,
2400:cb00:2048:1::6819:a415, ...
Connecting to https://www.arangodb.com/
(www.arangodb.com)|104.25. 164.21|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 3924 (3.8K) [application/pgpkeys]
Saving to: ‘Release.key’
Release.key 100%[===================>] 3.83K - .-KB/s in 0.001s
2017-09-03 12:13:25 (2.61 MB/s) - ‘Release.key’ saved [39 24/3924]O ponto importante é que você deve ver o Release.key salvo no final da saída.
Vamos instalar a chave salva usando a seguinte linha de código -
# sudo apt-key add Release.keyResultado
OKExecute os seguintes comandos para adicionar o repositório apt e atualizar o índice -
# sudo apt-add-repository 'deb
https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/ /'
# sudo apt-get updateComo uma etapa final, podemos instalar o ArangoDB -
# sudo apt-get install arangodb3Resultado
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following package was automatically installed and is no longer required:
grub-pc-bin
Use 'sudo apt autoremove' to remove it.
The following NEW packages will be installed:
arangodb3
0 upgraded, 1 newly installed, 0 to remove and 17 not upgraded.
Need to get 55.6 MB of archives.
After this operation, 343 MB of additional disk space will be used.pressione Enter. Agora o processo de instalação do ArangoDB vai começar -
Get:1 https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04
arangodb3 3.1.27 [55.6 MB]
Fetched 55.6 MB in 59s (942 kB/s)
Preconfiguring packages ...
Selecting previously unselected package arangodb3.
(Reading database ... 54209 files and directories currently installed.)
Preparing to unpack .../arangodb3_3.1.27_amd64.deb ...
Unpacking arangodb3 (3.1.27) ...
Processing triggers for systemd (229-4ubuntu19) ...
Processing triggers for ureadahead (0.100.0-19) ...
Processing triggers for man-db (2.7.5-1) ...
Setting up arangodb3 (3.1.27) ...
Database files are up-to-date.Quando a instalação do ArangoDB está prestes a ser concluída, a seguinte tela aparece -
Aqui, você será solicitado a fornecer uma senha para o ArangoDB rootdo utilizador. Anote com cuidado.
Selecione os yes opção quando a seguinte caixa de diálogo aparecer -
Quando você clica Yescomo na caixa de diálogo acima, a seguinte caixa de diálogo aparece. CliqueYes aqui.
Você também pode verificar o status do ArangoDB com o seguinte comando -
# sudo systemctl status arangodb3Resultado
arangodb3.service - LSB: arangodb
Loaded: loaded (/etc/init.d/arangodb3; bad; vendor pre set: enabled)
Active: active (running) since Mon 2017-09-04 05:42:35 UTC;
4min 46s ago
Docs: man:systemd-sysv-generator(8)
Process: 2642 ExecStart=/etc/init.d/arangodb3 start (code = exited,
status = 0/SUC
Tasks: 22
Memory: 158.6M
CPU: 3.117s
CGroup: /system.slice/arangodb3.service
├─2689 /usr/sbin/arangod --uid arangodb
--gid arangodb --pid-file /va
└─2690 /usr/sbin/arangod --uid arangodb
--gid arangodb --pid-file /va
Sep 04 05:42:33 ubuntu-512 systemd[1]: Starting LSB: arangodb...
Sep 04 05:42:33 ubuntu-512 arangodb3[2642]: * Starting arango database server a
Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: {startup} starting up in daemon mode
Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: changed working directory for child
Sep 04 05:42:35 ubuntu-512 arangodb3[2642]: ...done.
Sep 04 05:42:35 ubuntu-512 systemd[1]: StartedLSB: arang odb.
Sep 04 05:46:59 ubuntu-512 systemd[1]: Started LSB: arangodb. lines 1-19/19 (END)ArangoDB agora está pronto para ser usado.
Para invocar o terminal arangosh, digite o seguinte comando no terminal -
# arangoshResultado
Please specify a password:Fornece o root senha criada no momento da instalação -
_
__ _ _ __ __ _ _ __ __ _ ___ | |
/ | '__/ _ | ’ \ / ` |/ _ / | ’
| (| | | | (| | | | | (| | () _ \ | | |
_,|| _,|| ||_, |_/|/| ||
|__/arangosh (ArangoDB 3.1.27 [linux] 64bit, using VPack 0.1.30, ICU 54.1, V8
5.0.71.39, OpenSSL 1.0.2g 1 Mar 2016)
Copyright (c) ArangoDB GmbH
Pretty printing values.
Connected to ArangoDB 'http+tcp://127.0.0.1:8529' version: 3.1.27 [server],
database: '_system', username: 'root'
Please note that a new minor version '3.2.2' is available
Type 'tutorial' for a tutorial or 'help' to see common examples
127.0.0.1:[email protected]_system> exit
Para sair do ArangoDB, digite o seguinte comando -
127.0.0.1:[email protected]_system> exitResultado
Uf wiederluege! Na shledanou! Auf Wiedersehen! Bye Bye! Adiau! ¡Hasta luego!
Εις το επανιδείν!
להתראות ! Arrivederci! Tot ziens! Adjö! Au revoir! さようなら До свидания! Até
Breve! !خداحافظNeste capítulo, discutiremos como Arangosh funciona como a linha de comando para ArangoDB. Começaremos aprendendo como adicionar um usuário de banco de dados.
Note - Lembre-se de que o teclado numérico pode não funcionar no Arangosh.
Vamos supor que o usuário seja “harry” e a senha seja “hpwdb”.
127.0.0.1:[email protected]_system> require("org/arangodb/users").save("harry", "hpwdb");Resultado
{
"user" : "harry",
"active" : true,
"extra" : {},
"changePassword" : false,
"code" : 201
}Neste capítulo, aprenderemos como habilitar / desabilitar a autenticação e como vincular o ArangoDB à interface de rede pública.
# arangosh --server.endpoint tcp://127.0.0.1:8529 --server.database "_system"Ele irá solicitar a senha salva anteriormente -
Please specify a password:Use a senha que você criou para o root, na configuração.
Você também pode usar curl para verificar se está realmente recebendo respostas do servidor HTTP 401 (não autorizado) para solicitações que exigem autenticação -
# curl --dump - http://127.0.0.1:8529/_api/versionResultado
HTTP/1.1 401 Unauthorized
X-Content-Type-Options: nosniff
Www-Authenticate: Bearer token_type = "JWT", realm = "ArangoDB"
Server: ArangoDB
Connection: Keep-Alive
Content-Type: text/plain; charset = utf-8
Content-Length: 0Para evitar inserir a senha todas as vezes durante nosso processo de aprendizagem, iremos desativar a autenticação. Para isso, abra o arquivo de configuração -
# vim /etc/arangodb3/arangod.confVocê deve alterar o esquema de cores se o código não estiver devidamente visível.
:colorscheme desertDefina a autenticação como falsa, conforme mostrado na captura de tela abaixo.
Reinicie o serviço -
# service arangodb3 restartAo tornar a autenticação falsa, você será capaz de fazer o login (seja com root ou usuário criado como Harry neste caso) sem inserir nenhuma senha em please specify a password.
Vamos verificar o api versão quando a autenticação é desligada -
# curl --dump - http://127.0.0.1:8529/_api/versionResultado
HTTP/1.1 200 OK
X-Content-Type-Options: nosniff
Server: ArangoDB
Connection: Keep-Alive
Content-Type: application/json; charset=utf-8
Content-Length: 60
{"server":"arango","version":"3.1.27","license":"community"}Neste capítulo, consideraremos dois cenários de exemplo. Esses exemplos são mais fáceis de compreender e nos ajudarão a entender como funciona a funcionalidade do ArangoDB.
Para demonstrar as APIs, ArangoDB vem pré-carregado com um conjunto de gráficos de fácil compreensão. Existem dois métodos para criar instâncias desses gráficos em seu ArangoDB -
- Adicionar guia Exemplo na janela de criação de gráfico na interface da web,
- ou carregue o módulo @arangodb/graph-examples/example-graph em Arangosh.
Para começar, vamos carregar um gráfico com a ajuda da interface web. Para isso, abra a interface web e clique no botãographs aba.
o Create Grapha caixa de diálogo aparece. O assistente contém duas guias -Examples e Graph. oGrapha guia está aberta por padrão; supondo que queremos criar um novo gráfico, ele solicitará o nome e outras definições para o gráfico.
Agora, faremos o upload do gráfico já criado. Para isso, vamos selecionar oExamples aba.
Podemos ver os três gráficos de exemplo. Selecione osKnows_Graph e clique no botão verde Criar.
Depois de criá-los, você pode inspecioná-los na interface da web - que foi usada para criar as imagens abaixo.
The Knows_Graph
Vamos agora ver como o Knows_Graphtrabalho. Selecione o Knows_Graph, e ele irá buscar os dados do gráfico.
O Knows_Graph consiste em uma coleção de vértices persons conectado por meio de uma coleção de borda knows. Ele conterá cinco pessoas Alice, Bob, Charlie, Dave e Eve como vértices. Teremos as seguintes relações dirigidas
Alice knows Bob
Bob knows Charlie
Bob knows Dave
Eve knows Alice
Eve knows Bob
Se você clicar em um nó (vértice), diga 'bob', ele mostrará o nome do atributo ID (pessoas / bob).
E ao clicar em qualquer uma das arestas, ele irá mostrar os atributos ID (sabe / 4590).
É assim que o criamos, inspecionamos seus vértices e arestas.
Vamos adicionar outro gráfico, desta vez usando Arangosh. Para isso, precisamos incluir outro endpoint no arquivo de configuração ArangoDB.
Como adicionar vários terminais
Abra o arquivo de configuração -
# vim /etc/arangodb3/arangod.confAdicione outro endpoint como mostrado na captura de tela do terminal abaixo.
Reinicie o ArangoDB -
# service arangodb3 restartLance o Arangosh -
# arangosh
Please specify a password:
_
__ _ _ __ __ _ _ __ __ _ ___ ___| |__
/ _` | '__/ _` | '_ \ / _` |/ _ \/ __| '_ \
| (_| | | | (_| | | | | (_| | (_) \__ \ | | |
\__,_|_| \__,_|_| |_|\__, |\___/|___/_| |_|
|___/
arangosh (ArangoDB 3.1.27 [linux] 64bit, using VPack 0.1.30, ICU 54.1, V8
5.0.71.39, OpenSSL 1.0.2g 1 Mar 2016)
Copyright (c) ArangoDB GmbH
Pretty printing values.
Connected to ArangoDB 'http+tcp://127.0.0.1:8529' version: 3.1.27
[server], database: '_system', username: 'root'
Please note that a new minor version '3.2.2' is available
Type 'tutorial' for a tutorial or 'help' to see common examples
127.0.0.1:[email protected]_system>The Social_Graph
Vamos agora entender o que é um Social_Graph e como ele funciona. O gráfico mostra um conjunto de pessoas e suas relações -
Este exemplo tem pessoas femininas e masculinas como vértices em duas coleções de vértices - feminino e masculino. As arestas são suas conexões na coleção de arestas de relação. Descrevemos como criar este gráfico usando Arangosh. O leitor pode contornar isso e explorar seus atributos, como fizemos com Knows_Graph.
Neste capítulo, vamos nos concentrar nos seguintes tópicos -
- Interação de banco de dados
- Modelo de dados
- Recuperação de dados
ArangoDB suporta modelo de dados baseado em documento, bem como modelo de dados baseado em gráfico. Vamos primeiro descrever o modelo de dados baseado em documento.
Os documentos de ArangoDB se parecem muito com o formato JSON. Zero ou mais atributos estão contidos em um documento e um valor anexado a cada atributo. Um valor pode ser do tipo atômico, como um número, booleano ou nulo, string literal ou de um tipo de dados composto, como documento / objeto incorporado ou uma matriz. Arrays ou subobjetos podem consistir nesses tipos de dados, o que implica que um único documento pode representar estruturas de dados não triviais.
Mais adiante na hierarquia, os documentos são organizados em coleções, que podem não conter documentos (em teoria) ou mais de um documento. Pode-se comparar documentos a linhas e coleções a tabelas (aqui, tabelas e linhas se referem àquelas de sistemas de gerenciamento de banco de dados relacional - RDBMS).
Mas, no RDBMS, definir colunas é um pré-requisito para armazenar registros em uma tabela, chamando esses esquemas de definições. No entanto, como um recurso novo, ArangoDB não tem esquema - não há razão a priori para especificar quais atributos o documento terá.
E ao contrário do RDBMS, cada documento pode ser estruturado de uma maneira completamente diferente de outro documento. Esses documentos podem ser salvos juntos em uma única coleção. Praticamente, características comuns podem existir entre os documentos da coleção, porém o sistema de banco de dados, ou seja, o próprio ArangoDB, não o vincula a uma estrutura de dados particular.
Agora vamos tentar entender o [graph data model], que requer dois tipos de coleções - a primeira são as coleções de documentos (conhecidas como coleções de vértices na linguagem da teoria de grupo), a segunda são as coleções de borda. Existe uma diferença sutil entre esses dois tipos. As coleções do Edge também armazenam documentos, mas são caracterizadas por incluir dois atributos exclusivos,_from e _topara criar relações entre documentos. Na prática, um documento (ler borda) vincula dois documentos (ler vértices), ambos armazenados em suas respectivas coleções. Essa arquitetura é derivada do conceito teórico de gráfico de um grafo rotulado e direcionado, excluindo as arestas que podem ter não apenas rótulos, mas podem ser um documento do tipo JSON completo em si mesmo.
Para computar dados novos, deletar documentos ou manipulá-los, são utilizadas consultas, que selecionam ou filtram documentos de acordo com os critérios dados. Quer sejam simples como uma “consulta de exemplo” ou tão complexas como “junções”, as consultas são codificadas em AQL - ArangoDB Query Language.
Neste capítulo, discutiremos os diferentes métodos de banco de dados em ArangoDB.
Para começar, vamos obter as propriedades do banco de dados -
- Name
- ID
- Path
Primeiro, invocamos o Arangosh. Assim que Arangosh for invocado, listaremos os bancos de dados que criamos até agora
Usaremos a seguinte linha de código para invocar Arangosh -
127.0.0.1:[email protected]_system> db._databases()Resultado
[
"_system",
"song_collection"
]Vemos dois bancos de dados, um _system criado por padrão, e o segundo song_collection que criamos.
Vamos agora mudar para o banco de dados song_collection com a seguinte linha de código -
127.0.0.1:[email protected]_system> db._useDatabase("song_collection")Resultado
true
127.0.0.1:[email protected]_collection>Exploraremos as propriedades de nosso banco de dados song_collection.
Para encontrar o nome
Usaremos a seguinte linha de código para encontrar o nome.
127.0.0.1:[email protected]_collection> db._name()Resultado
song_collectionPara encontrar o id -
Usaremos a seguinte linha de código para encontrar o id.
song_collectionResultado
4838Para encontrar o caminho -
Usaremos a seguinte linha de código para encontrar o caminho.
127.0.0.1:[email protected]_collection> db._path()Resultado
/var/lib/arangodb3/databases/database-4838Vamos agora verificar se estamos no banco de dados do sistema ou não usando a seguinte linha de código -
127.0.0.1:[email protected]_collection&t; db._isSystem()Resultado
falseIsso significa que não estamos no banco de dados do sistema (como criamos e mudamos para song_collection). A captura de tela a seguir ajudará você a entender isso.
Para obter uma coleção específica, diga canções -
Usaremos a seguinte linha de código para obter uma coleção específica.
127.0.0.1:[email protected]_collection> db._collection("songs")Resultado
[ArangoCollection 4890, "songs" (type document, status loaded)]A linha de código retorna uma única coleção.
Vamos passar para o essencial das operações de banco de dados em nossos capítulos subsequentes.
Neste capítulo, aprenderemos as diferentes operações com a Arangosh.
A seguir estão as operações possíveis com a Arangosh -
- Criando uma coleção de documentos
- Criação de documentos
- Lendo Documentos
- Atualizando Documentos
Vamos começar criando um novo banco de dados. Usaremos a seguinte linha de código para criar um novo banco de dados -
127.0.0.1:[email protected]_system> db._createDatabase("song_collection")
trueA seguinte linha de código o ajudará a mudar para o novo banco de dados -
127.0.0.1:[email protected]_system> db._useDatabase("song_collection")
trueO prompt mudará para "@@ song_collection"
127.0.0.1:[email protected]_collection>
A partir daqui, estudaremos as operações CRUD. Vamos criar uma coleção no novo banco de dados -
127.0.0.1:[email protected]_collection> db._createDocumentCollection('songs')Resultado
[ArangoCollection 4890, "songs" (type document, status loaded)]
127.0.0.1:[email protected]_collection>Vamos adicionar alguns documentos (objetos JSON) à nossa coleção de 'canções'.
Adicionamos o primeiro documento da seguinte maneira -
127.0.0.1:[email protected]_collection> db.songs.save({title: "A Man's Best Friend",
lyricist: "Johnny Mercer", composer: "Johnny Mercer", Year: 1950, _key:
"A_Man"})Resultado
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVClbW---"
}Vamos adicionar outros documentos ao banco de dados. Isso nos ajudará a aprender o processo de consulta dos dados. Você pode copiar esses códigos e colar os mesmos no Arangosh para emular o processo -
127.0.0.1:[email protected]_collection> db.songs.save(
{
title: "Accentchuate The Politics",
lyricist: "Johnny Mercer",
composer: "Harold Arlen", Year: 1944,
_key: "Accentchuate_The"
}
)
{
"_id" : "songs/Accentchuate_The",
"_key" : "Accentchuate_The",
"_rev" : "_VjVDnzO---"
}
127.0.0.1:[email protected]_collection> db.songs.save(
{
title: "Affable Balding Me",
lyricist: "Johnny Mercer",
composer: "Robert Emmett Dolan",
Year: 1950,
_key: "Affable_Balding"
}
)
{
"_id" : "songs/Affable_Balding",
"_key" : "Affable_Balding",
"_rev" : "_VjVEFMm---"
}Como ler documentos
o _keyou o identificador de documento pode ser usado para recuperar um documento. Use o identificador de documento se não houver necessidade de percorrer a coleção em si. Se você tem uma coleção, a função de documento é fácil de usar -
127.0.0.1:[email protected]_collection> db.songs.document("A_Man");
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVClbW---",
"title" : "A Man's Best Friend",
"lyricist" : "Johnny Mercer",
"composer" : "Johnny Mercer",
"Year" : 1950
}Como Atualizar Documentos
Duas opções estão disponíveis para atualizar os dados salvos - replace e update.
A função de atualização corrige um documento, fundindo-o com os atributos fornecidos. Por outro lado, a função de substituição substituirá o documento anterior por um novo. A substituição ainda ocorrerá mesmo se atributos completamente diferentes forem fornecidos. Vamos primeiro observar uma atualização não destrutiva, atualizando o atributo Production` em uma música -
127.0.0.1:[email protected]_collection> db.songs.update("songs/A_Man",{production:
"Top Banana"});Resultado
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVOcqe---",
"_oldRev" : "_VjVClbW---"
}Vamos agora ler os atributos atualizados da música -
127.0.0.1:[email protected]_collection> db.songs.document('A_Man');Resultado
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVOcqe---",
"title" : "A Man's Best Friend",
"lyricist" : "Johnny Mercer",
"composer" : "Johnny Mercer",
"Year" : 1950,
"production" : "Top Banana"
}Um grande documento pode ser facilmente atualizado com o update função, especialmente quando os atributos são muito poucos.
Em contraste, o replace função irá abolir seus dados ao usá-lo com o mesmo documento.
127.0.0.1:[email protected]_collection> db.songs.replace("songs/A_Man",{production:
"Top Banana"});Vamos agora verificar a música que acabamos de atualizar com a seguinte linha de código -
127.0.0.1:[email protected]_collection> db.songs.document('A_Man');Resultado
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVRhOq---",
"production" : "Top Banana"
}Agora, você pode observar que o documento não possui mais os dados originais.
Como Remover Documentos
A função remover é usada em combinação com o identificador de documento para remover um documento de uma coleção -
127.0.0.1:[email protected]_collection> db.songs.remove('A_Man');Vamos agora verificar os atributos da música que acabamos de remover usando a seguinte linha de código -
127.0.0.1:[email protected]_collection> db.songs.document('A_Man');Obteremos um erro de exceção como o seguinte como saída -
JavaScript exception in file
'/usr/share/arangodb3/js/client/modules/@arangodb/arangosh.js' at 97,7:
ArangoError 1202: document not found
! throw error;
! ^
stacktrace: ArangoError: document not found
at Object.exports.checkRequestResult
(/usr/share/arangodb3/js/client/modules/@arangodb/arangosh.js:95:21)
at ArangoCollection.document
(/usr/share/arangodb3/js/client/modules/@arangodb/arango-collection.js:667:12)
at <shell command>:1:10
Em nosso capítulo anterior, aprendemos como realizar várias operações em documentos com Arangosh, a linha de comando. Agora aprenderemos como realizar as mesmas operações usando a interface da web. Para começar, coloque o seguinte endereço - http: // your_server_ip: 8529 / _db / song_collection / _admin / aardvark / index.html # login na barra de endereços do seu navegador. Você será direcionado para a seguinte página de login.
Agora, digite o nome de usuário e a senha.
Se for bem-sucedido, a tela a seguir será exibida. Precisamos fazer uma escolha para o banco de dados trabalhar, o_systembanco de dados sendo o padrão. Vamos escolher osong_collection banco de dados e clique na guia verde -
Criando uma coleção
Nesta seção, aprenderemos como criar uma coleção. Pressione a guia Coleções na barra de navegação na parte superior.
Nossa coleção de músicas adicionadas à linha de comando são visíveis. Clicar nele irá mostrar as entradas. Agora vamos adicionar umartists’coleção usando a interface da web. Coleçãosongsque criamos com a Arangosh já está lá. No campo Nome, escrevaartists no New Collectioncaixa de diálogo que aparece. As opções avançadas podem ser ignoradas com segurança e o tipo de coleção padrão, ou seja, Documento, é adequado.
Clicar no botão Salvar finalmente criará a coleção e agora as duas coleções estarão visíveis nesta página.
Preenchendo a coleção recém-criada com documentos
Você verá uma coleção vazia ao clicar no artists coleção -
Para adicionar um documento, você precisa clicar no sinal + colocado no canto superior direito. Quando você for solicitado por um_key, entrar Affable_Balding como a chave.
Agora, aparecerá um formulário para adicionar e editar os atributos do documento. Existem duas maneiras de adicionar atributos:Graphical e Tree. A forma gráfica é intuitiva, mas lenta, portanto, vamos mudar para oCode visualizar, usando o menu suspenso Árvore para selecioná-lo -
Para facilitar o processo, criamos uma amostra de dados no formato JSON, que você pode copiar e colar na área do editor de consultas -
{"artista": "Johnny Mercer", "título": "Affable Balding Me", "compositor": "Robert Emmett Dolan", "Ano": 1950}
(Observação: apenas um par de chaves deve ser usado; veja a captura de tela abaixo)
Você pode observar que citamos as chaves e também os valores no modo de visualização de código. Agora cliqueSave. Após a conclusão bem-sucedida, um flash verde aparece na página momentaneamente.
Como ler documentos
Para ler documentos, volte para a página Coleções.
Quando alguém clica no artist coleção, uma nova entrada aparece.
Como Atualizar Documentos
É simples editar as entradas em um documento; você só precisa clicar na linha que deseja editar na visão geral do documento. Aqui, novamente, o mesmo editor de consulta será apresentado ao criar novos documentos.
Removendo Documentos
Você pode excluir os documentos pressionando o ícone '-'. Cada linha do documento tem este sinal no final. Ele solicitará que você confirme para evitar a exclusão insegura.
Além disso, para uma coleção particular, outras operações como filtrar os documentos, gerenciar índices e importar dados também existem no Collections Overview página.
Em nosso capítulo subsequente, discutiremos um recurso importante da interface da Web, ou seja, o editor de consultas AQL.
Neste capítulo, discutiremos como consultar os dados com AQL. Já discutimos em nossos capítulos anteriores que ArangoDB desenvolveu sua própria linguagem de consulta e que atende pelo nome de AQL.
Vamos agora começar a interagir com AQL. Conforme mostrado na imagem abaixo, na interface da web, pressione o botãoAQL Editorguia colocada na parte superior da barra de navegação. Um editor de consulta em branco aparecerá.
Quando necessário, você pode alternar para o editor a partir da visualização de resultados e vice-versa, clicando nas guias Consulta ou Resultado no canto superior direito, conforme mostrado na imagem abaixo -
Entre outras coisas, o editor possui realce de sintaxe, funcionalidade desfazer / refazer e salvar consultas. Para uma referência detalhada, pode-se ver a documentação oficial. Vamos destacar alguns recursos básicos e comumente usados do editor de consulta AQL.
Fundamentos de AQL
Em AQL, uma consulta representa o resultado final a ser alcançado, mas não o processo pelo qual o resultado final deve ser alcançado. Esse recurso é comumente conhecido como uma propriedade declarativa da linguagem. Além disso, AQL pode consultar também modificar os dados e, portanto, consultas complexas podem ser criadas combinando os dois processos.
Observe que AQL é totalmente compatível com ACID. Ler ou modificar as consultas irá concluir totalmente ou não será concluído. Até a leitura dos dados de um documento terminará com uma unidade consistente dos dados.
Nós adicionamos dois novos songspara a coleção de músicas que já criamos. Em vez de digitar, você pode copiar a consulta a seguir e colá-la no editor AQL -
FOR song IN [
{
title: "Air-Minded Executive", lyricist: "Johnny Mercer",
composer: "Bernie Hanighen", Year: 1940, _key: "Air-Minded"
},
{
title: "All Mucked Up", lyricist: "Johnny Mercer", composer:
"Andre Previn", Year: 1974, _key: "All_Mucked"
}
]
INSERT song IN songsPressione o botão Executar no canto inferior esquerdo.
Ele vai escrever dois novos documentos no songs coleção.
Esta consulta descreve como o loop FOR funciona em AQL; ele itera sobre a lista de documentos codificados em JSON, realizando as operações codificadas em cada um dos documentos da coleção. As diferentes operações podem ser criar novas estruturas, filtrar, selecionar documentos, modificar ou inserir documentos na base de dados (ver o exemplo instantâneo). Em essência, AQL pode executar as operações CRUD com eficiência.
Para encontrar todas as músicas em nosso banco de dados, vamos mais uma vez executar a seguinte consulta, equivalente a um SELECT * FROM songs de um banco de dados do tipo SQL (porque o editor memoriza a última consulta, pressione o *New* botão para limpar o editor) -
FOR song IN songs
RETURN songO conjunto de resultados mostrará a lista de músicas até agora salvas no songs coleção como mostrado na imagem abaixo.
Operações como FILTER, SORT e LIMIT pode ser adicionado ao For loop corpo para estreitar e ordenar o resultado.
FOR song IN songs
FILTER song.Year > 1940
RETURN songA consulta acima fornecerá músicas criadas após o ano de 1940 na guia Resultado (veja a imagem abaixo).
A chave do documento é usada neste exemplo, mas qualquer outro atributo também pode ser usado como um equivalente para filtragem. Como a chave do documento tem garantia de ser exclusiva, não mais do que um único documento corresponderá a esse filtro. Para outros atributos, pode não ser o caso. Para retornar um subconjunto de usuários ativos (determinado por um atributo chamado status), classificados por nome em ordem crescente, usamos a seguinte sintaxe -
FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
RETURN song
LIMIT 2Incluímos deliberadamente este exemplo. Aqui, observamos uma mensagem de erro de sintaxe de consulta destacada em vermelho pela AQL. Esta sintaxe destaca os erros e é útil para depurar suas consultas, conforme mostrado na captura de tela abaixo.
Vamos agora executar a consulta correta (observe a correção) -
FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
LIMIT 2
RETURN song
Consulta complexa em AQL
AQL é equipado com várias funções para todos os tipos de dados suportados. A atribuição de variáveis em uma consulta permite construir construções aninhadas muito complexas. Dessa forma, as operações com uso intensivo de dados se aproximam dos dados no back-end do que no cliente (como o navegador). Para entender isso, vamos primeiro adicionar as durações arbitrárias (duração) das músicas.
Vamos começar com a primeira função, ou seja, a função Atualizar -
UPDATE { _key: "All_Mucked" }
WITH { length: 180 }
IN songs
Podemos ver que um documento foi escrito conforme mostrado na imagem acima.
Vamos agora atualizar outros documentos (músicas) também.
UPDATE { _key: "Affable_Balding" }
WITH { length: 200 }
IN songsAgora podemos verificar se todas as nossas músicas têm um novo atributo length -
FOR song IN songs
RETURN songResultado
[
{
"_key": "Air-Minded",
"_id": "songs/Air-Minded",
"_rev": "_VkC5lbS---",
"title": "Air-Minded Executive",
"lyricist": "Johnny Mercer",
"composer": "Bernie Hanighen",
"Year": 1940,
"length": 210
},
{
"_key": "Affable_Balding",
"_id": "songs/Affable_Balding",
"_rev": "_VkC4eM2---",
"title": "Affable Balding Me",
"lyricist": "Johnny Mercer",
"composer": "Robert Emmett Dolan",
"Year": 1950,
"length": 200
},
{
"_key": "All_Mucked",
"_id": "songs/All_Mucked",
"_rev": "_Vjah9Pu---",
"title": "All Mucked Up",
"lyricist": "Johnny Mercer",
"composer": "Andre Previn",
"Year": 1974,
"length": 180
},
{
"_key": "Accentchuate_The",
"_id": "songs/Accentchuate_The",
"_rev": "_VkC3WzW---",
"title": "Accentchuate The Politics",
"lyricist": "Johnny Mercer",
"composer": "Harold Arlen",
"Year": 1944,
"length": 190
}
]Para ilustrar o uso de outras palavras-chave de AQL, como LET, FILTER, SORT, etc., agora formataremos as durações da música no mm:ss formato.
Inquerir
FOR song IN songs
FILTER song.length > 150
LET seconds = song.length % 60
LET minutes = FLOOR(song.length / 60)
SORT song.composer
RETURN
{
Title: song.title,
Composer: song.composer,
Duration: CONCAT_SEPARATOR(':',minutes, seconds)
}
Desta vez, retornaremos o título da música junto com a duração. oReturn função permite criar um novo objeto JSON para retornar para cada documento de entrada.
Agora falaremos sobre o recurso 'Joins' do banco de dados AQL.
Vamos começar criando uma coleção composer_dob. Além disso, criaremos os quatro documentos com a data hipotética de nascimento dos compositores executando a seguinte consulta na caixa de consulta -
FOR dob IN [
{composer: "Bernie Hanighen", Year: 1909}
,
{composer: "Robert Emmett Dolan", Year: 1922}
,
{composer: "Andre Previn", Year: 1943}
,
{composer: "Harold Arlen", Year: 1910}
]
INSERT dob in composer_dob
Para destacar a semelhança com SQL, apresentamos uma consulta FOR-loop aninhada em AQL, levando à operação REPLACE, iterando primeiro no loop interno, sobre todos os dob dos compositores e depois em todas as músicas associadas, criando um novo documento contendo atributo song_with_composer_key ao invés de song atributo.
Aqui vai a consulta -
FOR s IN songs
FOR c IN composer_dob
FILTER s.composer == c.composer
LET song_with_composer_key = MERGE(
UNSET(s, 'composer'),
{composer_key:c._key}
)
REPLACE s with song_with_composer_key IN songs
Vamos agora executar a consulta FOR song IN songs RETURN song novamente para ver como a coleção de músicas mudou.
Resultado
[
{
"_key": "Air-Minded",
"_id": "songs/Air-Minded",
"_rev": "_Vk8kFoK---",
"Year": 1940,
"composer_key": "5501",
"length": 210,
"lyricist": "Johnny Mercer",
"title": "Air-Minded Executive"
},
{
"_key": "Affable_Balding",
"_id": "songs/Affable_Balding",
"_rev": "_Vk8kFoK--_",
"Year": 1950,
"composer_key": "5505",
"length": 200,
"lyricist": "Johnny Mercer",
"title": "Affable Balding Me"
},
{
"_key": "All_Mucked",
"_id": "songs/All_Mucked",
"_rev": "_Vk8kFoK--A",
"Year": 1974,
"composer_key": "5507",
"length": 180,
"lyricist": "Johnny Mercer",
"title": "All Mucked Up"
},
{
"_key": "Accentchuate_The",
"_id": "songs/Accentchuate_The",
"_rev": "_Vk8kFoK--B",
"Year": 1944,
"composer_key": "5509",
"length": 190,
"lyricist": "Johnny Mercer",
"title": "Accentchuate The Politics"
}
]A consulta acima completa o processo de migração de dados, adicionando o composer_key para cada música.
Agora, a próxima consulta é novamente uma consulta FOR-loop aninhada, mas desta vez levando à operação Join, adicionando o nome do compositor associado (escolhendo com a ajuda de `composer_key`) para cada música -
FOR s IN songs
FOR c IN composer_dob
FILTER c._key == s.composer_key
RETURN MERGE(s,
{ composer: c.composer }
)Resultado
[
{
"Year": 1940,
"_id": "songs/Air-Minded",
"_key": "Air-Minded",
"_rev": "_Vk8kFoK---",
"composer_key": "5501",
"length": 210,
"lyricist": "Johnny Mercer",
"title": "Air-Minded Executive",
"composer": "Bernie Hanighen"
},
{
"Year": 1950,
"_id": "songs/Affable_Balding",
"_key": "Affable_Balding",
"_rev": "_Vk8kFoK--_",
"composer_key": "5505",
"length": 200,
"lyricist": "Johnny Mercer",
"title": "Affable Balding Me",
"composer": "Robert Emmett Dolan"
},
{
"Year": 1974,
"_id": "songs/All_Mucked",
"_key": "All_Mucked",
"_rev": "_Vk8kFoK--A",
"composer_key": "5507",
"length": 180,
"lyricist": "Johnny Mercer",
"title": "All Mucked Up",
"composer": "Andre Previn"
},
{
"Year": 1944,
"_id": "songs/Accentchuate_The",
"_key": "Accentchuate_The",
"_rev": "_Vk8kFoK--B",
"composer_key": "5509",
"length": 190,
"lyricist": "Johnny Mercer",
"title": "Accentchuate The Politics",
"composer": "Harold Arlen"
}
]
Neste capítulo, consideraremos alguns exemplos de consultas de AQL em um Actors and MoviesBase de dados. Essas consultas são baseadas em gráficos.
Problema
Dada uma coleção de atores e uma coleção de filmes, e uma coleção de bordas actIn (com uma propriedade de ano) para conectar o vértice conforme indicado abaixo -
[Actor] <- act in -> [Movie]
Como podemos obter -
- Todos os atores que atuaram em "movie1" OU "movie2"?
- Todos os atores que atuaram em "movie1" E "movie2"?
- Todos os filmes comuns entre "ator1" e "ator2"?
- Todos os atores que atuaram em 3 ou mais filmes?
- Todos os filmes em que exatamente 6 atores atuaram?
- O número de atores por filme?
- O número de filmes por ator?
- A quantidade de filmes atuados entre 2005 e 2010 por ator?
Solução
Durante o processo de resolução e obtenção das respostas às consultas acima, usaremos Arangosh para criar o conjunto de dados e executar consultas sobre ele. Todas as consultas AQL são strings e podem simplesmente ser copiadas para o seu driver favorito em vez do Arangosh.
Vamos começar criando um conjunto de dados de teste na Arangosh. Primeiro, baixe este arquivo -
# wget -O dataset.js
https://drive.google.com/file/d/0B4WLtBDZu_QWMWZYZ3pYMEdqajA/view?usp=sharingResultado
...
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]
Saving to: ‘dataset.js’
dataset.js [ <=> ] 115.14K --.-KB/s in 0.01s
2017-09-17 14:19:12 (11.1 MB/s) - ‘dataset.js’ saved [117907]Você pode ver na saída acima que baixamos um arquivo JavaScript dataset.js.Este arquivo contém os comandos Arangosh para criar o conjunto de dados no banco de dados. Em vez de copiar e colar os comandos um por um, usaremos o--javascript.executeopção no Arangosh para executar os vários comandos de forma não interativa. Considere isso o comando salva-vidas!
Agora execute o seguinte comando no shell -
$ arangosh --javascript.execute dataset.js
Forneça a senha quando solicitado, como você pode ver na imagem acima. Agora que salvamos os dados, construiremos as consultas AQL para responder às questões específicas levantadas no início deste capítulo.
Primeira pergunta
Deixe-nos responder à primeira pergunta: All actors who acted in "movie1" OR "movie2". Suponha que queremos encontrar os nomes de todos os atores que atuaram em "TheMatrix" OU "TheDevilsAdvocate" -
Começaremos com um filme de cada vez para obter os nomes dos atores -
127.0.0.1:[email protected]_system> db._query("FOR x IN ANY 'movies/TheMatrix' actsIn
OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN x._id").toArray();Resultado
Receberemos a seguinte saída -
[
"actors/Hugo",
"actors/Emil",
"actors/Carrie",
"actors/Keanu",
"actors/Laurence"
]
Agora continuamos a formar um UNION_DISTINCT de duas consultas NEIGHBORS que serão a solução -
127.0.0.1:[email protected]_system> db._query("FOR x IN UNION_DISTINCT ((FOR y IN ANY
'movies/TheMatrix' actsIn OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN
y._id), (FOR y IN ANY 'movies/TheDevilsAdvocate' actsIn OPTIONS {bfs: true,
uniqueVertices: 'global'} RETURN y._id)) RETURN x").toArray();Resultado
[
"actors/Charlize",
"actors/Al",
"actors/Laurence",
"actors/Keanu",
"actors/Carrie",
"actors/Emil",
"actors/Hugo"
]
Segunda questão
Vamos agora considerar a segunda questão: All actors who acted in both "movie1" AND "movie2". Isso é quase idêntico à pergunta acima. Mas desta vez não estamos interessados em uma UNIÃO, mas sim em uma INTERSECÇÃO -
127.0.0.1:[email protected]_system> db._query("FOR x IN INTERSECTION ((FOR y IN ANY
'movies/TheMatrix' actsIn OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN
y._id), (FOR y IN ANY 'movies/TheDevilsAdvocate' actsIn OPTIONS {bfs: true,
uniqueVertices: 'global'} RETURN y._id)) RETURN x").toArray();Resultado
Receberemos a seguinte saída -
[
"actors/Keanu"
]
Terceira pergunta
Vamos agora considerar a terceira questão: All common movies between "actor1" and "actor2". Na verdade, isso é idêntico à pergunta sobre atores comuns em movie1 e movie2. Só temos que mudar os vértices iniciais. Como exemplo, vamos encontrar todos os filmes em que Hugo Weaving ("Hugo") e Keanu Reeves estão co-estrelando -
127.0.0.1:[email protected]_system> db._query(
"FOR x IN INTERSECTION (
(
FOR y IN ANY 'actors/Hugo' actsIn OPTIONS
{bfs: true, uniqueVertices: 'global'}
RETURN y._id
),
(
FOR y IN ANY 'actors/Keanu' actsIn OPTIONS
{bfs: true, uniqueVertices:'global'} RETURN y._id
)
)
RETURN x").toArray();Resultado
Receberemos a seguinte saída -
[
"movies/TheMatrixReloaded",
"movies/TheMatrixRevolutions",
"movies/TheMatrix"
]
Quarta Pergunta
Vamos agora considerar a quarta questão. All actors who acted in 3 or more movies. Essa questão é diferente; não podemos fazer uso da função de vizinhos aqui. Em vez disso, faremos uso do índice de borda e da instrução COLLECT de AQL para agrupamento. A ideia básica é agrupar todas as arestas por seusstartVertex(que neste conjunto de dados é sempre o ator). Em seguida, removemos todos os atores com menos de 3 filmes do resultado, pois aqui incluímos o número de filmes em que um ator atuou -
127.0.0.1:[email protected]_system> db._query("FOR x IN actsIn COLLECT actor = x._from WITH
COUNT INTO counter FILTER counter >= 3 RETURN {actor: actor, movies:
counter}"). toArray()Resultado
[
{
"actor" : "actors/Carrie",
"movies" : 3
},
{
"actor" : "actors/CubaG",
"movies" : 4
},
{
"actor" : "actors/Hugo",
"movies" : 3
},
{
"actor" : "actors/Keanu",
"movies" : 4
},
{
"actor" : "actors/Laurence",
"movies" : 3
},
{
"actor" : "actors/MegR",
"movies" : 5
},
{
"actor" : "actors/TomC",
"movies" : 3
},
{
"actor" : "actors/TomH",
"movies" : 3
}
]
Para as questões restantes, discutiremos a formação da consulta e forneceremos apenas as consultas. O leitor deve executar a consulta por conta própria no terminal Arangosh.
Quinta pergunta
Vamos agora considerar a quinta questão: All movies where exactly 6 actors acted in. A mesma ideia da consulta anterior, mas com o filtro de igualdade. No entanto, agora precisamos do filme em vez do ator, então retornamos o_to attribute -
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter FILTER
counter == 6 RETURN movie").toArray()O número de atores por filme?
Lembramos em nosso conjunto de dados _to na borda corresponde ao filme, então contamos quantas vezes o mesmo _toparece. Este é o número de atores. A consulta é quase idêntica às anteriores, maswithout the FILTER after COLLECT -
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter RETURN
{movie: movie, actors: counter}").toArray()Sexta Questão
Vamos agora considerar a sexta questão: The number of movies by an actor.
A maneira como encontramos soluções para nossas dúvidas acima o ajudará a encontrar a solução para essa consulta também.
db._query("FOR x IN actsIn COLLECT actor = x._from WITH COUNT INTO counter
RETURN {actor: actor, movies: counter}").toArray()Neste capítulo, descreveremos várias possibilidades para implantar o ArangoDB.
Implantação: instância única
Já aprendemos como implantar a única instância do Linux (Ubuntu) em um de nossos capítulos anteriores. Vamos agora ver como fazer a implantação usando o Docker.
Implantação: Docker
Para implantação usando docker, vamos instalar o Docker em nossa máquina. Para obter mais informações sobre o Docker, consulte nosso tutorial sobre o Docker .
Depois que o Docker estiver instalado, você pode usar o seguinte comando -
docker run -e ARANGO_RANDOM_ROOT_PASSWORD = 1 -d --name agdb-foo -d
arangodb/arangodbEle criará e iniciará a instância Docker de ArangoDB com o nome de identificação agdbfoo como um processo em segundo plano do Docker.
Também o terminal imprimirá o identificador do processo.
Por padrão, a porta 8529 é reservada para ArangoDB escutar os pedidos. Além disso, essa porta está automaticamente disponível para todos os contêineres de aplicativos Docker que você possa ter vinculado.