ArangoDB - Guide rapide

ArangoDB est salué comme une base de données multi-modèle native par ses développeurs. Ceci est différent des autres bases de données NoSQL. Dans cette base de données, les données peuvent être stockées sous forme de documents, de paires clé / valeur ou de graphiques. Et avec un seul langage de requête déclaratif, vous pouvez accéder à tout ou partie de vos données. De plus, différents modèles peuvent être combinés dans une seule requête. Et, en raison de son style multi-modèle, on peut créer des applications allégées, qui seront évolutives horizontalement avec l'un ou l'ensemble des trois modèles de données.

Bases de données multi-modèles en couches et natives

Dans cette section, nous mettrons en évidence une différence cruciale entre les bases de données multimodèles natives et multicouches.

De nombreux fournisseurs de bases de données appellent leur produit «multi-modèle», mais l'ajout d'une couche de graphes à une clé / valeur ou à un magasin de documents ne constitue pas un multi-modèle natif.

Avec ArangoDB, le même noyau avec le même langage de requête, on peut regrouper différents modèles de données et fonctionnalités dans une seule requête, comme nous l'avons déjà indiqué dans la section précédente. Dans ArangoDB, il n'y a pas de «basculement» entre les modèles de données, et il n'y a pas de déplacement des données de A vers B pour exécuter des requêtes. Cela conduit à des avantages de performances pour ArangoDB par rapport aux approches «en couches».

Le besoin d'une base de données multimodale

L'interprétation de l'idée de base [de Fowler] nous amène à réaliser les avantages de l'utilisation d'une variété de modèles de données appropriés pour différentes parties de la couche de persistance, la couche faisant partie de l'architecture logicielle plus large.

Selon cela, on pourrait, par exemple, utiliser une base de données relationnelle pour conserver des données tabulaires structurées; un magasin de documents pour les données non structurées de type objet; un magasin clé / valeur pour une table de hachage; et une base de données de graphiques pour des données référentielles hautement liées.

Cependant, la mise en œuvre traditionnelle de cette approche conduira à utiliser plusieurs bases de données dans le même projet. Cela peut entraîner des frictions opérationnelles (déploiement plus compliqué, mises à niveau plus fréquentes) ainsi que des problèmes de cohérence et de duplication des données.

Le prochain défi après l'unification des données pour les trois modèles de données est de concevoir et d'implémenter un langage de requête commun qui peut permettre aux administrateurs de données d'exprimer une variété de requêtes, telles que des requêtes de document, des recherches clé / valeur, des requêtes graphiques et des combinaisons arbitraires. de ceux-ci.

Par graphy queries, nous entendons des requêtes impliquant des considérations de théorie des graphes. En particulier, ceux-ci peuvent impliquer les caractéristiques de connectivité particulières provenant des bords. Par exemple,ShortestPath, GraphTraversal, et Neighbors.

Les graphiques sont un ajustement parfait en tant que modèle de données pour les relations. Dans de nombreux cas réels tels que les réseaux sociaux, les systèmes de recommandation, etc., un modèle de données très naturel est un graphique. Il capture les relations et peut contenir des informations d'étiquette avec chaque arête et avec chaque sommet. De plus, les documents JSON conviennent naturellement pour stocker ce type de données de sommet et d'arête.

ArangoDB ─ Caractéristiques

Il existe diverses fonctionnalités notables d'ArangoDB. Nous soulignerons les caractéristiques importantes ci-dessous -

• Paradigme multimodèle
• Propriétés ACID
• API HTTP

ArangoDB prend en charge tous les modèles de base de données courants. Voici quelques modèles pris en charge par ArangoDB -

• Modèle de document
• Modèle clé / valeur
• Modèle graphique

Un seul langage de requête suffit pour récupérer des données hors de la base de données

Les quatre propriétés Atomicity, Consistency, Isolation, et Durability(ACID) décrivent les garanties des transactions de base de données. ArangoDB prend en charge les transactions conformes à ACID.

ArangoDB permet aux clients, tels que les navigateurs, d'interagir avec la base de données avec l'API HTTP, l'API étant orientée ressources et extensible avec JavaScript.

Voici les avantages de l'utilisation d'ArangoDB -

Consolidation

En tant que base de données multi-modèle native, ArangoDB élimine le besoin de déployer plusieurs bases de données, et diminue ainsi le nombre de composants et leur maintenance. Par conséquent, cela réduit la complexité de la pile technologique pour l'application. En plus de consolider vos besoins techniques globaux, cette simplification permet de réduire le coût total de possession et d'augmenter la flexibilité.

Évolutivité simplifiée des performances

Avec la croissance des applications au fil du temps, ArangoDB peut répondre aux besoins croissants de performances et de stockage, en évoluant indépendamment avec différents modèles de données. Comme ArangoDB peut évoluer à la fois verticalement et horizontalement, donc dans le cas où vos performances exigent une diminution (un ralentissement délibéré et souhaité), votre système back-end peut être facilement réduit pour économiser du matériel ainsi que des coûts opérationnels.

Complexité opérationnelle réduite

Le décret de Polyglot Persistence est d'utiliser les meilleurs outils pour chaque travail que vous entreprenez. Certaines tâches nécessitent une base de données de documents, tandis que d'autres peuvent nécessiter une base de données de graphiques. En raison du travail avec des bases de données à modèle unique, cela peut entraîner de multiples défis opérationnels. L'intégration de bases de données à modèle unique est une tâche difficile en soi. Mais le plus grand défi est de construire une grande structure cohésive avec une cohérence des données et une tolérance aux pannes entre des systèmes de bases de données séparés et indépendants. Cela peut s'avérer presque impossible.

