ArangoDB - Guida rapida

ArangoDB è salutato come un database multi-modello nativo dai suoi sviluppatori. Questo è diverso da altri database NoSQL. In questo database, i dati possono essere memorizzati come documenti, coppie chiave / valore o grafici. E con un singolo linguaggio di query dichiarativo, è possibile accedere a tutti o a tutti i dati. Inoltre, diversi modelli possono essere combinati in una singola query. E, grazie al suo stile multi-modello, è possibile realizzare applicazioni snelle, che saranno scalabili orizzontalmente con uno o tutti i tre modelli di dati.

Database multimodello stratificati e nativi

In questa sezione, evidenzieremo una differenza cruciale tra database multimodello nativi e stratificati.

Molti fornitori di database chiamano il loro prodotto "multi-modello", ma l'aggiunta di un livello grafico a una chiave / valore o un archivio di documenti non si qualifica come multi-modello nativo.

Con ArangoDB, lo stesso core con lo stesso linguaggio di query, è possibile raggruppare diversi modelli di dati e funzionalità in una singola query, come abbiamo già affermato nella sezione precedente. In ArangoDB, non vi è alcun "passaggio" tra i modelli di dati e non vi è alcun trasferimento di dati da A a B per eseguire le query. Porta ad ArangoDB vantaggi in termini di prestazioni rispetto agli approcci "a strati".

La necessità di un database multimodale

L'interpretazione dell'idea di base [di Fowler] ci porta a realizzare i vantaggi dell'utilizzo di una varietà di modelli di dati appropriati per diverse parti del livello di persistenza, essendo il livello parte dell'architettura software più ampia.

Secondo questo, si potrebbe, ad esempio, utilizzare un database relazionale per persistere dati strutturati e tabulari; un archivio di documenti per dati non strutturati e simili a oggetti; un archivio chiave / valore per una tabella hash; e un database a grafo per dati referenziali altamente collegati.

Tuttavia, l'implementazione tradizionale di questo approccio porterà a utilizzare più database nello stesso progetto. Può portare a qualche attrito operativo (distribuzione più complicata, aggiornamenti più frequenti), nonché problemi di coerenza dei dati e duplicazione.

La sfida successiva, dopo aver unificato i dati per i tre modelli di dati, è ideare e implementare un linguaggio di query comune che possa consentire agli amministratori di dati di esprimere una varietà di query, come query di documenti, ricerche chiave / valore, query grafiche e combinazioni arbitrarie di questi.

Di graphy queries, intendiamo query che implicano considerazioni di teoria dei grafi. In particolare, queste possono coinvolgere le particolari caratteristiche di connettività provenienti dai bordi. Per esempio,ShortestPath, GraphTraversal, e Neighbors.

I grafici si adattano perfettamente come modello di dati per le relazioni. In molti casi reali come social network, sistemi di raccomandazione, ecc., Un modello di dati molto naturale è un grafico. Cattura le relazioni e può contenere le informazioni sull'etichetta con ogni bordo e con ogni vertice. Inoltre, i documenti JSON sono una scelta naturale per archiviare questo tipo di dati sui vertici e sui bordi.

ArangoDB ─ Caratteristiche

Ci sono varie caratteristiche degne di nota di ArangoDB. Evidenzieremo le caratteristiche principali di seguito:

  • Paradigma multi-modello
  • Proprietà ACID
  • API HTTP

ArangoDB supporta tutti i modelli di database più diffusi. Di seguito sono riportati alcuni modelli supportati da ArangoDB:

  • Modello di documento
  • Modello chiave / valore
  • Modello grafico

Un singolo linguaggio di query è sufficiente per recuperare i dati dal database

Le quattro proprietà Atomicity, Consistency, Isolation, e Durability(ACID) descrive le garanzie delle transazioni del database. ArangoDB supporta transazioni conformi ad ACID.

ArangoDB consente ai client, come i browser, di interagire con il database con l'API HTTP, essendo l'API orientata alle risorse ed estendibile con JavaScript.

Di seguito sono riportati i vantaggi dell'utilizzo di ArangoDB:

Consolidamento

Essendo un database multi-modello nativo, ArangoDB elimina la necessità di distribuire più database e quindi riduce il numero di componenti e la loro manutenzione. Di conseguenza, riduce la complessità dello stack tecnologico per l'applicazione. Oltre a consolidare le vostre esigenze tecniche complessive, questa semplificazione porta a un minore costo totale di proprietà e ad una maggiore flessibilità.

Scalabilità delle prestazioni semplificata

Con le applicazioni che crescono nel tempo, ArangoDB può affrontare le crescenti esigenze di prestazioni e archiviazione, scalando in modo indipendente con diversi modelli di dati. Poiché ArangoDB può scalare sia verticalmente che orizzontalmente, quindi nel caso in cui le prestazioni richiedano una diminuzione (un rallentamento intenzionale e desiderato), il sistema di back-end può essere facilmente ridimensionato per risparmiare sull'hardware e sui costi operativi.

