ArangoDB - Kurzanleitung
ArangoDB wird von seinen Entwicklern als native Datenbank mit mehreren Modellen gefeiert. Dies ist anders als bei anderen NoSQL-Datenbanken. In dieser Datenbank können die Daten als Dokumente, Schlüssel / Wert-Paare oder Diagramme gespeichert werden. Mit einer einzigen deklarativen Abfragesprache kann auf einige oder alle Ihrer Daten zugegriffen werden. Darüber hinaus können verschiedene Modelle in einer einzigen Abfrage kombiniert werden. Aufgrund seines Multi-Modell-Stils können schlanke Anwendungen erstellt werden, die mit einem oder allen drei Datenmodellen horizontal skalierbar sind.
Layered vs. Native Multi-Model-Datenbanken
In diesem Abschnitt werden wir einen entscheidenden Unterschied zwischen nativen und geschichteten Multimodell-Datenbanken hervorheben.
Viele Datenbankanbieter bezeichnen ihr Produkt als "Multi-Modell". Das Hinzufügen einer Diagrammebene zu einem Schlüssel- / Wert- oder Dokumentenspeicher gilt jedoch nicht als natives Multi-Modell.
Mit ArangoDB, demselben Kern mit derselben Abfragesprache, können verschiedene Datenmodelle und Funktionen in einer einzigen Abfrage zusammengefasst werden, wie bereits im vorherigen Abschnitt angegeben. In ArangoDB gibt es kein „Umschalten“ zwischen Datenmodellen und keine Verschiebung von Daten von A nach B, um Abfragen auszuführen. Dies führt zu Leistungsvorteilen für ArangoDB im Vergleich zu den "geschichteten" Ansätzen.
Die Notwendigkeit einer multimodalen Datenbank
Die Interpretation der Grundidee von [Fowler] führt uns zu den Vorteilen der Verwendung einer Vielzahl geeigneter Datenmodelle für verschiedene Teile der Persistenzschicht, wobei die Schicht Teil der größeren Softwarearchitektur ist.
Demnach könnte man beispielsweise eine relationale Datenbank verwenden, um strukturierte tabellarische Daten beizubehalten; ein Dokumentenspeicher für unstrukturierte, objektähnliche Daten; ein Schlüssel- / Wertspeicher für eine Hash-Tabelle; und eine Graphendatenbank für stark verknüpfte Referenzdaten.
Die traditionelle Implementierung dieses Ansatzes führt jedoch dazu, dass mehrere Datenbanken im selben Projekt verwendet werden. Dies kann zu Betriebsstörungen (kompliziertere Bereitstellung, häufigere Upgrades) sowie zu Datenkonsistenz- und Duplizierungsproblemen führen.
Die nächste Herausforderung nach der Vereinheitlichung der Daten für die drei Datenmodelle besteht darin, eine gemeinsame Abfragesprache zu entwickeln und zu implementieren, mit der Datenadministratoren eine Vielzahl von Abfragen ausdrücken können, z. B. Dokumentabfragen, Schlüssel- / Wertsuchen, grafische Abfragen und beliebige Kombinationen von diesen.
Durch graphy queriesWir meinen Abfragen mit graphentheoretischen Überlegungen. Dies kann insbesondere die besonderen Konnektivitätsmerkmale betreffen, die von den Rändern kommen. Zum Beispiel,ShortestPath, GraphTraversal, und Neighbors.
Diagramme passen perfekt als Datenmodell für Beziehungen. In vielen realen Fällen wie sozialen Netzwerken, Empfehlungssystemen usw. ist ein sehr natürliches Datenmodell ein Diagramm. Es erfasst Beziehungen und kann Beschriftungsinformationen mit jeder Kante und mit jedem Scheitelpunkt enthalten. Darüber hinaus eignen sich JSON-Dokumente ideal zum Speichern dieser Art von Scheitelpunkt- und Kantendaten.
ArangoDB ─ Funktionen
Es gibt verschiedene bemerkenswerte Funktionen von ArangoDB. Wir werden die herausragenden Merkmale unten hervorheben -
- Multi-Modell-Paradigma
- ACID-Eigenschaften
- HTTP-API
ArangoDB unterstützt alle gängigen Datenbankmodelle. Im Folgenden sind einige von ArangoDB unterstützte Modelle aufgeführt:
- Dokumentmodell
- Schlüssel- / Wertmodell
- Diagrammmodell
Eine einzige Abfragesprache reicht aus, um Daten aus der Datenbank abzurufen
Die vier Eigenschaften Atomicity, Consistency, Isolation, und Durability(ACID) beschreiben die Garantien von Datenbanktransaktionen. ArangoDB unterstützt ACID-konforme Transaktionen.
Mit ArangoDB können Clients wie Browser mit der HTTP-API mit der Datenbank interagieren. Die API ist ressourcenorientiert und mit JavaScript erweiterbar.
Im Folgenden sind die Vorteile der Verwendung von ArangoDB aufgeführt:
Konsolidierung
Als native Datenbank mit mehreren Modellen macht ArangoDB die Bereitstellung mehrerer Datenbanken überflüssig und verringert somit die Anzahl der Komponenten und deren Wartung. Folglich wird die Komplexität des Technologie-Stacks für die Anwendung reduziert. Diese Vereinfachung konsolidiert nicht nur Ihre technischen Gesamtanforderungen, sondern führt auch zu niedrigeren Gesamtbetriebskosten und einer höheren Flexibilität.
Vereinfachte Leistungsskalierung
Mit Anwendungen, die im Laufe der Zeit wachsen, kann ArangoDB den wachsenden Leistungs- und Speicheranforderungen gerecht werden, indem es unabhängig mit verschiedenen Datenmodellen skaliert. Da ArangoDB sowohl vertikal als auch horizontal skaliert werden kann, kann Ihr Back-End-System für den Fall, dass Ihre Leistung eine Verringerung erfordert (eine absichtliche, gewünschte Verlangsamung), einfach verkleinert werden, um Hardware- und Betriebskosten zu sparen.
Reduzierte betriebliche Komplexität
Das Dekret der Polyglot-Persistenz besteht darin, für jeden Job, den Sie ausführen, die besten Werkzeuge einzusetzen. Bestimmte Aufgaben benötigen eine Dokumentendatenbank, während andere möglicherweise eine Diagrammdatenbank benötigen. Aufgrund der Arbeit mit Datenbanken mit einem Modell kann dies zu mehreren betrieblichen Herausforderungen führen. Die Integration von Datenbanken mit einem Modell ist an sich schon eine schwierige Aufgabe. Die größte Herausforderung besteht jedoch darin, eine große zusammenhängende Struktur mit Datenkonsistenz und Fehlertoleranz zwischen separaten, nicht verwandten Datenbanksystemen aufzubauen. Es kann sich als nahezu unmöglich erweisen.
Die Polyglot-Persistenz kann mit einer nativen Datenbank mit mehreren Modellen verarbeitet werden, da Polyglot-Daten problemlos und gleichzeitig mit Datenkonsistenz auf einem fehlertoleranten System verfügbar sind. Mit ArangoDB können wir das richtige Datenmodell für den komplexen Job verwenden.
Starke Datenkonsistenz
Wenn mehrere Datenbanken mit einem Modell verwendet werden, kann die Datenkonsistenz zu einem Problem werden. Diese Datenbanken sind nicht für die Kommunikation untereinander ausgelegt. Daher muss eine Form von Transaktionsfunktionalität implementiert werden, damit Ihre Daten zwischen verschiedenen Modellen konsistent bleiben.
ArangoDB unterstützt ACID-Transaktionen und verwaltet Ihre verschiedenen Datenmodelle mit einem einzigen Back-End. Dies bietet eine starke Konsistenz für eine einzelne Instanz und atomare Operationen im Cluster-Modus.
Fehlertoleranz
Es ist eine Herausforderung, fehlertolerante Systeme mit vielen unabhängigen Komponenten zu bauen. Diese Herausforderung wird bei der Arbeit mit Clustern komplexer. Für die Bereitstellung und Wartung solcher Systeme unter Verwendung verschiedener Technologien und / oder Technologie-Stacks ist Fachwissen erforderlich. Darüber hinaus verursacht die Integration mehrerer Subsysteme, die für einen unabhängigen Betrieb ausgelegt sind, hohe Engineering- und Betriebskosten.
Als konsolidierter Technologie-Stack bietet die Datenbank mit mehreren Modellen eine elegante Lösung. ArangoDB wurde entwickelt, um moderne, modulare Architekturen mit unterschiedlichen Datenmodellen zu ermöglichen. Es funktioniert auch für die Cluster-Nutzung.
Niedrigere Gesamtbetriebskosten
Jede Datenbanktechnologie erfordert fortlaufende Wartung, Patches zur Fehlerbehebung und andere vom Hersteller bereitgestellte Codeänderungen. Durch die Verwendung einer Datenbank mit mehreren Modellen werden die damit verbundenen Wartungskosten erheblich reduziert, indem die Anzahl der Datenbanktechnologien beim Entwerfen einer Anwendung eliminiert wird.
Transaktionen
Das Bereitstellen von Transaktionsgarantien auf mehreren Computern ist eine echte Herausforderung, und nur wenige NoSQL-Datenbanken bieten diese Garantien. Als natives Multi-Modell schreibt ArangoDB Transaktionen vor, um die Datenkonsistenz zu gewährleisten.
In diesem Kapitel werden die grundlegenden Konzepte und Terminologien für ArangoDB erläutert. Es ist sehr wichtig, ein Know-how über die zugrunde liegenden grundlegenden Terminologien zu haben, die sich auf das technische Thema beziehen, mit dem wir uns befassen.
Die Terminologien für ArangoDB sind unten aufgeführt -
- Document
- Collection
- Sammlungskennung
- Sammlungsname
- Database
- Name der Datenbank
- Datenbankorganisation
Aus Sicht des Datenmodells kann ArangoDB als dokumentenorientierte Datenbank betrachtet werden, da der Begriff eines Dokuments die mathematische Idee des letzteren ist. Dokumentorientierte Datenbanken sind eine der Hauptkategorien von NoSQL-Datenbanken.
Die Hierarchie sieht folgendermaßen aus: Dokumente werden in Sammlungen gruppiert, und Sammlungen sind in Datenbanken vorhanden
Es sollte offensichtlich sein, dass Bezeichner und Name zwei Attribute für die Sammlung und die Datenbank sind.
Normalerweise werden zwei in Dokumentensammlungen gespeicherte Dokumente (Eckpunkte) durch ein in einer Kantenkollektion gespeichertes Dokument (Kante) verknüpft. Dies ist das Diagrammdatenmodell von ArangoDB. Es folgt dem mathematischen Konzept eines gerichteten, beschrifteten Diagramms, mit der Ausnahme, dass Kanten nicht nur Beschriftungen haben, sondern vollständige Dokumente sind.
Nachdem wir uns mit den Kernbegriffen für diese Datenbank vertraut gemacht haben, beginnen wir, das Diagrammdatenmodell von ArangoDB zu verstehen. In diesem Modell gibt es zwei Arten von Sammlungen: Dokumentensammlungen und Kantensammlungen. Edge-Sammlungen speichern Dokumente und enthalten außerdem zwei spezielle Attribute: Erstens das_from Attribut, und das zweite ist das _toAttribut. Diese Attribute werden verwendet, um Kanten (Beziehungen) zwischen Dokumenten zu erstellen, die für die Diagrammdatenbank wesentlich sind. Dokumentensammlungen werden im Kontext von Diagrammen auch als Scheitelpunktsammlungen bezeichnet (siehe jedes Diagramm-Theoriebuch).
Lassen Sie uns nun sehen, wie wichtig Datenbanken sind. Sie sind wichtig, da Sammlungen in Datenbanken vorhanden sind. In einer Instanz von ArangoDB kann es eine oder mehrere Datenbanken geben. Für die Einrichtung mehrerer Mandanten werden normalerweise unterschiedliche Datenbanken verwendet, da die verschiedenen darin enthaltenen Datensätze (Sammlungen, Dokumente usw.) voneinander isoliert sind. Die Standarddatenbank_systemist etwas Besonderes, weil es nicht entfernt werden kann. Benutzer werden in dieser Datenbank verwaltet und ihre Anmeldeinformationen gelten für alle Datenbanken einer Serverinstanz.
In diesem Kapitel werden die Systemanforderungen für ArangoDB erläutert.
Die Systemanforderungen für ArangoDB lauten wie folgt:
- Ein VPS-Server mit Ubuntu-Installation
- RAM: 1 GB; CPU: 2,2 GHz
Für alle Befehle in diesem Tutorial haben wir eine Instanz von Ubuntu 16.04 (Xenial) mit 1 GB RAM und einer CPU mit einer Verarbeitungsleistung von 2,2 GHz verwendet. Alle Arangosh-Befehle in diesem Tutorial wurden für die ArangoDB-Version 3.1.27 getestet.
Wie installiere ich ArangoDB?
In diesem Abschnitt erfahren Sie, wie Sie ArangoDB installieren. ArangoDB ist für viele Betriebssysteme und Distributionen vorgefertigt. Weitere Informationen finden Sie in der ArangoDB-Dokumentation. Wie bereits erwähnt, verwenden wir für dieses Tutorial Ubuntu 16.04x64.
Der erste Schritt besteht darin, den öffentlichen Schlüssel für seine Repositorys herunterzuladen.
# wget https://www.arangodb.com/repositories/arangodb31/
xUbuntu_16.04/Release.key
Ausgabe
--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]
Der wichtige Punkt ist, dass Sie das sehen sollten Release.key am Ende der Ausgabe gespeichert.
Lassen Sie uns den gespeicherten Schlüssel mit der folgenden Codezeile installieren:
# sudo apt-key add Release.key
Ausgabe
OK
Führen Sie die folgenden Befehle aus, um das apt-Repository hinzuzufügen und den Index zu aktualisieren:
# sudo apt-add-repository 'deb
https://www.arangodb.com/repositories/arangodb31/xUbuntu_16.04/ /'
# sudo apt-get update
Als letzten Schritt können wir ArangoDB installieren -
# sudo apt-get install arangodb3
Ausgabe
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.
Drücken Sie Enter. Jetzt beginnt der Installationsprozess von 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.
Wenn die Installation von ArangoDB abgeschlossen ist, wird der folgende Bildschirm angezeigt:
Hier werden Sie aufgefordert, ein Passwort für die ArangoDB anzugeben rootNutzer. Notieren Sie es sorgfältig.
Wähle aus yes Option, wenn das folgende Dialogfeld angezeigt wird -
Wenn Sie klicken YesWie im obigen Dialogfeld wird das folgende Dialogfeld angezeigt. KlickenYes Hier.
Sie können den Status von ArangoDB auch mit dem folgenden Befehl überprüfen:
# sudo systemctl status arangodb3
Ausgabe
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 kann jetzt verwendet werden.
Geben Sie zum Aufrufen des Arangosh-Terminals den folgenden Befehl in das Terminal ein:
# arangosh
Ausgabe
Please specify a password:
Liefern Sie die root Passwort zum Zeitpunkt der Installation erstellt -
_
__ _ _ __ __ _ _ __ __ _ ___ | |
/ | '__/ _ | ’ \ / ` |/ _ / | ’
| (| | | | (| | | | | (| | () _ \ | | |
_,|| _,|| ||_, |_/|/| ||
|__/
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:8529@_system> exit
Geben Sie den folgenden Befehl ein, um sich von ArangoDB abzumelden:
127.0.0.1:8529@_system> exit
Ausgabe
Uf wiederluege! Na shledanou! Auf Wiedersehen! Bye Bye! Adiau! ¡Hasta luego!
Εις το επανιδείν!
להתראות ! Arrivederci! Tot ziens! Adjö! Au revoir! さようなら До свидания! Até
Breve! !خداحافظ
In diesem Kapitel werden wir diskutieren, wie Arangosh als Befehlszeile für ArangoDB funktioniert. Zunächst lernen wir, wie Sie einen Datenbankbenutzer hinzufügen.
Note - Denken Sie daran, dass die Zehnertastatur unter Arangosh möglicherweise nicht funktioniert.
Nehmen wir an, der Benutzer ist "harry" und das Passwort ist "hpwdb".
127.0.0.1:8529@_system> require("org/arangodb/users").save("harry", "hpwdb");
Ausgabe
{
"user" : "harry",
"active" : true,
"extra" : {},
"changePassword" : false,
"code" : 201
}
In diesem Kapitel erfahren Sie, wie Sie die Authentifizierung aktivieren / deaktivieren und die ArangoDB an die öffentliche Netzwerkschnittstelle binden.
# arangosh --server.endpoint tcp://127.0.0.1:8529 --server.database "_system"
Sie werden aufgefordert, das zuvor gespeicherte Passwort einzugeben.
Please specify a password:
Verwenden Sie bei der Konfiguration das Kennwort, das Sie für root erstellt haben.
Sie können Curl auch verwenden, um zu überprüfen, ob Sie tatsächlich HTTP 401-Serverantworten (nicht autorisiert) für Anforderungen erhalten, für die eine Authentifizierung erforderlich ist.
# curl --dump - http://127.0.0.1:8529/_api/version
Ausgabe
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
Um zu vermeiden, dass Sie das Passwort jedes Mal während unseres Lernprozesses eingeben, deaktivieren wir die Authentifizierung. Öffnen Sie dazu die Konfigurationsdatei -
# vim /etc/arangodb3/arangod.conf
Sie sollten das Farbschema ändern, wenn der Code nicht richtig sichtbar ist.
:colorscheme desert
Setzen Sie die Authentifizierung auf false, wie im folgenden Screenshot gezeigt.
Starten Sie den Dienst neu -
# service arangodb3 restart
Wenn Sie die Authentifizierung falsch machen, können Sie sich anmelden (entweder mit root oder einem erstellten Benutzer wie Harry in diesem Fall) ohne Eingabe eines Passworts in please specify a password.
Lassen Sie uns das überprüfen api Version, wenn die Authentifizierung ausgeschaltet ist -
# curl --dump - http://127.0.0.1:8529/_api/version
Ausgabe
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 diesem Kapitel werden zwei Beispielszenarien betrachtet. Diese Beispiele sind leichter zu verstehen und helfen uns zu verstehen, wie die ArangoDB-Funktionalität funktioniert.
Um die APIs zu demonstrieren, ist ArangoDB mit einer Reihe leicht verständlicher Grafiken vorinstalliert. Es gibt zwei Methoden, um Instanzen dieser Diagramme in Ihrer ArangoDB zu erstellen:
- Fügen Sie im Fenster "Diagramm erstellen" der Weboberfläche die Registerkarte "Beispiel" hinzu.
- oder laden Sie das Modul @arangodb/graph-examples/example-graph in Arangosh.
Lassen Sie uns zunächst ein Diagramm mit Hilfe der Weboberfläche laden. Starten Sie dazu die Weboberfläche und klicken Sie aufgraphs Tab.
Das Create GraphDas Dialogfeld wird angezeigt. Der Assistent enthält zwei Registerkarten -Examples und Graph. DasGraphDie Registerkarte ist standardmäßig geöffnet. Angenommen, wir möchten ein neues Diagramm erstellen, werden Sie nach dem Namen und anderen Definitionen für das Diagramm gefragt.
Jetzt laden wir das bereits erstellte Diagramm hoch. Dazu wählen wir dieExamples Tab.
Wir können die drei Beispielgraphen sehen. Wähle ausKnows_Graph und klicken Sie auf die grüne Schaltfläche Erstellen.
Sobald Sie sie erstellt haben, können Sie sie in der Weboberfläche überprüfen, mit der die folgenden Bilder erstellt wurden.
Der Knows_Graph
Lassen Sie uns jetzt sehen, wie die Knows_Graphfunktioniert. Wählen Sie den Knows_Graph aus, um die Diagrammdaten abzurufen.
Der Knows_Graph besteht aus einer Vertex-Sammlung persons über eine Kantensammlung verbunden knows. Es wird fünf Personen enthalten, Alice, Bob, Charlie, Dave und Eva als Eckpunkte. Wir werden die folgenden gerichteten Beziehungen haben
Alice knows Bob
Bob knows Charlie
Bob knows Dave
Eve knows Alice
Eve knows Bob
Wenn Sie auf einen Knoten (Scheitelpunkt) klicken, z. B. "Bob", wird der Attributname der ID (Personen / Bob) angezeigt.
Wenn Sie auf eine der Kanten klicken, werden die ID-Attribute (know / 4590) angezeigt.
So erstellen wir es, untersuchen seine Eckpunkte und Kanten.
Fügen wir ein weiteres Diagramm hinzu, diesmal mit Arangosh. Dazu müssen wir einen weiteren Endpunkt in die ArangoDB-Konfigurationsdatei aufnehmen.
Hinzufügen mehrerer Endpunkte
Öffnen Sie die Konfigurationsdatei -
# vim /etc/arangodb3/arangod.conf
Fügen Sie einen weiteren Endpunkt hinzu, wie im folgenden Screenshot des Terminals gezeigt.
Starten Sie die ArangoDB neu -
# service arangodb3 restart
Starten Sie den 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:8529@_system>
Der Social_Graph
Lassen Sie uns nun verstehen, was ein Social_Graph ist und wie es funktioniert. Die Grafik zeigt eine Reihe von Personen und ihre Beziehungen -
In diesem Beispiel werden weibliche und männliche Personen als Scheitelpunkte in zwei Scheitelpunktsammlungen verwendet - weibliche und männliche. Die Kanten sind ihre Verbindungen in der Relation Edge Collection. Wir haben beschrieben, wie Sie dieses Diagramm mit Arangosh erstellen. Der Leser kann es umgehen und seine Attribute untersuchen, wie wir es mit dem Knows_Graph getan haben.
In diesem Kapitel konzentrieren wir uns auf die folgenden Themen:
- Datenbankinteraktion
- Datenmodell
- Datenabruf
ArangoDB unterstützt sowohl dokumentbasierte Datenmodelle als auch graphbasierte Datenmodelle. Beschreiben wir zunächst das dokumentbasierte Datenmodell.
Die Dokumente von ArangoDB ähneln stark dem JSON-Format. In einem Dokument sind null oder mehr Attribute enthalten, und jedem Attribut ist ein Wert zugeordnet. Ein Wert ist entweder ein atomarer Typ, z. B. eine Zahl, ein Boolescher Wert oder eine Null, eine Literalzeichenfolge, oder ein zusammengesetzter Datentyp, z. B. ein eingebettetes Dokument / Objekt oder ein Array. Arrays oder Unterobjekte können aus diesen Datentypen bestehen, was bedeutet, dass ein einzelnes Dokument nicht triviale Datenstrukturen darstellen kann.
Weiter in der Hierarchie sind Dokumente in Sammlungen angeordnet, die (theoretisch) keine Dokumente oder mehr als ein Dokument enthalten dürfen. Man kann Dokumente mit Zeilen und Sammlungen mit Tabellen vergleichen (hier beziehen sich Tabellen und Zeilen auf die von relationalen Datenbankverwaltungssystemen - RDBMS).
In RDBMS ist das Definieren von Spalten jedoch eine Voraussetzung, um Datensätze in einer Tabelle zu speichern und diese Definitionsschemata aufzurufen. Als neuartige Funktion ist ArangoDB jedoch schemalos - es gibt keinen a priori Grund, anzugeben, welche Attribute das Dokument haben wird.
Und im Gegensatz zu RDBMS kann jedes Dokument ganz anders strukturiert sein als ein anderes Dokument. Diese Dokumente können zusammen in einer einzigen Sammlung gespeichert werden. In der Praxis können unter den Dokumenten in der Sammlung gemeinsame Merkmale vorhanden sein, das Datenbanksystem, dh ArangoDB selbst, bindet Sie jedoch nicht an eine bestimmte Datenstruktur.
Jetzt werden wir versuchen, ArangoDBs [graph data model], für die zwei Arten von Sammlungen erforderlich sind: Die erste sind die Dokumentensammlungen (in gruppentheoretischer Sprache als Vertices-Sammlungen bezeichnet), die zweite die Randsammlungen. Es gibt einen subtilen Unterschied zwischen diesen beiden Typen. Edge-Sammlungen speichern auch Dokumente, zeichnen sich jedoch durch zwei eindeutige Attribute aus:_from und _tozum Erstellen von Beziehungen zwischen Dokumenten. In der Praxis verknüpft ein Dokument (Lesekante) zwei Dokumente (Lesescheitelpunkte), die beide in ihren jeweiligen Sammlungen gespeichert sind. Diese Architektur leitet sich aus dem graphentheoretischen Konzept eines beschrifteten, gerichteten Graphen ab, mit Ausnahme von Kanten, die nicht nur Beschriftungen haben können, sondern an sich ein vollständiges JSON-ähnliches Dokument sein können.
Um neue Daten zu berechnen, Dokumente zu löschen oder zu bearbeiten, werden Abfragen verwendet, die Dokumente gemäß den angegebenen Kriterien auswählen oder filtern. Abfragen sind entweder einfach als "Beispielabfrage" oder so komplex wie "Verknüpfungen" und werden in AQL - ArangoDB Query Language codiert.
In diesem Kapitel werden die verschiedenen Datenbankmethoden in ArangoDB erläutert.
Lassen Sie uns zunächst die Eigenschaften der Datenbank abrufen -
- Name
- ID
- Path
Zuerst rufen wir den Arangosh auf. Sobald Arangosh aufgerufen wird, werden wir die Datenbanken auflisten, die wir bisher erstellt haben -
Wir werden die folgende Codezeile verwenden, um Arangosh aufzurufen -
127.0.0.1:8529@_system> db._databases()
Ausgabe
[
"_system",
"song_collection"
]
Wir sehen zwei Datenbanken, eine _system Standardmäßig erstellt, und die zweite song_collection das haben wir geschaffen.
Wechseln wir nun mit der folgenden Codezeile zur Datenbank song_collection:
127.0.0.1:8529@_system> db._useDatabase("song_collection")
Ausgabe
true
127.0.0.1:8529@song_collection>
Wir werden die Eigenschaften unserer song_collection-Datenbank untersuchen.
Um den Namen zu finden
Wir werden die folgende Codezeile verwenden, um den Namen zu finden.
127.0.0.1:8529@song_collection> db._name()
Ausgabe
song_collection
Um die ID zu finden -
Wir werden die folgende Codezeile verwenden, um die ID zu finden.
song_collection
Ausgabe
4838
Den Weg finden -
Wir werden die folgende Codezeile verwenden, um den Pfad zu finden.
127.0.0.1:8529@song_collection> db._path()
Ausgabe
/var/lib/arangodb3/databases/database-4838
Lassen Sie uns nun anhand der folgenden Codezeile überprüfen, ob wir uns in der Systemdatenbank befinden oder nicht.
127.0.0.1:8529@song_collection&t; db._isSystem()
Ausgabe
false
Dies bedeutet, dass wir uns nicht in der Systemdatenbank befinden (wie wir sie erstellt und in die song_collection verschoben haben). Der folgende Screenshot hilft Ihnen dabei, dies zu verstehen.
Um eine bestimmte Sammlung zu erhalten, sagen Sie Lieder -
Wir werden die folgende Codezeile verwenden, um eine bestimmte Sammlung zu erhalten.
127.0.0.1:8529@song_collection> db._collection("songs")
Ausgabe
[ArangoCollection 4890, "songs" (type document, status loaded)]
Die Codezeile gibt eine einzelne Sammlung zurück.
Kommen wir in den folgenden Kapiteln zu den Grundlagen der Datenbankoperationen.
In diesem Kapitel lernen wir die verschiedenen Operationen mit Arangosh kennen.
Das Folgende sind die möglichen Operationen mit Arangosh -
- Dokumentensammlung erstellen
- Dokumente erstellen
- Dokumente lesen
- Dokumente aktualisieren
Beginnen wir mit der Erstellung einer neuen Datenbank. Wir werden die folgende Codezeile verwenden, um eine neue Datenbank zu erstellen -
127.0.0.1:8529@_system> db._createDatabase("song_collection")
true
Die folgende Codezeile hilft Ihnen beim Wechsel zur neuen Datenbank:
127.0.0.1:8529@_system> db._useDatabase("song_collection")
true
Die Eingabeaufforderung wechselt zu "@@ song_collection".
127.0.0.1:8529@song_collection>
Von hier aus werden wir CRUD Operations studieren. Lassen Sie uns eine Sammlung in der neuen Datenbank erstellen -
127.0.0.1:8529@song_collection> db._createDocumentCollection('songs')
Ausgabe
[ArangoCollection 4890, "songs" (type document, status loaded)]
127.0.0.1:8529@song_collection>
Fügen wir unserer 'Songs'-Sammlung einige Dokumente (JSON-Objekte) hinzu.
Wir fügen das erste Dokument folgendermaßen hinzu:
127.0.0.1:8529@song_collection> db.songs.save({title: "A Man's Best Friend",
lyricist: "Johnny Mercer", composer: "Johnny Mercer", Year: 1950, _key:
"A_Man"})
Ausgabe
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVClbW---"
}
Fügen wir der Datenbank weitere Dokumente hinzu. Dies wird uns helfen, den Prozess der Abfrage der Daten zu lernen. Sie können diese Codes kopieren und in Arangosh einfügen, um den Prozess zu emulieren.
127.0.0.1:8529@song_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:8529@song_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---"
}
Lesen von Dokumenten
Das _keyoder das Dokumenthandle kann zum Abrufen eines Dokuments verwendet werden. Verwenden Sie das Dokumenthandle, wenn die Sammlung selbst nicht durchlaufen werden muss. Wenn Sie eine Sammlung haben, ist die Dokumentfunktion einfach zu verwenden -
127.0.0.1:8529@song_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
}
So aktualisieren Sie Dokumente
Zum Aktualisieren der gespeicherten Daten stehen zwei Optionen zur Verfügung: replace und update.
Die Aktualisierungsfunktion patcht ein Dokument und führt es mit den angegebenen Attributen zusammen. Andererseits ersetzt die Ersetzungsfunktion das vorherige Dokument durch ein neues. Der Austausch erfolgt auch dann, wenn völlig andere Attribute angegeben werden. Wir werden zuerst ein zerstörungsfreies Update beobachten, bei dem das Attribut Production` in einem Song aktualisiert wird -
127.0.0.1:8529@song_collection> db.songs.update("songs/A_Man",{production:
"Top Banana"});
Ausgabe
{
"_id" : "songs/A_Man",
"_key" : "A_Man",
"_rev" : "_VjVOcqe---",
"_oldRev" : "_VjVClbW---"
}
Lassen Sie uns nun die Attribute des aktualisierten Songs lesen -
127.0.0.1:8529@song_collection> db.songs.document('A_Man');
Ausgabe
{
"_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"
}
Ein großes Dokument kann einfach mit dem aktualisiert werden update Funktion, insbesondere wenn die Attribute sehr wenige sind.
Im Gegensatz dazu ist die replace Durch die Funktion werden Ihre Daten bei Verwendung mit demselben Dokument abgeschafft.
127.0.0.1:8529@song_collection> db.songs.replace("songs/A_Man",{production:
"Top Banana"});
Lassen Sie uns nun das Lied überprüfen, das wir gerade mit der folgenden Codezeile aktualisiert haben -
127.0.0.1:8529@song_collection> db.songs.document('A_Man');
Ausgabe
{
"_key" : "A_Man",
"_id" : "songs/A_Man",
"_rev" : "_VjVRhOq---",
"production" : "Top Banana"
}
Jetzt können Sie feststellen, dass das Dokument nicht mehr die Originaldaten enthält.
So entfernen Sie Dokumente
Die Entfernungsfunktion wird in Kombination mit dem Dokumenthandle verwendet, um ein Dokument aus einer Sammlung zu entfernen.
127.0.0.1:8529@song_collection> db.songs.remove('A_Man');
Lassen Sie uns nun die Attribute des Songs, die wir gerade entfernt haben, mithilfe der folgenden Codezeile überprüfen:
127.0.0.1:8529@song_collection> db.songs.document('A_Man');
Als Ausgabe erhalten wir einen Ausnahmefehler wie den folgenden:
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
In unserem vorherigen Kapitel haben wir gelernt, wie Sie mit Arangosh, der Befehlszeile, verschiedene Operationen an Dokumenten ausführen. Wir werden nun lernen, wie dieselben Vorgänge über die Weboberfläche ausgeführt werden. Geben Sie zunächst die folgende Adresse ein: http: // your_server_ip: 8529 / _db / song_collection / _admin / aardvark / index.html # login in die Adressleiste Ihres Browsers. Sie werden zur folgenden Anmeldeseite weitergeleitet.
Geben Sie nun den Benutzernamen und das Passwort ein.
Wenn dies erfolgreich ist, wird der folgende Bildschirm angezeigt. Wir müssen eine Auswahl treffen, damit die Datenbank bearbeitet werden kann_systemDatenbank ist die Standarddatenbank. Lassen Sie uns die wählensong_collection Datenbank, und klicken Sie auf die grüne Registerkarte -
Erstellen einer Sammlung
In diesem Abschnitt erfahren Sie, wie Sie eine Sammlung erstellen. Klicken Sie oben in der Navigationsleiste auf die Registerkarte Sammlungen.
Unsere Sammlung von Songs, die über die Befehlszeile hinzugefügt wurden, ist sichtbar. Wenn Sie darauf klicken, werden die Einträge angezeigt. Wir werden jetzt eine hinzufügenartists’Sammlung über die Weboberfläche. Sammlungsongswas wir mit Arangosh erstellt haben, ist schon da. Schreiben Sie in das Feld Nameartists in dem New CollectionDialogfeld, das angezeigt wird. Erweiterte Optionen können ignoriert werden und der Standardauflistungstyp, z. B. Dokument, ist in Ordnung.
Durch Klicken auf die Schaltfläche Speichern wird die Sammlung endgültig erstellt. Jetzt werden die beiden Sammlungen auf dieser Seite angezeigt.
Füllen der neu erstellten Sammlung mit Dokumenten
Wenn Sie auf klicken, wird eine leere Sammlung angezeigt artists Sammlung -
Um ein Dokument hinzuzufügen, müssen Sie auf das Pluszeichen in der oberen rechten Ecke klicken. Wenn Sie zur Eingabe eines_key, eingeben Affable_Balding als Schlüssel.
Nun wird ein Formular angezeigt, in dem Sie die Attribute des Dokuments hinzufügen und bearbeiten können. Es gibt zwei Möglichkeiten, Attribute hinzuzufügen:Graphical und Tree. Die grafische Darstellung ist intuitiv, aber langsam. Daher wechseln wir zuCode Ansicht, mit dem Dropdown-Menü Baum, um es auszuwählen -
Um den Vorgang zu vereinfachen, haben wir Beispieldaten im JSON-Format erstellt, die Sie kopieren und dann in den Abfrageeditorbereich einfügen können.
{"Künstler": "Johnny Mercer", "Titel": "Affable Balding Me", "Komponist": "Robert Emmett Dolan", "Jahr": 1950}
(Hinweis: Es sollte nur ein Paar geschweifte Klammern verwendet werden. Siehe Abbildung unten.)
Sie können beobachten, dass wir die Schlüssel und auch die Werte im Codeansichtsmodus zitiert haben. Klicken Sie nun aufSave. Nach erfolgreichem Abschluss erscheint kurzzeitig ein grüner Blitz auf der Seite.
Lesen von Dokumenten
Um Dokumente zu lesen, kehren Sie zur Seite Sammlungen zurück.
Wenn man auf klickt artist Sammlung erscheint ein neuer Eintrag.
So aktualisieren Sie Dokumente
Es ist einfach, die Einträge in einem Dokument zu bearbeiten. Sie müssen nur auf die Zeile klicken, die Sie in der Dokumentübersicht bearbeiten möchten. Auch hier wird derselbe Abfrageeditor angezeigt wie beim Erstellen neuer Dokumente.
Dokumente entfernen
Sie können die Dokumente löschen, indem Sie auf das Symbol '-' klicken. Jede Dokumentzeile hat dieses Zeichen am Ende. Sie werden zur Bestätigung aufgefordert, um ein unsicheres Löschen zu vermeiden.
Darüber hinaus gibt es für eine bestimmte Sammlung auch andere Vorgänge wie das Filtern der Dokumente, das Verwalten von Indizes und das Importieren von Daten Collections Overview Seite.
In unserem folgenden Kapitel werden wir eine wichtige Funktion des Webinterface diskutieren, dh den AQL-Abfrage-Editor.
In diesem Kapitel werden wir diskutieren, wie die Daten mit AQL abgefragt werden. Wir haben bereits in unseren vorherigen Kapiteln besprochen, dass ArangoDB eine eigene Abfragesprache entwickelt hat und dass sie den Namen AQL trägt.
Beginnen wir jetzt mit der Interaktion mit AQL. Drücken Sie wie in der Abbildung unten gezeigt in der Weboberfläche die TasteAQL EditorRegisterkarte oben in der Navigationsleiste. Ein leerer Abfrageeditor wird angezeigt.
Bei Bedarf können Sie von der Ergebnisansicht zum Editor wechseln und umgekehrt, indem Sie oben rechts auf die Registerkarten Abfrage oder Ergebnis klicken (siehe Abbildung unten).
Der Editor verfügt unter anderem über Syntaxhervorhebungen, Funktionen zum Rückgängigmachen / Wiederherstellen und zum Speichern von Abfragen. Für eine detaillierte Referenz kann man die offizielle Dokumentation sehen. Wir werden einige grundlegende und häufig verwendete Funktionen des AQL-Abfrage-Editors hervorheben.
AQL-Grundlagen
In AQL stellt eine Abfrage das zu erreichende Endergebnis dar, nicht jedoch den Prozess, durch den das Endergebnis erzielt werden soll. Diese Funktion wird allgemein als deklarative Eigenschaft der Sprache bezeichnet. Darüber hinaus kann AQL die Daten abfragen und ändern, sodass komplexe Abfragen durch Kombinieren beider Prozesse erstellt werden können.
Bitte beachten Sie, dass AQL vollständig ACID-konform ist. Das Lesen oder Ändern von Abfragen wird entweder vollständig oder gar nicht abgeschlossen. Selbst das Lesen der Daten eines Dokuments endet mit einer konsistenten Einheit der Daten.
Wir fügen zwei neue hinzu songszu der Songsammlung, die wir bereits erstellt haben. Anstatt zu tippen, können Sie die folgende Abfrage kopieren und in den AQL-Editor einfügen:
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
Drücken Sie die Execute-Taste unten links.
Es werden zwei neue Dokumente in die geschrieben songs Sammlung.
Diese Abfrage beschreibt, wie die FOR-Schleife in AQL funktioniert. Es durchläuft die Liste der JSON-codierten Dokumente und führt die codierten Vorgänge für jedes der Dokumente in der Sammlung aus. Die verschiedenen Vorgänge können das Erstellen neuer Strukturen, das Filtern, Auswählen von Dokumenten, Ändern oder Einfügen von Dokumenten in die Datenbank sein (siehe das aktuelle Beispiel). Im Wesentlichen kann AQL die CRUD-Operationen effizient ausführen.
Um alle Songs in unserer Datenbank zu finden, führen wir erneut die folgende Abfrage aus, die a entspricht SELECT * FROM songs einer SQL-Datenbank (da der Editor die letzte Abfrage speichert, drücken Sie die Taste *New* Schaltfläche zum Reinigen des Editors) -
FOR song IN songs
RETURN song
Die Ergebnismenge zeigt die Liste der bisher gespeicherten Songs in der songs Sammlung wie im Screenshot unten gezeigt.
Operationen wie FILTER, SORT und LIMIT kann dem hinzugefügt werden For loop Körper zu verengen und das Ergebnis zu ordnen.
FOR song IN songs
FILTER song.Year > 1940
RETURN song
Die obige Abfrage gibt Songs an, die nach dem Jahr 1940 auf der Registerkarte Ergebnis erstellt wurden (siehe Abbildung unten).
In diesem Beispiel wird der Dokumentschlüssel verwendet, aber jedes andere Attribut kann auch als Äquivalent zum Filtern verwendet werden. Da der Dokumentschlüssel garantiert eindeutig ist, entspricht nicht mehr als ein einzelnes Dokument diesem Filter. Bei anderen Attributen ist dies möglicherweise nicht der Fall. Um eine Teilmenge aktiver Benutzer zurückzugeben (bestimmt durch ein Attribut namens status), sortiert nach Namen in aufsteigender Reihenfolge, verwenden wir die folgende Syntax:
FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
RETURN song
LIMIT 2
Wir haben dieses Beispiel bewusst aufgenommen. Hier beobachten wir eine Fehlermeldung zur Abfragesyntax, die von AQL rot hervorgehoben wird. Diese Syntax hebt die Fehler hervor und ist hilfreich beim Debuggen Ihrer Abfragen, wie im folgenden Screenshot gezeigt.
Lassen Sie uns nun die richtige Abfrage ausführen (beachten Sie die Korrektur) -
FOR song IN songs
FILTER song.Year > 1940
SORT song.composer
LIMIT 2
RETURN song
Komplexe Abfrage in AQL
AQL ist mit mehreren Funktionen für alle unterstützten Datentypen ausgestattet. Durch die Zuweisung von Variablen innerhalb einer Abfrage können sehr komplexe verschachtelte Konstrukte erstellt werden. Auf diese Weise rücken datenintensive Vorgänge näher an die Daten im Backend als an den Client (z. B. den Browser) heran. Um dies zu verstehen, fügen wir zunächst die willkürliche Dauer (Länge) zu den Songs hinzu.
Beginnen wir mit der ersten Funktion, dh der Update-Funktion -
UPDATE { _key: "All_Mucked" }
WITH { length: 180 }
IN songs
Wir können sehen, dass ein Dokument wie im obigen Screenshot gezeigt geschrieben wurde.
Lassen Sie uns jetzt auch andere Dokumente (Songs) aktualisieren.
UPDATE { _key: "Affable_Balding" }
WITH { length: 200 }
IN songs
Wir können jetzt überprüfen, ob alle unsere Songs ein neues Attribut haben length - -
FOR song IN songs
RETURN song
Ausgabe
[
{
"_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
}
]
Um die Verwendung anderer Schlüsselwörter von AQL wie LET, FILTER, SORT usw. zu veranschaulichen, formatieren wir jetzt die Dauer des Songs in der mm:ss Format.
Abfrage
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)
}
Dieses Mal geben wir den Songtitel zusammen mit der Dauer zurück. DasReturn Mit dieser Funktion können Sie ein neues JSON-Objekt erstellen, das für jedes Eingabedokument zurückgegeben wird.
Wir werden nun über die 'Joins'-Funktion der AQL-Datenbank sprechen.
Beginnen wir mit der Erstellung einer Sammlung composer_dob. Außerdem erstellen wir die vier Dokumente mit dem hypothetischen Geburtsdatum der Komponisten, indem wir die folgende Abfrage im Abfragefeld ausführen:
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
Um die Ähnlichkeit mit SQL hervorzuheben, präsentieren wir eine verschachtelte FOR-Loop-Abfrage in AQL, die zur REPLACE-Operation führt, die zuerst in der inneren Schleife über alle Dobs der Komponisten und dann über alle zugehörigen Songs iteriert und ein neues Dokument mit enthält Attribut song_with_composer_key anstatt der song Attribut.
Hier geht die Abfrage -
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
Lassen Sie uns nun die Abfrage ausführen FOR song IN songs RETURN song noch einmal, um zu sehen, wie sich die Liedersammlung verändert hat.
Ausgabe
[
{
"_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"
}
]
Die obige Abfrage schließt den Datenmigrationsprozess ab und fügt die hinzu composer_key zu jedem Lied.
Jetzt ist die nächste Abfrage wieder eine verschachtelte FOR-Loop-Abfrage, diesmal jedoch mit dem Join-Vorgang, bei dem jedem Song der Name des zugeordneten Komponisten hinzugefügt wird (Auswahl mit Hilfe von "composer_key").
FOR s IN songs
FOR c IN composer_dob
FILTER c._key == s.composer_key
RETURN MERGE(s,
{ composer: c.composer }
)
Ausgabe
[
{
"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 diesem Kapitel werden einige AQL-Beispielabfragen für eine Actors and MoviesDatenbank. Diese Abfragen basieren auf Diagrammen.
Problem
Gegeben eine Sammlung von Schauspielern und eine Sammlung von Filmen sowie eine Sammlung von actIn-Kanten (mit einer Jahr-Eigenschaft), um den Scheitelpunkt wie unten angegeben zu verbinden -
[Actor] <- act in -> [Movie]
Wie kommen wir -
- Alle Schauspieler, die in "movie1" ODER "movie2" mitgewirkt haben?
- Alle Schauspieler, die sowohl in "movie1" als auch in "movie2" mitgewirkt haben?
- Alle gängigen Filme zwischen "Schauspieler1" und "Schauspieler2"?
- Alle Schauspieler, die in 3 oder mehr Filmen mitgewirkt haben?
- Alle Filme, in denen genau 6 Schauspieler mitwirkten?
- Die Anzahl der Schauspieler pro Film?
- Die Anzahl der Filme nach Schauspieler?
- Die Anzahl der Filme, die zwischen 2005 und 2010 vom Schauspieler gedreht wurden?
Lösung
Während des Lösens und Erhaltens der Antworten auf die oben genannten Abfragen verwenden wir Arangosh, um das Dataset zu erstellen und Abfragen darauf auszuführen. Alle AQL-Abfragen sind Zeichenfolgen und können anstelle von Arangosh einfach auf Ihren Lieblingstreiber kopiert werden.
Beginnen wir mit der Erstellung eines Testdatensatzes in Arangosh. Laden Sie zuerst diese Datei herunter -
# wget -O dataset.js
https://drive.google.com/file/d/0B4WLtBDZu_QWMWZYZ3pYMEdqajA/view?usp=sharing
Ausgabe
...
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]
Sie können in der obigen Ausgabe sehen, dass wir eine JavaScript-Datei heruntergeladen haben dataset.js.Diese Datei enthält die Arangosh-Befehle zum Erstellen des Datasets in der Datenbank. Anstatt die Befehle einzeln zu kopieren und einzufügen, verwenden wir die--javascript.executeOption auf Arangosh, um die mehreren Befehle nicht interaktiv auszuführen. Betrachten Sie es als den Lebensretterbefehl!
Führen Sie nun den folgenden Befehl auf der Shell aus:
$ arangosh --javascript.execute dataset.js
Geben Sie das Passwort ein, wenn Sie dazu aufgefordert werden, wie Sie im obigen Screenshot sehen können. Nachdem wir die Daten gespeichert haben, werden wir die AQL-Abfragen erstellen, um die spezifischen Fragen zu beantworten, die zu Beginn dieses Kapitels aufgeworfen wurden.
Erste Frage
Lassen Sie uns die erste Frage stellen: All actors who acted in "movie1" OR "movie2". Angenommen, wir möchten die Namen aller Schauspieler finden, die in "TheMatrix" ODER "TheDevilsAdvocate" mitgewirkt haben.
Wir werden mit jeweils einem Film beginnen, um die Namen der Schauspieler zu erhalten -
127.0.0.1:8529@_system> db._query("FOR x IN ANY 'movies/TheMatrix' actsIn
OPTIONS {bfs: true, uniqueVertices: 'global'} RETURN x._id").toArray();
Ausgabe
Wir erhalten folgende Ausgabe:
[
"actors/Hugo",
"actors/Emil",
"actors/Carrie",
"actors/Keanu",
"actors/Laurence"
]
Jetzt bilden wir weiterhin eine UNION_DISTINCT aus zwei NEIGHBORS-Abfragen, die die Lösung sein werden -
127.0.0.1:8529@_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();
Ausgabe
[
"actors/Charlize",
"actors/Al",
"actors/Laurence",
"actors/Keanu",
"actors/Carrie",
"actors/Emil",
"actors/Hugo"
]
Zweite Frage
Betrachten wir nun die zweite Frage: All actors who acted in both "movie1" AND "movie2". Dies ist fast identisch mit der obigen Frage. Aber diesmal interessieren wir uns nicht für eine UNION, sondern für eine INTERSECTION -
127.0.0.1:8529@_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();
Ausgabe
Wir erhalten folgende Ausgabe:
[
"actors/Keanu"
]
Dritte Frage
Betrachten wir nun die dritte Frage: All common movies between "actor1" and "actor2". Dies ist tatsächlich identisch mit der Frage nach gemeinsamen Schauspielern in Film1 und Film2. Wir müssen nur die Startscheitelpunkte ändern. Lassen Sie uns als Beispiel alle Filme finden, in denen Hugo Weaving ("Hugo") und Keanu Reeves die Hauptrolle spielen -
127.0.0.1:8529@_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();
Ausgabe
Wir erhalten folgende Ausgabe:
[
"movies/TheMatrixReloaded",
"movies/TheMatrixRevolutions",
"movies/TheMatrix"
]
Vierte Frage
Betrachten wir nun die vierte Frage. All actors who acted in 3 or more movies. Diese Frage ist anders; Wir können die Nachbarfunktion hier nicht nutzen. Stattdessen verwenden wir den Kantenindex und die COLLECT-Anweisung von AQL für die Gruppierung. Die Grundidee ist, alle Kanten nach ihren zu gruppierenstartVertex(was in diesem Datensatz immer der Schauspieler ist). Dann entfernen wir alle Schauspieler mit weniger als 3 Filmen aus dem Ergebnis, da wir hier die Anzahl der Filme angegeben haben, in denen ein Schauspieler gespielt hat -
127.0.0.1:8529@_system> db._query("FOR x IN actsIn COLLECT actor = x._from WITH
COUNT INTO counter FILTER counter >= 3 RETURN {actor: actor, movies:
counter}"). toArray()
Ausgabe
[
{
"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
}
]
Bei den verbleibenden Fragen werden wir die Abfragebildung diskutieren und nur die Abfragen bereitstellen. Der Leser sollte die Abfrage selbst auf dem Arangosh-Terminal ausführen.
Fünfte Frage
Betrachten wir nun die fünfte Frage: All movies where exactly 6 actors acted in. Die gleiche Idee wie in der vorherigen Abfrage, jedoch mit dem Gleichheitsfilter. Jetzt brauchen wir jedoch den Film anstelle des Schauspielers, also geben wir den zurück_to attribute - -
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter FILTER
counter == 6 RETURN movie").toArray()
Die Anzahl der Schauspieler pro Film?
Wir erinnern uns in unserem Datensatz _to am Rand entspricht dem Film, also zählen wir, wie oft das gleiche _toerscheint. Dies ist die Anzahl der Schauspieler. Die Abfrage ist aber fast identisch mit denen vorher aberwithout the FILTER after COLLECT - -
db._query("FOR x IN actsIn COLLECT movie = x._to WITH COUNT INTO counter RETURN
{movie: movie, actors: counter}").toArray()
Sechste Frage
Betrachten wir nun die sechste Frage: The number of movies by an actor.
Die Art und Weise, wie wir Lösungen für unsere oben genannten Abfragen gefunden haben, hilft Ihnen auch dabei, die Lösung für diese Abfrage zu finden.
db._query("FOR x IN actsIn COLLECT actor = x._from WITH COUNT INTO counter
RETURN {actor: actor, movies: counter}").toArray()
In diesem Kapitel werden verschiedene Möglichkeiten zur Bereitstellung von ArangoDB beschrieben.
Bereitstellung: Einzelinstanz
In einem unserer vorherigen Kapitel haben wir bereits gelernt, wie die einzelne Instanz von Linux (Ubuntu) bereitgestellt wird. Lassen Sie uns nun sehen, wie die Bereitstellung mit Docker durchgeführt wird.
Bereitstellung: Docker
Für die Bereitstellung mit Docker installieren wir Docker auf unserem Computer. Weitere Informationen zu Docker finden Sie in unserem Tutorial zu Docker .
Sobald Docker installiert ist, können Sie den folgenden Befehl verwenden:
docker run -e ARANGO_RANDOM_ROOT_PASSWORD = 1 -d --name agdb-foo -d
arangodb/arangodb
Es wird die Docker-Instanz von ArangoDB mit dem identifizierenden Namen erstellt und gestartet agdbfoo als Docker-Hintergrundprozess.
Das Terminal druckt auch die Prozesskennung.
Standardmäßig ist Port 8529 für ArangoDB reserviert, um auf Anforderungen zu warten. Außerdem steht dieser Port automatisch allen Docker-Anwendungscontainern zur Verfügung, die Sie möglicherweise verknüpft haben.