Polyglot Persistence peut être géré avec une base de données multi-modèle native, car il permet d'avoir des données polyglottes facilement, mais en même temps avec la cohérence des données sur un système tolérant aux pannes. Avec ArangoDB, nous pouvons utiliser le bon modèle de données pour le travail complexe.

Forte cohérence des données

Si l'on utilise plusieurs bases de données à modèle unique, la cohérence des données peut devenir un problème. Ces bases de données ne sont pas conçues pour communiquer entre elles, par conséquent, une certaine forme de fonctionnalité de transaction doit être implémentée pour maintenir la cohérence de vos données entre les différents modèles.

Prenant en charge les transactions ACID, ArangoDB gère vos différents modèles de données avec un seul back-end, offrant une forte cohérence sur une seule instance et des opérations atomiques en mode cluster.

Tolérance aux pannes

C'est un défi de construire des systèmes tolérants aux pannes avec de nombreux composants non liés. Ce défi devient plus complexe lorsque vous travaillez avec des clusters. Une expertise est requise pour déployer et maintenir de tels systèmes, en utilisant différentes technologies et / ou piles technologiques. De plus, l'intégration de plusieurs sous-systèmes, conçus pour fonctionner de manière indépendante, entraîne des coûts d'ingénierie et d'exploitation importants.

En tant que pile technologique consolidée, la base de données multimodèle présente une solution élégante. Conçu pour permettre des architectures modernes et modulaires avec différents modèles de données, ArangoDB fonctionne également pour une utilisation en cluster.

Coût total de possession réduit

Chaque technologie de base de données nécessite une maintenance continue, des correctifs de correction de bogues et d'autres modifications de code fournies par le fournisseur. L'adoption d'une base de données multimodèle réduit considérablement les coûts de maintenance associés simplement en éliminant le nombre de technologies de base de données lors de la conception d'une application.

Transactions

Fournir des garanties transactionnelles sur plusieurs machines est un véritable défi, et peu de bases de données NoSQL offrent ces garanties. Étant multi-modèle natif, ArangoDB impose des transactions pour garantir la cohérence des données.

Dans ce chapitre, nous discuterons des concepts de base et des terminologies pour ArangoDB. Il est très important d'avoir une connaissance des terminologies de base sous-jacentes liées au sujet technique que nous traitons.

Les terminologies pour ArangoDB sont répertoriées ci-dessous -

• Document
• Collection
• Identifiant de la collection
• Nom de la collection
• Database
• Nom de la base de données
• Organisation de la base de données

Du point de vue du modèle de données, ArangoDB peut être considéré comme une base de données orientée document, la notion de document étant l'idée mathématique de cette dernière. Les bases de données orientées document sont l'une des principales catégories de bases de données NoSQL.

La hiérarchie est la suivante: les documents sont regroupés en collections et les collections existent dans les bases de données

Il devrait être évident que l'identificateur et le nom sont deux attributs de la collection et de la base de données.

Habituellement, deux documents (sommets) stockés dans des collections de documents sont liés par un document (bord) stocké dans une collection Edge. Il s'agit du modèle de données graphiques d'ArangoDB. Il suit le concept mathématique d'un graphe orienté et étiqueté, sauf que les arêtes n'ont pas seulement des étiquettes, mais sont des documents à part entière.

Une fois familiarisés avec les termes de base de cette base de données, nous commençons à comprendre le modèle de données graphiques d'ArangoDB. Dans ce modèle, il existe deux types de collections: les collections de documents et les collections de périphérie. Les collections Edge stockent des documents et incluent également deux attributs spéciaux: le premier est le_from attribut, et le second est le _toattribut. Ces attributs sont utilisés pour créer des arêtes (relations) entre les documents essentiels pour la base de données de graphes. Les collections de documents sont également appelées collections de sommets dans le contexte des graphes (voir n'importe quel livre de théorie des graphes).

Voyons maintenant à quel point les bases de données sont importantes. Ils sont importants car des collections existent dans les bases de données. Dans une instance d'ArangoDB, il peut y avoir une ou plusieurs bases de données. Différentes bases de données sont généralement utilisées pour les configurations multi-locataires, car les différents ensembles de données qu'elles contiennent (collections, documents, etc.) sont isolés les uns des autres. La base de données par défaut_systemest spécial, car il ne peut pas être supprimé. Les utilisateurs sont gérés dans cette base de données et leurs informations d'identification sont valides pour toutes les bases de données d'une instance de serveur.

Dans ce chapitre, nous discuterons de la configuration système requise pour ArangoDB.

La configuration système requise pour ArangoDB est la suivante -

• Un serveur VPS avec une installation Ubuntu
• RAM: 1 Go; Processeur: 2,2 GHz

Pour toutes les commandes de ce tutoriel, nous avons utilisé une instance d'Ubuntu 16.04 (xenial) de RAM 1 Go avec un processeur ayant une puissance de traitement de 2,2 GHz. Et toutes les commandes arangosh de ce didacticiel ont été testées pour la version 3.1.27 d'ArangoDB.

Comment installer ArangoDB?

Dans cette section, nous verrons comment installer ArangoDB. ArangoDB est pré-construit pour de nombreux systèmes d'exploitation et distributions. Pour plus de détails, veuillez vous référer à la documentation ArangoDB. Comme déjà mentionné, pour ce tutoriel, nous utiliserons Ubuntu 16.04x64.

La première étape consiste à télécharger la clé publique de ses référentiels -

# wget https://www.arangodb.com/repositories/arangodb31/
xUbuntu_16.04/Release.key