Complessità operativa ridotta

Il decreto di Polyglot Persistence è quello di utilizzare i migliori strumenti per ogni lavoro che intraprendi. Alcune attività richiedono un database di documenti, mentre altre potrebbero richiedere un database a grafo. Come risultato dell'utilizzo di database a modello singolo, può portare a molteplici sfide operative. L'integrazione di database a modello singolo è di per sé un lavoro difficile. Ma la sfida più grande è costruire una grande struttura coesa con coerenza dei dati e tolleranza ai guasti tra sistemi di database separati e non correlati. Potrebbe rivelarsi quasi impossibile.

Polyglot Persistence può essere gestito con un database multi-modello nativo, in quanto consente di avere dati poliglotti facilmente, ma allo stesso tempo con coerenza dei dati su un sistema fault tolerant. Con ArangoDB, possiamo utilizzare il modello di dati corretto per il lavoro complesso.

Forte coerenza dei dati

Se si utilizzano più database a modello singolo, la coerenza dei dati può diventare un problema. Questi database non sono progettati per comunicare tra loro, quindi è necessario implementare una qualche forma di funzionalità di transazione per mantenere i dati coerenti tra i diversi modelli.

Supportando le transazioni ACID, ArangoDB gestisce i diversi modelli di dati con un unico back-end, fornendo una forte coerenza su una singola istanza e operazioni atomiche quando si opera in modalità cluster.

Tolleranza agli errori

È una sfida costruire sistemi a tolleranza di errore con molti componenti non correlati. Questa sfida diventa più complessa quando si lavora con i cluster. La competenza è necessaria per implementare e mantenere tali sistemi, utilizzando diverse tecnologie e / o stack tecnologici. Inoltre, l'integrazione di più sottosistemi, progettati per funzionare in modo indipendente, comporta ingenti costi di progettazione e operativi.

In quanto stack tecnologico consolidato, il database multi-modello rappresenta una soluzione elegante. Progettato per abilitare architetture moderne e modulari con diversi modelli di dati, ArangoDB funziona anche per l'utilizzo in cluster.

Costo totale di proprietà inferiore

Ogni tecnologia di database richiede una manutenzione continua, patch per la correzione di bug e altre modifiche al codice fornite dal fornitore. L'adozione di un database multimodello riduce notevolmente i relativi costi di manutenzione semplicemente eliminando il numero di tecnologie di database nella progettazione di un'applicazione.

Transazioni

Fornire garanzie transazionali su più macchine è una vera sfida e pochi database NoSQL offrono queste garanzie. Essendo multi-modello nativo, ArangoDB impone transazioni per garantire la coerenza dei dati.

In questo capitolo, discuteremo i concetti di base e la terminologia per ArangoDB. È molto importante avere una conoscenza delle terminologie di base sottostanti relative all'argomento tecnico che stiamo trattando.

Le terminologie per ArangoDB sono elencate di seguito:

  • Document
  • Collection
  • Identificatore della raccolta
  • Nome raccolta
  • Database
  • Nome del database
  • Organizzazione del database

Dal punto di vista del modello di dati, ArangoDB può essere considerato un database orientato ai documenti, poiché la nozione di documento è l'idea matematica di quest'ultimo. I database orientati ai documenti sono una delle principali categorie di database NoSQL.

La gerarchia funziona in questo modo: i documenti sono raggruppati in raccolte e le raccolte esistono all'interno dei database

Dovrebbe essere ovvio che Identificatore e Nome sono due attributi per la raccolta e il database.

Di solito, due documenti (vertici) memorizzati nelle raccolte di documenti sono collegati da un documento (bordo) memorizzato in una raccolta di bordi. Questo è il modello di dati grafico di ArangoDB. Segue il concetto matematico di un grafico diretto ed etichettato, tranne per il fatto che i bordi non hanno solo etichette, ma sono documenti in piena regola.

Avendo acquisito familiarità con i termini principali di questo database, iniziamo a comprendere il modello di dati del grafico di ArangoDB. In questo modello esistono due tipi di raccolte: raccolte di documenti e raccolte edge. Le raccolte Edge archiviano i documenti e includono anche due attributi speciali: il primo è il file_from attributo, e il secondo è il _toattributo. Questi attributi vengono utilizzati per creare bordi (relazioni) tra i documenti essenziali per il database dei grafici. Le raccolte di documenti sono anche chiamate raccolte di vertici nel contesto dei grafici (vedere qualsiasi libro di teoria dei grafi).

Vediamo ora quanto sono importanti i database. Sono importanti perché le raccolte esistono all'interno dei database. In un'istanza di ArangoDB, possono essere presenti uno o più database. Database diversi vengono solitamente utilizzati per configurazioni multi-tenant, poiché i diversi set di dati al loro interno (raccolte, documenti, ecc.) Sono isolati l'uno dall'altro. Il database predefinito_systemè speciale, perché non può essere rimosso. Gli utenti sono gestiti in questo database e le loro credenziali sono valide per tutti i database di un'istanza del server.