Production

--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]

Le point important est que vous devriez voir le Release.key enregistré à la fin de la sortie.

Laissez-nous installer la clé enregistrée en utilisant la ligne de code suivante -

# sudo apt-key add Release.key

Production

OK

Exécutez les commandes suivantes pour ajouter le référentiel apt et mettre à jour l'index -

# sudo apt-add-repository 'deb
https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/ /'
# sudo apt-get update

Comme dernière étape, nous pouvons installer ArangoDB -

# sudo apt-get install arangodb3

Production

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.

presse Enter. Maintenant, le processus d'installation d'ArangoDB va commencer -

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.

Lorsque l'installation d'ArangoDB est sur le point de se terminer, l'écran suivant apparaît -

Ici, il vous sera demandé de fournir un mot de passe pour ArangoDB rootutilisateur. Notez-le attentivement.

Sélectionnez le yes option lorsque la boîte de dialogue suivante apparaît -

Lorsque vous cliquez Yescomme dans la boîte de dialogue ci-dessus, la boîte de dialogue suivante apparaît. Cliquez surYes ici.

Vous pouvez également vérifier l'état d'ArangoDB avec la commande suivante -

# sudo systemctl status arangodb3

Production

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 est maintenant prêt à être utilisé.

Pour appeler le terminal arangosh, tapez la commande suivante dans le terminal -

# arangosh

Production

Please specify a password:

Fournir le root mot de passe créé au moment de l'installation -