In questo capitolo discuteremo i requisiti di sistema per ArangoDB.

I requisiti di sistema per ArangoDB sono i seguenti:

  • Un server VPS con installazione di Ubuntu
  • RAM: 1 GB; CPU: 2,2 GHz

Per tutti i comandi in questo tutorial, abbiamo utilizzato un'istanza di Ubuntu 16.04 (xenial) di RAM 1 GB con una CPU con una potenza di elaborazione di 2,2 GHz. E tutti i comandi di arangosh in questo tutorial sono stati testati per la versione 3.1.27 di ArangoDB.

Come installare ArangoDB?

In questa sezione vedremo come installare ArangoDB. ArangoDB è pre-costruito per molti sistemi operativi e distribuzioni. Per maggiori dettagli, fare riferimento alla documentazione di ArangoDB. Come già accennato, per questo tutorial useremo Ubuntu 16.04x64.

Il primo passo è scaricare la chiave pubblica per i suoi repository -

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

Produzione

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

Il punto importante è che dovresti vedere il file Release.key salvato alla fine dell'output.

Cerchiamo di installare la chiave salvata utilizzando la seguente riga di codice:

# sudo apt-key add Release.key

Produzione

OK

Eseguire i seguenti comandi per aggiungere il repository apt e aggiornare l'indice:

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

Come passaggio finale, possiamo installare ArangoDB -

# sudo apt-get install arangodb3

Produzione

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.

stampa Enter. Ora inizierà il processo di installazione di ArangoDB -

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 l'installazione di ArangoDB sta per essere completata, viene visualizzata la seguente schermata:

Qui ti verrà chiesto di fornire una password per ArangoDB rootutente. Annotatelo attentamente.

Seleziona il yes opzione quando viene visualizzata la seguente finestra di dialogo:

Quando fai clic su Yescome nella finestra di dialogo sopra, appare la seguente finestra di dialogo. ClicYes Qui.

Puoi anche controllare lo stato di ArangoDB con il seguente comando:

# sudo systemctl status arangodb3

Produzione

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 è ora pronto per essere utilizzato.

Per richiamare il terminale arangosh, digita il seguente comando nel terminale:

# arangosh

Produzione

Please specify a password:

Fornire il root password creata al momento dell'installazione -