_
__ _ _ __ __ _ _ __ __ _ ___ | |
/ | '__/ _ | ’ \ / ` |/ _ / | ’
| (| | | | (| | | | | (| | () _ \ | | |
_,|| _,|| ||_, |_/|/| ||
|__/

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

Pour vous déconnecter d'ArangoDB, tapez la commande suivante -

127.0.0.1:[email protected]_system> exit

Production

Uf wiederluege! Na shledanou! Auf Wiedersehen! Bye Bye! Adiau! ¡Hasta luego!
Εις το επανιδείν!

להתראות ! Arrivederci! Tot ziens! Adjö! Au revoir! さようなら До свидания! Até
Breve! !خداحافظ

Dans ce chapitre, nous verrons comment Arangosh fonctionne comme ligne de commande pour ArangoDB. Nous allons commencer par apprendre à ajouter un utilisateur de base de données.

Note - N'oubliez pas que le pavé numérique peut ne pas fonctionner sur Arangosh.

Supposons que l'utilisateur soit «harry» et que le mot de passe soit «hpwdb».

127.0.0.1:[email protected]_system> require("org/arangodb/users").save("harry", "hpwdb");

Production

{
   "user" : "harry",
   "active" : true,
   "extra" : {},
   "changePassword" : false,
   "code" : 201
}

Dans ce chapitre, nous apprendrons comment activer / désactiver l'authentification et comment lier ArangoDB à l'interface réseau publique.

# arangosh --server.endpoint tcp://127.0.0.1:8529 --server.database "_system"

Il vous demandera le mot de passe enregistré plus tôt -

Please specify a password:

Utilisez le mot de passe que vous avez créé pour root, lors de la configuration.

Vous pouvez également utiliser curl pour vérifier que vous obtenez réellement des réponses de serveur HTTP 401 (non autorisées) pour les demandes nécessitant une authentification -

# curl --dump - http://127.0.0.1:8529/_api/version

Production

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: 0

Pour éviter d'entrer le mot de passe à chaque fois pendant notre processus d'apprentissage, nous désactiverons l'authentification. Pour cela, ouvrez le fichier de configuration -

# vim /etc/arangodb3/arangod.conf

Vous devez changer le jeu de couleurs si le code n'est pas correctement visible.

:colorscheme desert

Définissez l'authentification sur false comme indiqué dans la capture d'écran ci-dessous.

Redémarrez le service -

# service arangodb3 restart

En rendant l'authentification fausse, vous pourrez vous connecter (soit avec un utilisateur root ou créé comme Harry dans ce cas) sans saisir de mot de passe dans please specify a password.

Laissez-nous vérifier api version lorsque l'authentification est désactivée -

# curl --dump - http://127.0.0.1:8529/_api/version

Production

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"}

Dans ce chapitre, nous examinerons deux exemples de scénarios. Ces exemples sont plus faciles à comprendre et nous aideront à comprendre le fonctionnement de la fonctionnalité ArangoDB.

Pour démontrer les API, ArangoDB est préchargé avec un ensemble de graphiques facilement compréhensibles. Il existe deux méthodes pour créer des instances de ces graphiques dans votre ArangoDB -

• Ajouter l'onglet Exemple dans la fenêtre de création de graphique de l'interface Web,
• ou charger le module @arangodb/graph-examples/example-graph à Arangosh.

Pour commencer, chargeons un graphique à l'aide de l'interface Web. Pour cela, lancez l'interface web et cliquez sur le boutongraphs languette.

le Create Graphla boîte de dialogue apparaît. L'assistant contient deux onglets -Examples et Graph. leGraphl'onglet est ouvert par défaut; en supposant que nous voulions créer un nouveau graphe, il demandera le nom et d'autres définitions pour le graphe.

Maintenant, nous allons télécharger le graphique déjà créé. Pour cela, nous sélectionnerons leExamples languette.

Nous pouvons voir les trois graphiques d'exemple. Sélectionnez leKnows_Graph et cliquez sur le bouton vert Créer.

Une fois que vous les avez créés, vous pouvez les inspecter dans l'interface Web - qui a été utilisée pour créer les images ci-dessous.

Le Knows_Graph

Voyons maintenant comment le Knows_Graphtravaux. Sélectionnez le Knows_Graph et il récupérera les données du graphique.

Le Knows_Graph se compose d'une collection de sommets persons connecté via une collection de bord knows. Il contiendra cinq personnes Alice, Bob, Charlie, Dave et Eve comme sommets. Nous aurons les relations dirigées suivantes

Alice knows Bob
Bob knows Charlie
Bob knows Dave
Eve knows Alice
Eve knows Bob

Si vous cliquez sur un nœud (sommet), dites «bob», il affichera le nom de l'attribut ID (personnes / bob).

Et en cliquant sur l'un des bords, il affichera les attributs ID (know / 4590).

C'est ainsi que nous le créons, inspectons ses sommets et ses arêtes.

Ajoutons un autre graphe, cette fois en utilisant Arangosh. Pour cela, nous devons inclure un autre point de terminaison dans le fichier de configuration ArangoDB.

Comment ajouter plusieurs points de terminaison

Ouvrez le fichier de configuration -

# vim /etc/arangodb3/arangod.conf

Ajoutez un autre point de terminaison comme indiqué dans la capture d'écran du terminal ci-dessous.

Redémarrez ArangoDB -

# service arangodb3 restart

Lancez l'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>

Le Social_Graph

Voyons maintenant ce qu'est un Social_Graph et comment il fonctionne. Le graphique montre un ensemble de personnes et leurs relations -

Cet exemple a des personnes féminines et masculines comme sommets dans deux collections de sommets - femme et homme. Les arêtes sont leurs connexions dans la collection d'arêtes de relation. Nous avons décrit comment créer ce graphique en utilisant Arangosh. Le lecteur peut contourner ce problème et explorer ses attributs, comme nous l'avons fait avec le Knows_Graph.

Dans ce chapitre, nous nous concentrerons sur les sujets suivants -

• Interaction avec la base de données
• Modèle de données
• Récupération de données

ArangoDB prend en charge le modèle de données basé sur un document ainsi que le modèle de données basé sur un graphique. Décrivons d'abord le modèle de données basé sur un document.

Les documents d'ArangoDB ressemblent étroitement au format JSON. Aucun ou plusieurs attributs sont contenus dans un document et une valeur est associée à chaque attribut. Une valeur est soit d'un type atomique, tel qu'un nombre, booléen ou nul, une chaîne littérale, soit d'un type de données composé, tel qu'un document / objet incorporé ou un tableau. Les tableaux ou sous-objets peuvent être constitués de ces types de données, ce qui implique qu'un seul document peut représenter des structures de données non triviales.

Plus loin dans la hiérarchie, les documents sont organisés en collections, qui peuvent ne contenir aucun document (en théorie) ou plus d'un document. On peut comparer des documents à des lignes et des collections à des tables (ici, les tableaux et les lignes font référence à ceux des systèmes de gestion de bases de données relationnelles - SGBDR).

Mais, dans le SGBDR, la définition de colonnes est une condition préalable pour stocker des enregistrements dans une table, en appelant ces schémas de définitions. Cependant, en tant que nouvelle fonctionnalité, ArangoDB est sans schéma - il n'y a aucune raison a priori de spécifier les attributs que le document aura.

Et contrairement au SGBDR, chaque document peut être structuré d'une manière complètement différente d'un autre document. Ces documents peuvent être enregistrés ensemble dans une seule collection. En pratique, des caractéristiques communes peuvent exister parmi les documents de la collection, mais le système de base de données, c'est-à-dire ArangoDB lui-même, ne vous lie pas à une structure de données particulière.

Nous allons maintenant essayer de comprendre ArangoDB [graph data model], qui nécessite deux types de collections - la première est les collections de documents (appelées collections de sommets dans le langage de la théorie des groupes), la seconde est les collections de bord. Il existe une différence subtile entre ces deux types. Les collections Edge stockent également des documents, mais elles se caractérisent par l'inclusion de deux attributs uniques,_from et _topour créer des relations entre documents. En pratique, un document (bord de lecture) relie deux documents (sommets de lecture), tous deux stockés dans leurs collections respectives. Cette architecture est dérivée du concept théorique des graphes d'un graphe orienté étiqueté, excluant les arêtes qui peuvent non seulement avoir des étiquettes, mais peuvent être un document JSON complet en soi.

Pour calculer des données fraîches, supprimer des documents ou les manipuler, des requêtes sont utilisées, qui sélectionnent ou filtrent les documents selon les critères donnés. Qu'elles soient simples comme une «requête d'exemple» ou soient aussi complexes que des «jointures», les requêtes sont codées en AQL - ArangoDB Query Language.

Dans ce chapitre, nous discuterons des différentes méthodes de base de données dans ArangoDB.

Pour commencer, obtenons les propriétés de la base de données -

• Name
• ID
• Path

Tout d'abord, nous invoquons l'Arangosh. Une fois, Arangosh est invoqué, nous listerons les bases de données que nous avons créées jusqu'à présent -

Nous utiliserons la ligne de code suivante pour invoquer Arangosh -

127.0.0.1:[email protected]_system> db._databases()

Production

[
   "_system",
   "song_collection"
]

Nous voyons deux bases de données, une _system créé par défaut, et le second song_collection que nous avons créé.

Passons maintenant à la base de données song_collection avec la ligne de code suivante -

127.0.0.1:[email protected]_system> db._useDatabase("song_collection")

Production

true
127.0.0.1:[email protected]_collection>

Nous explorerons les propriétés de notre base de données song_collection.

Pour trouver le nom

Nous utiliserons la ligne de code suivante pour trouver le nom.

127.0.0.1:[email protected]_collection> db._name()

Production

song_collection

Pour trouver l'identifiant -

Nous utiliserons la ligne de code suivante pour trouver l'identifiant.

song_collection

Production

4838

Pour trouver le chemin -

Nous utiliserons la ligne de code suivante pour trouver le chemin.

127.0.0.1:[email protected]_collection> db._path()

Production

/var/lib/arangodb3/databases/database-4838

Vérifions maintenant si nous sommes dans la base de données système ou non en utilisant la ligne de code suivante -

127.0.0.1:[email protected]_collection&t; db._isSystem()

Production

false

Cela signifie que nous ne sommes pas dans la base de données système (comme nous l'avons créé et déplacé vers la song_collection). La capture d'écran suivante vous aidera à comprendre cela.

Pour obtenir une collection particulière, dites chansons -

Nous utiliserons la ligne de code suivante pour obtenir une collection particulière.

127.0.0.1:[email protected]_collection> db._collection("songs")

Production

[ArangoCollection 4890, "songs" (type document, status loaded)]

La ligne de code renvoie une seule collection.

Passons à l'essentiel des opérations de base de données avec nos chapitres suivants.

Dans ce chapitre, nous allons apprendre les différentes opérations avec Arangosh.

Voici les opérations possibles avec Arangosh -

• Créer une collection de documents
• Création de documents
• Lecture de documents
• Mise à jour des documents

Commençons par créer une nouvelle base de données. Nous utiliserons la ligne de code suivante pour créer une nouvelle base de données -

127.0.0.1:[email protected]_system> db._createDatabase("song_collection")
true

La ligne de code suivante vous aidera à passer à la nouvelle base de données -

127.0.0.1:[email protected]_system> db._useDatabase("song_collection")
true

L'invite passera à "@@ song_collection"

127.0.0.1:[email protected]_collection>

De là, nous étudierons les opérations CRUD. Créons une collection dans la nouvelle base de données -

127.0.0.1:[email protected]_collection> db._createDocumentCollection('songs')

Production

[ArangoCollection 4890, "songs" (type document, status loaded)]
127.0.0.1:[email protected]_collection>

Ajoutons quelques documents (objets JSON) à notre collection «chansons».

Nous ajoutons le premier document de la manière suivante -

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"})

Production

{
   "_id" : "songs/A_Man",
   "_key" : "A_Man",
   "_rev" : "_VjVClbW---"
}

Ajoutons d'autres documents à la base de données. Cela nous aidera à apprendre le processus d'interrogation des données. Vous pouvez copier ces codes et les coller dans Arangosh pour émuler le processus -

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---"
}

Comment lire des documents

le _keyou le descripteur de document peut être utilisé pour récupérer un document. Utilisez le descripteur de document s'il n'est pas nécessaire de parcourir la collection elle-même. Si vous avez une collection, la fonction de document est facile à utiliser -

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
}

Comment mettre à jour des documents

Deux options sont disponibles pour mettre à jour les données enregistrées - replace et update.

La fonction de mise à jour corrige un document en le fusionnant avec les attributs donnés. En revanche, la fonction de remplacement remplacera le document précédent par un nouveau. Le remplacement se produira toujours même si des attributs complètement différents sont fournis. Nous allons d'abord observer une mise à jour non destructive, mettant à jour l'attribut Production` dans une chanson -

127.0.0.1:[email protected]_collection> db.songs.update("songs/A_Man",{production:
"Top Banana"});

Production

{
   "_id" : "songs/A_Man",
   "_key" : "A_Man",
   "_rev" : "_VjVOcqe---",
   "_oldRev" : "_VjVClbW---"
}

Lisons maintenant les attributs de la chanson mise à jour -

127.0.0.1:[email protected]_collection> db.songs.document('A_Man');

Production

{
   "_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"
}

Un document volumineux peut être facilement mis à jour avec le update fonction, surtout lorsque les attributs sont très peu nombreux.

En revanche, le replace La fonction supprimera vos données en l'utilisant avec le même document.

127.0.0.1:[email protected]_collection> db.songs.replace("songs/A_Man",{production:
"Top Banana"});

Voyons maintenant la chanson que nous venons de mettre à jour avec la ligne de code suivante -

127.0.0.1:[email protected]_collection> db.songs.document('A_Man');

Production

{
   "_key" : "A_Man",
   "_id" : "songs/A_Man",
   "_rev" : "_VjVRhOq---",
   "production" : "Top Banana"
}

Maintenant, vous pouvez observer que le document ne contient plus les données d'origine.

Comment supprimer des documents

La fonction remove est utilisée en combinaison avec le descripteur de document pour supprimer un document d'une collection -

127.0.0.1:[email protected]_collection> db.songs.remove('A_Man');

Vérifions maintenant les attributs de la chanson que nous venons de supprimer en utilisant la ligne de code suivante -

127.0.0.1:[email protected]_collection> db.songs.document('A_Man');

Nous obtiendrons une erreur d'exception comme la suivante en sortie -

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

Dans notre chapitre précédent, nous avons appris à effectuer diverses opérations sur des documents avec Arangosh, la ligne de commande. Nous allons maintenant apprendre à effectuer les mêmes opérations à l'aide de l'interface Web. Pour commencer, mettez l'adresse suivante - http: // your_server_ip: 8529 / _db / song_collection / _admin / aardvark / index.html # login dans la barre d'adresse de votre navigateur. Vous serez dirigé vers la page de connexion suivante.

Maintenant, entrez le nom d'utilisateur et le mot de passe.

S'il réussit, l'écran suivant apparaît. Nous devons faire un choix pour la base de données sur laquelle travailler, le_systemla base de données étant celle par défaut. Laissez-nous choisir lesong_collection base de données, et cliquez sur l'onglet vert -

Créer une collection

Dans cette section, nous allons apprendre à créer une collection. Appuyez sur l'onglet Collections dans la barre de navigation en haut.

Notre collection de chansons ajoutées en ligne de commande est visible. Cliquez dessus pour afficher les entrées. Nous allons maintenant ajouter unartists’collection à l'aide de l'interface Web. Collectionsongsque nous avons créé avec Arangosh est déjà là. Dans le champ Nom, écrivezartists dans le New Collectionboîte de dialogue qui apparaît. Les options avancées peuvent être ignorées en toute sécurité et le type de collection par défaut, c'est-à-dire Document, convient.

Cliquer sur le bouton Enregistrer créera enfin la collection, et maintenant les deux collections seront visibles sur cette page.

Remplir la collection nouvellement créée avec des documents

Vous serez présenté avec une collection vide en cliquant sur le artists collection -

Pour ajouter un document, vous devez cliquer sur le signe + placé dans le coin supérieur droit. Lorsque vous êtes invité pour un_key, entrer Affable_Balding comme clé.

Maintenant, un formulaire apparaîtra pour ajouter et modifier les attributs du document. Il existe deux façons d'ajouter des attributs:Graphical et Tree. La manière graphique est intuitive mais lente, par conséquent, nous allons passer à laCode afficher, en utilisant le menu déroulant de l'arborescence pour le sélectionner -

Pour faciliter le processus, nous avons créé un exemple de données au format JSON, que vous pouvez copier puis coller dans la zone de l'éditeur de requête -

{"artiste": "Johnny Mercer", "titre": "Affable Balding Me", "compositeur": "Robert Emmett Dolan", "Année": 1950}

(Remarque: une seule paire d'accolades doit être utilisée; voir la capture d'écran ci-dessous)

Vous pouvez observer que nous avons cité les clés ainsi que les valeurs en mode d'affichage de code. Maintenant, cliquez surSave. Une fois l'opération terminée, un flash vert apparaît momentanément sur la page.

Comment lire des documents

Pour lire des documents, revenez à la page Collections.

Quand on clique sur le artist collection, une nouvelle entrée apparaît.

Comment mettre à jour des documents

Il est simple de modifier les entrées dans un document; il vous suffit de cliquer sur la ligne que vous souhaitez modifier dans l'aperçu du document. Ici encore, le même éditeur de requêtes sera présenté que lors de la création de nouveaux documents.

Suppression de documents

Vous pouvez supprimer les documents en appuyant sur l'icône «-». Chaque ligne de document a ce signe à la fin. Il vous demandera de confirmer pour éviter une suppression non sécurisée.

De plus, pour une collection particulière, d'autres opérations telles que le filtrage des documents, la gestion des index et l'importation de données existent également sur le Collections Overview page.

Dans notre prochain chapitre, nous discuterons d'une fonctionnalité importante de l'interface Web, à savoir l'éditeur de requêtes AQL.

Dans ce chapitre, nous verrons comment interroger les données avec AQL. Nous avons déjà discuté dans nos chapitres précédents qu'ArangoDB a développé son propre langage de requête et qu'il s'appelle AQL.

Commençons maintenant à interagir avec AQL. Comme le montre l'image ci-dessous, dans l'interface Web, appuyez sur le boutonAQL Editoronglet placé en haut de la barre de navigation. Un éditeur de requête vide apparaîtra.

En cas de besoin, vous pouvez basculer vers l'éditeur à partir de la vue des résultats et vice-versa, en cliquant sur les onglets Requête ou Résultat dans le coin supérieur droit comme indiqué dans l'image ci-dessous -

Entre autres choses, l'éditeur dispose de la coloration syntaxique, de la fonctionnalité d'annulation / restauration et de l'enregistrement des requêtes. Pour une référence détaillée, on peut consulter la documentation officielle. Nous mettrons en évidence quelques fonctionnalités de base et couramment utilisées de l'éditeur de requêtes AQL.

Fondamentaux AQL

Dans AQL, une requête représente le résultat final à atteindre, mais pas le processus par lequel le résultat final doit être atteint. Cette fonctionnalité est communément appelée propriété déclarative du langage. De plus, AQL peut interroger ainsi modifier les données, et ainsi des requêtes complexes peuvent être créées en combinant les deux processus.

Veuillez noter que AQL est entièrement compatible ACID. La lecture ou la modification des requêtes se terminera en totalité ou pas du tout. Même la lecture des données d'un document se terminera par une unité cohérente des données.

Nous ajoutons deux nouveaux songsà la collection de chansons que nous avons déjà créée. Au lieu de taper, vous pouvez copier la requête suivante et la coller dans l'éditeur 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 songs

Appuyez sur le bouton Exécuter en bas à gauche.

Il écrira deux nouveaux documents dans le songs collection.

Cette requête décrit le fonctionnement de la boucle FOR dans AQL; il itère sur la liste des documents codés JSON, effectuant les opérations codées sur chacun des documents de la collection. Les différentes opérations peuvent être la création de nouvelles structures, le filtrage, la sélection de documents, la modification ou l'insertion de documents dans la base de données (voir l'exemple instantané). En substance, AQL peut effectuer les opérations CRUD de manière efficace.

Pour retrouver toutes les chansons de notre base de données, exécutons à nouveau la requête suivante, équivalente à un SELECT * FROM songs d'une base de données de type SQL (car l'éditeur mémorise la dernière requête, appuyez sur la touche *New* bouton pour nettoyer l'éditeur) -

FOR song IN songs
RETURN song

Le jeu de résultats affichera la liste des chansons enregistrées jusqu'à présent dans le songs collection comme indiqué dans la capture d'écran ci-dessous.

Opérations comme FILTER, SORT et LIMIT peut être ajouté au For loop corps pour affiner et ordonner le résultat.

FOR song IN songs
FILTER song.Year > 1940
RETURN song

La requête ci-dessus donnera les chansons créées après l'année 1940 dans l'onglet Résultat (voir l'image ci-dessous).

La clé de document est utilisée dans cet exemple, mais tout autre attribut peut également être utilisé comme équivalent pour le filtrage. Étant donné que la clé de document est garantie d'être unique, pas plus d'un seul document ne correspondra à ce filtre. Pour d'autres attributs, cela peut ne pas être le cas. Pour renvoyer un sous-ensemble d'utilisateurs actifs (déterminé par un attribut appelé status), triés par nom dans l'ordre croissant, nous utilisons la syntaxe suivante -

FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
RETURN song
LIMIT 2

Nous avons délibérément inclus cet exemple. Ici, nous observons un message d'erreur de syntaxe de requête mis en évidence en rouge par AQL. Cette syntaxe met en évidence les erreurs et est utile pour déboguer vos requêtes, comme indiqué dans la capture d'écran ci-dessous.

Lançons maintenant la requête correcte (notez la correction) -

FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
LIMIT 2
RETURN song

Requête complexe dans AQL

AQL est équipé de plusieurs fonctions pour tous les types de données pris en charge. L'affectation de variables dans une requête permet de créer des constructions imbriquées très complexes. De cette façon, les opérations gourmandes en données se rapprochent des données du backend plutôt que du client (tel que le navigateur). Pour comprendre cela, ajoutons d'abord les durées arbitraires (longueur) des chansons.

Commençons par la première fonction, c'est-à-dire la fonction de mise à jour -

UPDATE { _key: "All_Mucked" }
WITH { length: 180 }
IN songs

Nous pouvons voir qu'un document a été écrit comme indiqué dans la capture d'écran ci-dessus.

Mettons maintenant à jour d'autres documents (chansons) aussi.

UPDATE { _key: "Affable_Balding" }
WITH { length: 200 }
IN songs

Nous pouvons maintenant vérifier que toutes nos chansons ont un nouvel attribut length -

FOR song IN songs
RETURN song

Production

[
   {
      "_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
   }
]

Pour illustrer l'utilisation d'autres mots-clés de AQL tels que LET, FILTER, SORT, etc., nous formaterons maintenant les durées de la chanson dans le mm:ss format.

Requete

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) 
}

Cette fois, nous retournerons le titre de la chanson avec la durée. leReturn La fonction vous permet de créer un nouvel objet JSON à renvoyer pour chaque document d'entrée.

Nous allons maintenant parler de la fonctionnalité «Jointures» de la base de données AQL.

Commençons par créer une collection composer_dob. De plus, nous allons créer les quatre documents avec la date hypothétique de naissance des compositeurs en exécutant la requête suivante dans la zone de requête -

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

Pour mettre en évidence la similitude avec SQL, nous présentons une requête en boucle FOR imbriquée dans AQL, conduisant à l'opération REPLACE, itérant d'abord dans la boucle interne, sur tous les dob des compositeurs puis sur toutes les chansons associées, créant un nouveau document contenant attribut song_with_composer_key à la place du song attribut.

Voici la requête -

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

Lançons maintenant la requête FOR song IN songs RETURN song à nouveau pour voir comment la collection de chansons a changé.

Production

[
   {
      "_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"
   }
]

La requête ci-dessus termine le processus de migration des données en ajoutant le composer_key à chaque chanson.

Maintenant, la requête suivante est à nouveau une requête en boucle FOR imbriquée, mais cette fois menant à l'opération Join, en ajoutant le nom du compositeur associé (en sélectionnant à l'aide de `composer_key`) à chaque chanson -

FOR s IN songs
FOR c IN composer_dob
FILTER c._key == s.composer_key
RETURN MERGE(s,
{ composer: c.composer }
)

Production

[
   {
      "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"
   }
]

Dans ce chapitre, nous examinerons quelques exemples de requêtes AQL sur un Actors and MoviesBase de données. Ces requêtes sont basées sur des graphiques.

Problème

Étant donné une collection d'acteurs et une collection de films, et une collection de bords actIn (avec une propriété year) pour connecter le sommet comme indiqué ci-dessous -

[Actor] <- act in -> [Movie]

Comment pouvons-nous -

• Tous les acteurs qui ont joué dans "movie1" OU "movie2"?
• Tous les acteurs qui ont joué à la fois dans "movie1" ET "movie2"?
• Tous les films communs entre «acteur1» et «acteur2»?
• Tous les acteurs qui ont joué dans 3 films ou plus?
• Tous les films où exactement 6 acteurs ont joué?
• Le nombre d'acteurs par film?
• Le nombre de films par acteur?
• Le nombre de films joués entre 2005 et 2010 par acteur?

Solution

Pendant le processus de résolution et d'obtention des réponses aux requêtes ci-dessus, nous utiliserons Arangosh pour créer l'ensemble de données et exécuter des requêtes à ce sujet. Toutes les requêtes AQL sont des chaînes et peuvent simplement être copiées sur votre pilote préféré au lieu d'Arangosh.

Commençons par créer un jeu de données de test dans Arangosh. Tout d'abord, téléchargez ce fichier -

# wget -O dataset.js
https://drive.google.com/file/d/0B4WLtBDZu_QWMWZYZ3pYMEdqajA/view?usp=sharing

Production

...
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]

Vous pouvez voir dans la sortie ci-dessus que nous avons téléchargé un fichier JavaScript dataset.js.Ce fichier contient les commandes Arangosh pour créer l'ensemble de données dans la base de données. Au lieu de copier et coller les commandes une par une, nous utiliserons le--javascript.executeoption sur Arangosh pour exécuter les multiples commandes de manière non interactive. Considérez cela comme la commande de sauvetage!

Maintenant, exécutez la commande suivante sur le shell -

$ arangosh --javascript.execute dataset.js

Fournissez le mot de passe lorsque vous y êtes invité, comme vous pouvez le voir dans la capture d'écran ci-dessus. Maintenant que nous avons sauvegardé les données, nous construirons les requêtes AQL pour répondre aux questions spécifiques soulevées au début de ce chapitre.

Première question

Prenons la première question: All actors who acted in "movie1" OR "movie2". Supposons que nous voulions trouver les noms de tous les acteurs qui ont joué dans "TheMatrix" OU "TheDevilsAdvocate" -

Nous commencerons par un film à la fois pour obtenir les noms des acteurs -

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();

Production

Nous recevrons la sortie suivante -

[
   "actors/Hugo",
   "actors/Emil",
   "actors/Carrie",
   "actors/Keanu",
   "actors/Laurence"
]

Maintenant, nous continuons à former un UNION_DISTINCT de deux requêtes NEIGHBORS qui sera la solution -

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();

Production

[
   "actors/Charlize",
   "actors/Al",
   "actors/Laurence",
   "actors/Keanu",
   "actors/Carrie",
   "actors/Emil",
   "actors/Hugo"
]

Deuxième question

Examinons maintenant la deuxième question: All actors who acted in both "movie1" AND "movie2". C'est presque identique à la question ci-dessus. Mais cette fois nous ne sommes pas intéressés par une UNION mais par une INTERSECTION -

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();

Production

Nous recevrons la sortie suivante -

[
   "actors/Keanu"
]

Troisième question

Examinons maintenant la troisième question: All common movies between "actor1" and "actor2". C'est en fait identique à la question sur les acteurs communs dans movie1 et movie2. Il suffit de changer les sommets de départ. A titre d'exemple, trouvons tous les films où Hugo Weaving ("Hugo") et Keanu Reeves co-vedette -

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();

Production

Nous recevrons la sortie suivante -

[
   "movies/TheMatrixReloaded",
   "movies/TheMatrixRevolutions",
   "movies/TheMatrix"
]

Quatrième question

Examinons maintenant la quatrième question. All actors who acted in 3 or more movies. Cette question est différente; nous ne pouvons pas utiliser la fonction voisins ici. À la place, nous utiliserons l'index de bord et l'instruction COLLECT d'AQL pour le regroupement. L'idée de base est de regrouper toutes les arêtes par leurstartVertex(qui dans cet ensemble de données est toujours l'acteur). Ensuite, nous supprimons tous les acteurs avec moins de 3 films du résultat car nous avons inclus ici le nombre de films dans lesquels un acteur a joué -

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()

Production

[
   {
      "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
   }
]

Pour les questions restantes, nous discuterons de la formation des requêtes et fournirons uniquement les requêtes. Le lecteur doit exécuter la requête lui-même sur le terminal Arangosh.

Cinquième question

Considérons maintenant la cinquième question: All movies where exactly 6 actors acted in. La même idée que dans la requête précédente, mais avec le filtre d'égalité. Cependant, maintenant nous avons besoin du film au lieu de l'acteur, donc nous retournons le_to attribute -

db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter FILTER
counter == 6 RETURN movie").toArray()

Le nombre d'acteurs par film?

Nous nous souvenons dans notre ensemble de données _to sur le bord correspond au film, donc nous comptons à quelle fréquence le même _toapparaît. C'est le nombre d'acteurs. La requête est presque identique à celles précédentes maiswithout the FILTER after COLLECT -

db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter RETURN
{movie: movie, actors: counter}").toArray()

Sixième question

Examinons maintenant la sixième question: The number of movies by an actor.

La façon dont nous avons trouvé des solutions à nos requêtes ci-dessus vous aidera également à trouver la solution à cette requête.

db._query("FOR x IN actsIn COLLECT actor = x._from WITH COUNT INTO counter
RETURN {actor: actor, movies: counter}").toArray()

Dans ce chapitre, nous décrirons différentes possibilités pour déployer ArangoDB.

Déploiement: instance unique

Nous avons déjà appris comment déployer l'instance unique de Linux (Ubuntu) dans l'un de nos chapitres précédents. Voyons maintenant comment effectuer le déploiement à l'aide de Docker.

Déploiement: Docker

Pour le déploiement à l'aide de docker, nous installerons Docker sur notre machine. Pour plus d'informations sur Docker, veuillez consulter notre tutoriel sur Docker .

Une fois Docker installé, vous pouvez utiliser la commande suivante -

docker run -e ARANGO_RANDOM_ROOT_PASSWORD = 1 -d --name agdb-foo -d
arangodb/arangodb

Il créera et lancera l'instance Docker d'ArangoDB avec le nom d'identification agdbfoo comme processus d'arrière-plan Docker.

Le terminal imprimera également l'identifiant du processus.

Par défaut, le port 8529 est réservé à ArangoDB pour écouter les requêtes. De plus, ce port est automatiquement disponible pour tous les conteneurs d'applications Docker que vous avez peut-être liés.