_
__ _ _ __ __ _ _ __ __ _ ___ | |
/ | '__/ _ | ’ \ / ` |/ _ / | ’
| (| | | | (| | | | | (| | () _ \ | | |
_,|| _,|| ||_, |_/|/| ||
|__/
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

Per disconnettersi da ArangoDB, digita il seguente comando:

127.0.0.1:[email protected]_system> exit

Produzione

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

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

In questo capitolo, discuteremo di come Arangosh funziona come riga di comando per ArangoDB. Inizieremo imparando come aggiungere un utente del database.

Note - Ricorda che il tastierino numerico potrebbe non funzionare su Arangosh.

Supponiamo che l'utente sia "harry" e la password sia "hpwdb".

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

Produzione

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

In questo capitolo impareremo come abilitare / disabilitare l'autenticazione e come associare ArangoDB all'interfaccia di rete pubblica.

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

Ti chiederà la password salvata in precedenza -

Please specify a password:

Usa la password che hai creato per root, nella configurazione.

Puoi anche utilizzare curl per verificare che stai effettivamente ricevendo risposte del server HTTP 401 (non autorizzato) per le richieste che richiedono l'autenticazione -

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

Produzione

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

Per evitare di inserire la password ogni volta durante il nostro processo di apprendimento, disabiliteremo l'autenticazione. Per questo, apri il file di configurazione -

# vim /etc/arangodb3/arangod.conf

È necessario modificare la combinazione di colori se il codice non è correttamente visibile.

:colorscheme desert

Imposta l'autenticazione su false come mostrato nello screenshot qui sotto.

Riavvia il servizio -

# service arangodb3 restart

Rendendo falsa l'autenticazione, sarai in grado di accedere (con root o con utenti creati come Harry in questo caso) senza inserire alcuna password in please specify a password.

Controlliamo il file api versione quando l'autenticazione è disattivata -

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

Produzione

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

In questo capitolo prenderemo in considerazione due scenari di esempio. Questi esempi sono più facili da comprendere e ci aiuteranno a capire il modo in cui funziona la funzionalità di ArangoDB.

Per dimostrare le API, ArangoDB viene fornito precaricato con una serie di grafici facilmente comprensibili. Esistono due metodi per creare istanze di questi grafici nel tuo ArangoDB:

  • Aggiungi la scheda Esempio nella finestra di creazione del grafico nell'interfaccia web,
  • o caricare il modulo @arangodb/graph-examples/example-graph ad Arangosh.

Per cominciare, carichiamo un grafico con l'aiuto dell'interfaccia web. Per questo, avvia l'interfaccia web e fai clic sugraphs tab.

Il Create Graphappare la finestra di dialogo. La procedura guidata contiene due schede:Examples e Graph. IlGraphla scheda è aperta per impostazione predefinita; supponendo di voler creare un nuovo grafico, chiederà il nome e altre definizioni per il grafico.

Ora, caricheremo il grafico già creato. Per questo, selezioneremo il fileExamples tab.

Possiamo vedere i tre grafici di esempio. Seleziona ilKnows_Graph e fare clic sul pulsante verde Crea.

Dopo averli creati, è possibile esaminarli nell'interfaccia web, che è stata utilizzata per creare le immagini seguenti.

The Knows_Graph

Vediamo ora come il file Knows_Graphlavori. Seleziona Knows_Graph e recupererà i dati del grafico.

Knows_Graph è costituito da una raccolta di vertici persons collegato tramite una raccolta bordo knows. Conterrà cinque persone Alice, Bob, Charlie, Dave ed Eve come vertici. Avremo le seguenti relazioni dirette

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

Se fai clic su un nodo (vertice), pronuncia "bob", verrà visualizzato il nome dell'attributo ID (persone / bob).

E facendo clic su uno qualsiasi dei bordi, verranno visualizzati gli attributi ID (sa / 4590).

È così che lo creiamo, ispezioniamo i suoi vertici e bordi.

Aggiungiamo un altro grafico, questa volta usando Arangosh. Per questo, dobbiamo includere un altro endpoint nel file di configurazione di ArangoDB.

Come aggiungere più endpoint

Apri il file di configurazione -

# vim /etc/arangodb3/arangod.conf

Aggiungi un altro endpoint come mostrato nella schermata del terminale di seguito.

Riavvia ArangoDB -

# service arangodb3 restart

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

Il Social_Graph

Vediamo ora cosa è un Social_Graph e come funziona. Il grafico mostra un insieme di persone e le loro relazioni -

Questo esempio ha persone di sesso femminile e maschile come vertici in due raccolte di vertici: femmina e maschio. I bordi sono le loro connessioni nella raccolta dei bordi di relazione. Abbiamo descritto come creare questo grafico usando Arangosh. Il lettore può aggirarlo ed esplorare i suoi attributi, come abbiamo fatto con Knows_Graph.

In questo capitolo ci concentreremo sui seguenti argomenti:

  • Interazione con il database
  • Modello di dati
  • Recupero dei dati

ArangoDB supporta il modello di dati basato su documenti e il modello di dati basato su grafici. Descriviamo prima il modello di dati basato su documenti.

I documenti di ArangoDB assomigliano molto al formato JSON. Zero o più attributi sono contenuti in un documento e un valore allegato a ogni attributo. Un valore è di tipo atomico, come un numero, booleano o null, stringa letterale o di un tipo di dati composto, come un documento / oggetto incorporato o un array. Gli array o gli oggetti secondari possono essere costituiti da questi tipi di dati, il che implica che un singolo documento può rappresentare strutture di dati non banali.

Più avanti nella gerarchia, i documenti sono organizzati in raccolte, che possono non contenere documenti (in teoria) o più di un documento. Si possono confrontare documenti con righe e raccolte con tabelle (qui tabelle e righe si riferiscono a quelle dei sistemi di gestione di database relazionali - RDBMS).

Tuttavia, in RDBMS, la definizione delle colonne è un prerequisito per memorizzare i record in una tabella, chiamando questi schemi di definizioni. Tuttavia, come nuova funzionalità, ArangoDB è senza schema: non c'è motivo a priori per specificare quali attributi avrà il documento.

E a differenza di RDBMS, ogni documento può essere strutturato in un modo completamente diverso da un altro documento. Questi documenti possono essere salvati insieme in un'unica raccolta. In pratica, possono esistere caratteristiche comuni tra i documenti nella raccolta, tuttavia il sistema di database, ovvero lo stesso ArangoDB, non ti lega a una particolare struttura di dati.

Ora proveremo a capire le [graph data model], che richiede due tipi di raccolte: la prima sono le raccolte di documenti (note come raccolte di vertici nel linguaggio teorico dei gruppi), la seconda sono le raccolte di margini. C'è una sottile differenza tra questi due tipi. Anche le raccolte Edge memorizzano i documenti, ma sono caratterizzate dall'inclusione di due attributi univoci,_from e _toper creare relazioni tra documenti. In pratica, un documento (read edge) collega due documenti (read vertices), entrambi archiviati nelle rispettive raccolte. Questa architettura è derivata dal concetto di teoria dei grafi di un grafo diretto etichettato, escludendo i bordi che possono avere non solo etichette, ma possono essere un documento completo simile a JSON in sé.

Per calcolare nuovi dati, eliminare documenti o manipolarli, vengono utilizzate query che selezionano o filtrano i documenti secondo i criteri dati. Sia che siano semplici come una "query di esempio" o complesse come "join", le query sono codificate in AQL - ArangoDB Query Language.

In questo capitolo, discuteremo i diversi metodi di database in ArangoDB.

Per cominciare, prendiamo le proprietà del database:

  • Name
  • ID
  • Path

Per prima cosa, invochiamo l'Arangosh. Una volta richiamato Arangosh, elencheremo i database che abbiamo creato finora -

Useremo la seguente riga di codice per invocare Arangosh -

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

Produzione

[
   "_system",
   "song_collection"
]

Vediamo due database, uno _system creato per impostazione predefinita e il secondo song_collection che abbiamo creato.

Passiamo ora al database song_collection con la seguente riga di codice:

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

Produzione

true
127.0.0.1:[email protected]_collection>

Esploreremo le proprietà del nostro database song_collection.

Per trovare il nome

Useremo la seguente riga di codice per trovare il nome.

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

Produzione

song_collection

Per trovare l'id -

Useremo la seguente riga di codice per trovare l'id.

song_collection

Produzione

4838

Per trovare il percorso -

Useremo la seguente riga di codice per trovare il percorso.

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

Produzione

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

Controlliamo ora se siamo nel database di sistema o meno utilizzando la seguente riga di codice:

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

Produzione

false

Significa che non siamo nel database di sistema (poiché abbiamo creato e spostato nella song_collection). Lo screenshot seguente ti aiuterà a capirlo.

Per ottenere una raccolta particolare, dì canzoni:

Useremo la seguente riga di codice per ottenere una raccolta particolare.

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

Produzione

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

La riga di codice restituisce una singola raccolta.

Passiamo all'essenziale delle operazioni del database con i nostri capitoli successivi.

In questo capitolo impareremo le diverse operazioni con Arangosh.

Le seguenti sono le possibili operazioni con Arangosh:

  • Creazione di una raccolta di documenti
  • Creazione di documenti
  • Lettura di documenti
  • Aggiornamento dei documenti

Cominciamo creando un nuovo database. Useremo la seguente riga di codice per creare un nuovo database:

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

La seguente riga di codice ti aiuterà a passare al nuovo database:

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

Il messaggio passerà a "@@ song_collection"

127.0.0.1:[email protected]_collection>

Da qui studieremo le operazioni CRUD. Creiamo una collezione nel nuovo database -

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

Produzione

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

Aggiungiamo alcuni documenti (oggetti JSON) alla nostra raccolta di "canzoni".

Aggiungiamo il primo documento nel modo seguente:

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

Produzione

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

Aggiungiamo altri documenti al database. Questo ci aiuterà ad apprendere il processo di interrogazione dei dati. Puoi copiare questi codici e incollare lo stesso in Arangosh per emulare il 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---"
}

Come leggere i documenti

Il _keyoppure l'handle del documento può essere utilizzato per recuperare un documento. Utilizzare l'handle del documento se non è necessario attraversare la raccolta stessa. Se hai una collezione, la funzione documento è facile da usare:

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
}

Come aggiornare i documenti

Sono disponibili due opzioni per aggiornare i dati salvati: replace e update.

La funzione di aggiornamento patcha un documento, fondendolo con gli attributi dati. D'altra parte, la funzione di sostituzione sostituirà il documento precedente con uno nuovo. La sostituzione avverrà comunque anche se vengono forniti attributi completamente diversi. Per prima cosa osserveremo un aggiornamento non distruttivo, aggiornando l'attributo Production` in una canzone -

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

Produzione

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

Leggiamo ora gli attributi della canzone aggiornata -

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

Produzione

{
   "_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 documento di grandi dimensioni può essere facilmente aggiornato con l'estensione update funzione, soprattutto quando gli attributi sono molto pochi.

Al contrario, il replace la funzione abolirà i tuoi dati quando li utilizzi con lo stesso documento.

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

Controlliamo ora la canzone che abbiamo appena aggiornato con la seguente riga di codice -

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

Produzione

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

Ora puoi osservare che il documento non ha più i dati originali.

Come rimuovere i documenti

La funzione di rimozione viene utilizzata in combinazione con l'handle del documento per rimuovere un documento da una raccolta:

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

Controlliamo ora gli attributi della canzone che abbiamo appena rimosso utilizzando la seguente riga di codice:

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

Otterremo un errore di eccezione come il seguente come output:

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

Nel nostro capitolo precedente, abbiamo imparato come eseguire varie operazioni sui documenti con Arangosh, la riga di comando. Ora impareremo come eseguire le stesse operazioni utilizzando l'interfaccia web. Per iniziare, inserisci il seguente indirizzo - http: // your_server_ip: 8529 / _db / song_collection / _admin / aardvark / index.html # login nella barra degli indirizzi del tuo browser. Verrai indirizzato alla seguente pagina di accesso.

Ora, inserisci il nome utente e la password.

In caso di esito positivo, viene visualizzata la seguente schermata. Dobbiamo fare una scelta per il database su cui lavorare, il_systemdatabase è quello predefinito. Scegliamo il filesong_collection database e fare clic sulla scheda verde -

Creazione di una raccolta

In questa sezione impareremo come creare una raccolta. Premi la scheda Raccolte nella barra di navigazione in alto.

La nostra raccolta di brani aggiunti dalla riga di comando è visibile. Facendo clic su questo verranno visualizzate le voci. Aggiungeremo ora un fileartists’raccolta tramite l'interfaccia web. Collezionesongsche abbiamo creato con Arangosh è già lì. Nel campo Nome, scriviartists nel New Collectionfinestra di dialogo che appare. Le opzioni avanzate possono essere tranquillamente ignorate e il tipo di raccolta predefinito, ovvero Documento, va bene.

Cliccando sul pulsante Salva si creerà finalmente la collezione, e ora le due collezioni saranno visibili in questa pagina.

Riempire la collezione appena creata con i documenti

Ti verrà presentata una raccolta vuota facendo clic su artists raccolta -

Per aggiungere un documento, è necessario fare clic sul segno + posto nell'angolo in alto a destra. Quando ti viene richiesto un file_key, accedere Affable_Balding come chiave.

Ora apparirà un modulo per aggiungere e modificare gli attributi del documento. Esistono due modi per aggiungere attributi:Graphical e Tree. La modalità grafica è intuitiva ma lenta, quindi passeremo allaCode vista, utilizzando il menu a discesa Albero per selezionarlo -

Per semplificare il processo, abbiamo creato un campione di dati in formato JSON, che puoi copiare e poi incollare nell'area dell'editor delle query -

{"artist": "Johnny Mercer", "title": "Affable Balding Me", "composer": "Robert Emmett Dolan", "Year": 1950}

(Nota: è necessario utilizzare solo un paio di parentesi graffe; vedere lo screenshot qui sotto)

Puoi osservare che abbiamo citato le chiavi e anche i valori nella modalità di visualizzazione del codice. Ora fai clic suSave. In caso di completamento con successo, sulla pagina appare momentaneamente un lampeggio verde.

Come leggere i documenti

Per leggere i documenti, torna alla pagina Raccolte.

Quando si fa clic sul file artist raccolta, viene visualizzata una nuova voce.

Come aggiornare i documenti

È semplice modificare le voci in un documento; è sufficiente fare clic sulla riga che si desidera modificare nella panoramica del documento. Anche in questo caso verrà presentato lo stesso editor di query della creazione di nuovi documenti.

Rimozione di documenti

È possibile eliminare i documenti premendo l'icona "-". Ogni riga del documento ha questo segno alla fine. Ti chiederà di confermare per evitare un'eliminazione non sicura.

Inoltre, per una particolare raccolta, esistono anche altre operazioni come il filtraggio dei documenti, la gestione degli indici e l'importazione dei dati nel file Collections Overview pagina.

Nel capitolo successivo, discuteremo un'importante caratteristica dell'interfaccia Web, ovvero l'Editor delle query AQL.

In questo capitolo, discuteremo come interrogare i dati con AQL. Abbiamo già discusso nei nostri capitoli precedenti che ArangoDB ha sviluppato un proprio linguaggio di query e che si chiama AQL.

Cominciamo ora a interagire con AQL. Come mostrato nell'immagine sotto, nell'interfaccia web, premere il tastoAQL Editorscheda posizionata nella parte superiore della barra di navigazione. Apparirà un editor di query vuoto.

Quando necessario, puoi passare all'editor dalla visualizzazione dei risultati e viceversa, facendo clic sulle schede Query o Risultato nell'angolo in alto a destra come mostrato nell'immagine sottostante -

Tra le altre cose, l'editor dispone di evidenziazione della sintassi, funzionalità di annullamento / ripristino e salvataggio delle query. Per un riferimento dettagliato, si può vedere la documentazione ufficiale. Evidenzieremo alcune funzionalità di base e di uso comune dell'editor di query AQL.

Fondamenti di AQL

In AQL, una query rappresenta il risultato finale da raggiungere, ma non il processo attraverso il quale il risultato finale deve essere raggiunto. Questa funzionalità è comunemente nota come proprietà dichiarativa della lingua. Inoltre, AQL può interrogare e modificare i dati e quindi è possibile creare query complesse combinando entrambi i processi.

Tieni presente che AQL è completamente conforme ad ACID. Leggere o modificare le query si concluderà per intero o per niente. Anche la lettura dei dati di un documento terminerà con un'unità di dati coerente.

Aggiungiamo due nuovi songsalla raccolta di canzoni che abbiamo già creato. Invece di digitare, puoi copiare la seguente query e incollarla nell'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 songs

Premere il pulsante Execute in basso a sinistra.

Scriverà due nuovi documenti nel file songs collezione.

Questa query descrive come funziona il ciclo FOR in AQL; itera sulla lista dei documenti codificati JSON, eseguendo le operazioni codificate su ciascuno dei documenti nella raccolta. Le diverse operazioni possono essere la creazione di nuove strutture, il filtraggio, la selezione di documenti, la modifica o l'inserimento di documenti nel database (fare riferimento all'esempio istantaneo). In sostanza, AQL può eseguire le operazioni CRUD in modo efficiente.

Per trovare tutte le canzoni nel nostro database, eseguiamo ancora una volta la seguente query, equivalente a un file SELECT * FROM songs di un database di tipo SQL (poiché l'editor memorizza l'ultima query, premere il tasto *New* pulsante per pulire l'editor) -

FOR song IN songs
RETURN song

Il set di risultati mostrerà l'elenco delle canzoni finora salvate nel file songs raccolta come mostrato nello screenshot qui sotto.

Operazioni come FILTER, SORT e LIMIT può essere aggiunto al file For loop corpo per restringere e ordinare il risultato.

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

La query di cui sopra darà brani creati dopo l'anno 1940 nella scheda Risultato (vedi l'immagine sotto).

La chiave del documento viene utilizzata in questo esempio, ma qualsiasi altro attributo può essere utilizzato anche come equivalente per il filtro. Poiché la chiave del documento è garantita come univoca, non più di un singolo documento corrisponderà a questo filtro. Per altri attributi questo potrebbe non essere il caso. Per restituire un sottoinsieme di utenti attivi (determinati da un attributo chiamato status), ordinati per nome in ordine crescente, utilizziamo la seguente sintassi:

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

Abbiamo deliberatamente incluso questo esempio. Qui, osserviamo un messaggio di errore di sintassi della query evidenziato in rosso da AQL. Questa sintassi evidenzia gli errori ed è utile per il debug delle query, come mostrato nello screenshot qui sotto.

Eseguiamo ora la query corretta (nota la correzione) -

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

Query complessa in AQL

AQL è dotato di molteplici funzioni per tutti i tipi di dati supportati. L'assegnazione di variabili all'interno di una query consente di costruire costrutti annidati molto complessi. In questo modo le operazioni ad alta intensità di dati si spostano più vicino ai dati sul back-end che sul client (come il browser). Per capirlo, aggiungiamo prima le durate arbitrarie (lunghezza) alle canzoni.

Cominciamo con la prima funzione, cioè la funzione Aggiorna -

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

Possiamo vedere che un documento è stato scritto come mostrato nello screenshot qui sopra.

Aggiorniamo ora anche altri documenti (canzoni).

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

Ora possiamo verificare che tutte le nostre canzoni abbiano un nuovo attributo length -

FOR song IN songs
RETURN song

Produzione

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

Per illustrare l'uso di altre parole chiave di AQL come LET, FILTER, SORT, ecc., Ora formattiamo le durate del brano nel mm:ss formato.

Query

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

Questa volta restituiremo il titolo del brano insieme alla durata. IlReturn consente di creare un nuovo oggetto JSON da restituire per ogni documento di input.

Ora parleremo della funzionalità "Join" del database AQL.

Cominciamo creando una collezione composer_dob. Inoltre, creeremo i quattro documenti con l'ipotetica data di nascita dei compositori eseguendo la seguente query nella casella delle query:

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

Per evidenziare la somiglianza con SQL, presentiamo una query FOR-loop annidata in AQL, che porta all'operazione REPLACE, iterando prima nel loop interno, su tutti i dob dei compositori e poi su tutte le canzoni associate, creando un nuovo documento contenente attributo song_with_composer_key invece di song attributo.

Ecco la domanda:

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

Eseguiamo ora la query FOR song IN songs RETURN song di nuovo per vedere come è cambiata la raccolta di brani.

Produzione

[
   {
      "_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 query precedente completa il processo di migrazione dei dati, aggiungendo l'estensione composer_key a ogni canzone.

Ora la query successiva è di nuovo una query FOR-loop annidata, ma questa volta porta all'operazione Join, aggiungendo il nome del compositore associato (selezionandolo con l'aiuto di `composer_key`) a ciascuna canzone -

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

Produzione

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

In questo capitolo, prenderemo in considerazione alcune query di esempio AQL su un file Actors and MoviesBanca dati. Queste query si basano su grafici.

Problema

Data una raccolta di attori e una raccolta di film e una raccolta di bordi actIn (con una proprietà year) per collegare il vertice come indicato di seguito:

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

Come otteniamo -

  • Tutti gli attori che hanno recitato in "movie1" OR "movie2"?
  • Tutti gli attori che hanno recitato sia in "movie1" E "movie2"?
  • Tutti i film comuni tra "attore1" e "attore2"?
  • Tutti gli attori che hanno recitato in 3 o più film?
  • Tutti i film in cui hanno recitato esattamente 6 attori?
  • Il numero di attori per film?
  • Il numero di film per attore?
  • Il numero di film recitati tra il 2005 e il 2010 dall'attore?

Soluzione

Durante il processo di risoluzione e ottenimento delle risposte alle domande di cui sopra, useremo Arangosh per creare il set di dati ed eseguire query su questo. Tutte le query AQL sono stringhe e possono essere semplicemente copiate sul tuo driver preferito invece che su Arangosh.

Cominciamo creando un set di dati di prova in Arangosh. Innanzitutto, scarica questo file -

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

Produzione

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

Puoi vedere nell'output sopra che abbiamo scaricato un file JavaScript dataset.js.Questo file contiene i comandi Arangosh per creare il set di dati nel database. Invece di copiare e incollare i comandi uno per uno, useremo il file--javascript.executeopzione su Arangosh per eseguire i comandi multipli in modo non interattivo. Consideralo il comando salvavita!

Ora esegui il seguente comando sulla shell:

$ arangosh --javascript.execute dataset.js

Fornisci la password quando richiesto, come puoi vedere nello screenshot qui sopra. Ora che abbiamo salvato i dati, costruiremo le query AQL per rispondere alle domande specifiche sollevate all'inizio di questo capitolo.

Prima domanda

Prendiamo la prima domanda: All actors who acted in "movie1" OR "movie2". Supponiamo di voler trovare i nomi di tutti gli attori che hanno recitato in "TheMatrix" O "TheDevilsAdvocate" -

Inizieremo con un film alla volta per ottenere i nomi degli attori -

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

Produzione

Riceveremo il seguente output:

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

Ora continuiamo a formare un UNION_DISTINCT di due query NEIGHBORS che saranno la soluzione -

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

Produzione

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

Seconda domanda

Consideriamo ora la seconda domanda: All actors who acted in both "movie1" AND "movie2". Questo è quasi identico alla domanda precedente. Ma questa volta non ci interessa un'UNIONE ma un'INTERSEZIONE -

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

Produzione

Riceveremo il seguente output:

[
   "actors/Keanu"
]

Terza domanda

Consideriamo ora la terza domanda: All common movies between "actor1" and "actor2". Questo è in realtà identico alla domanda sugli attori comuni in movie1 e movie2. Dobbiamo solo cambiare i vertici iniziali. Ad esempio, cerchiamo di trovare tutti i film in cui Hugo Weaving ("Hugo") e Keanu Reeves sono co-protagonisti -

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

Produzione

Riceveremo il seguente output:

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

Quarta domanda

Consideriamo ora la quarta domanda. All actors who acted in 3 or more movies. Questa domanda è diversa; non possiamo fare uso della funzione vicini qui. Al contrario, utilizzeremo l'edge-index e l'istruzione COLLECT di AQL per il raggruppamento. L'idea di base è raggruppare tutti i bordi per i lorostartVertex(che in questo set di dati è sempre l'attore). Quindi rimuoviamo tutti gli attori con meno di 3 film dal risultato poiché qui abbiamo incluso il numero di film in cui un attore ha recitato -

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

Produzione

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

Per le restanti domande, discuteremo la formazione delle query e forniremo solo le query. Il lettore dovrebbe eseguire la query da solo sul terminale Arangosh.

Quinta domanda

Consideriamo ora la quinta domanda: All movies where exactly 6 actors acted in. La stessa idea della query precedente, ma con il filtro di uguaglianza. Tuttavia, ora abbiamo bisogno del film invece dell'attore, quindi restituiamo il file_to attribute -

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

Il numero di attori per film?

Ricordiamo nel nostro set di dati _to sul bordo corrisponde al film, quindi contiamo quante volte lo stesso _toappare. Questo è il numero di attori. La query è quasi identica a quelle precedenti mawithout the FILTER after COLLECT -

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

Sesta domanda

Consideriamo ora la sesta domanda: The number of movies by an actor.

Il modo in cui abbiamo trovato le soluzioni alle nostre query precedenti ti aiuterà a trovare la soluzione anche a questa query.

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

In questo capitolo descriveremo varie possibilità per distribuire ArangoDB.

Distribuzione: istanza singola

Abbiamo già imparato come distribuire la singola istanza di Linux (Ubuntu) in uno dei nostri capitoli precedenti. Vediamo ora come eseguire la distribuzione utilizzando Docker.

Distribuzione: Docker

Per la distribuzione tramite docker, installeremo Docker sulla nostra macchina. Per ulteriori informazioni su Docker, fare riferimento al nostro tutorial su Docker .

Una volta installato Docker, puoi utilizzare il seguente comando:

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

Creerà e avvierà l'istanza Docker di ArangoDB con il nome identificativo agdbfoo come processo in background Docker.

Anche il terminale stamperà l'identificatore del processo.

Per impostazione predefinita, la porta 8529 è riservata ad ArangoDB per l'ascolto delle richieste. Anche questa porta è automaticamente disponibile per tutti i contenitori di applicazioni Docker che potresti aver collegato.