TOC

So installieren und verwenden Sie ArangoDB unter Ubuntu 14.04

Einführung

ArangoDB ist eine NoSQL-Datenbank. Es wurde 2011 erstellt, als es bereits viele NoSQL-Datenbanken gab, mit dem Ziel, eine umfassende Datenbanklösung zu schaffen, die eine Vielzahl von Anwendungsfällen abdecken kann.

Im Kern von ArangoDB befindet sich ein document store, aber das ist nur der Anfang. Sie können Daten mit einer vollwertigen Abfragesprache (AQL) abfragen, ACID ​​-Transaktionen durchführen und benutzerdefinierte HTTP-Endpunkte in Form von JavaScript-Anwendungen mit dem folgenden https hinzufügen: //developers.google.com/v8/[embedded V8] und mehr.

Da ArangoDB viele Funktionen hat, könnte es zunächst einschüchternd sein, aber nach einem zweiten Blick ist es überhaupt nicht kompliziert. Dieser Artikel hilft Ihnen bei der Installation von ArangoDB und gibt eine kurze Einführung in die Verwendung einiger seiner Hauptfunktionen.

Nach Abschluss dieses Tutorials sollten Sie in der Lage sein:

  • Installieren Sie ArangoDB unter Ubuntu 14.04

  • Konfigurieren Sie ArangoDB für den Basisgebrauch

  • Daten einfügen, ändern und abfragen

Kernkonzepte

Im gesamten Artikel werden wir einige Kernkonzepte verwenden. Sie möchten sich wahrscheinlich mit ihnen vertraut machen, bevor Sie ein Projekt auf ArangoDB erstellen:

  • Document Store: ArangoDB speichert Daten in Dokumenten, im Gegensatz zu relationalen Datenbanken. Dokumente sind beliebige Datenstrukturen, die aus Schlüssel-Wert-Paaren bestehen. Der key ist eine Zeichenfolge, die den value benennt (wie eine Spalte in einer relationalen Datenbank). Der Wert kann ein beliebiger Datentyp sein, auch ein anderes Dokument. Dokumente sind an kein Schema gebunden.

  • Query Language: Interagieren Sie mit Ihren Daten entweder über eine API oder eine Abfragesprache. Während Ersteres dem API-Benutzer viele Details überlässt, übergibt eine Abfragesprache die Details an die Datenbank. In einer relationalen Datenbank ist SQL ein Beispiel für eine Abfragesprache.

  • ACID: Die vier Eigenschaften A tomicity, C onsistency, I solation und D urability beschreiben die Garantien von Datenbanktransaktionen. ArangoDB unterstützt ACID-kompatible Transaktionen.

  • V8: Die JavaScript-Engine von Google, die Chrome unterstützt, kann problemlos in andere Software eingebettet werden. Die Verwendung in ArangoDB ermöglicht die Verwendung von JavaScript in der Datenbank. Ein Großteil der internen Funktionen von ArangoDB wird mit JavaScript erstellt.

  • HTTP-API: ArangoDB bietet eine HTTP-API, mit der Clients mit der Datenbank interagieren können. Die API ist resource oriented und kann mit JavaScript erweitert werden.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Ihr Droplet korrekt eingerichtet ist:

  • Erstelle ein Droplet mit Ubuntu 14.04 x64

  • Fügen Sie einen sudo user hinzu.

Jetzt sollten Sie sich mit dem neu erstellten Benutzer bei Ihrem Server anmelden. Alle Beispiele im Lernprogramm können über das Basisverzeichnis des Benutzers ausgeführt werden:

cd ~

Schritt 1 - Installation von ArangoDB

ArangoDB ist für viele Betriebssysteme und Distributionen vorgefertigt. Die Chance ist groß, dass Sie es nicht aus der Quelle erstellen müssen. Weitere Informationen finden Sie in der ArangoDB unter documentation. Für dieses Tutorial verwenden wir Ubuntu 14.04 x64.

Da ArangoDB den OpenSUSE-Dienst build verwendet, müssen Sie zunächst den öffentlichen Schlüssel für seine Repositorys herunterladen:

wget https://www.arangodb.com/repositories/arangodb2/xUbuntu_14.04/Release.key

Sie benötigen + sudo +, um den Schlüssel zu installieren:

sudo apt-key add Release.key

Fügen Sie als nächstes das Apt-Repository hinzu und aktualisieren Sie den Index:

sudo apt-add-repository 'deb https://www.arangodb.com/repositories/arangodb2/xUbuntu_14.04/ /'
sudo apt-get update

Installieren Sie ArangoDB:

sudo apt-get install arangodb

Wir können überprüfen, ob alles gut gelaufen ist, indem wir die HTTP-API abfragen:

curl http://localhost:8529/_api/version

Die folgende Ausgabe zeigt an, dass ArangoDB aktiv ist:

Output{"server":"arango","version":"2.5.5"}

Schritt 2 - Zugreifen auf die Befehlszeile mit Arangosh

ArangoDB wird mit + arangosh + ausgeliefert, einem Befehlszeilen-Client, mit dem Sie über die JavaScript-Laufzeit uneingeschränkt auf die Datenbank zugreifen können. Sie können es verwenden, um administrative Aufgaben oder Skripts in der Produktion auszuführen.

Es eignet sich auch gut für den Einstieg in ArangoDB und seine Kernfunktionen. Um mitzumachen, starte eine + arangosh + Sitzung wie folgt:

arangosh

Das Ergebnis ist im Grunde eine JavaScript-Shell, in der Sie beliebigen JavaScript-Code ausführen können. Fügen Sie beispielsweise zwei Zahlen hinzu:

23 + 19

Sie erhalten das folgende Ergebnis:

Output42

Wenn Sie tiefer in dieses Thema eintauchen möchten, geben Sie "+ Tutorial +" in die Shell ein.

Schritt 3 - Hinzufügen eines Datenbankbenutzers

Aus Sicherheitsgründen können Benutzer nur über die Befehlszeilenschnittstelle "+ arangosh " hinzugefügt werden. Sie sollten sich immer noch in der " arangosh +" - Shell des vorherigen Schritts befinden.

Nun fügen wir einen neuen Benutzer hinzu, * sammy *. Dieser Benutzer hat Zugriff auf die gesamte Datenbank. Dies ist vorerst in Ordnung, aber Sie möchten möglicherweise eingeschränktere Benutzer in einer Produktionsumgebung erstellen. Verwenden Sie ein sicheres ++.

require("org/arangodb/users").save("", "");

Verlasse nun die + arangosh + Shell:

exit

Schritt 4 - Konfigurieren des Webinterface

ArangoDB wird mit einer sehr leistungsfähigen Weboberfläche ausgeliefert. Es bietet Überwachungsfunktionen, Durchsuchen von Daten, interaktive API-Dokumentation, einen leistungsstarken Abfrageeditor und sogar ein integriertes "+ arangosh +". Wir werden uns auf die Verwendung der Weboberfläche konzentrieren, um Sie an dieses Tutorial zu erinnern.

Um das Webinterface leicht zugänglich zu machen, müssen wir einige Vorbereitungen treffen:

  1. Aktivieren Sie die Authentifizierung

  2. Binden Sie ArangoDB an die öffentliche Netzwerkschnittstelle

Authentifizierung aktivieren

ArangoDB wird wie viele andere NoSQL-Datenbanken mit deaktivierter Authentifizierung ausgeliefert. Es wird dringend empfohlen, die Authentifizierung zu aktivieren, wenn Sie ArangoDB in einer freigegebenen Umgebung ausführen und / oder die Webschnittstelle verwenden möchten. Weitere Informationen zu diesem Thema finden Sie in der Dokumentation zu ArangoDB.

Aktivieren Sie die Authentifizierung in der Datei "+ / etc / arangodb / arangod.conf ". Sie können diesen Befehl ausführen, um eine Sicherungsdatei zu erstellen und den Parameter " disable-authentication" auf "+ no +" zu setzen:

sudo sed -i.bak 's/disable-authentication = yes/disable-authentication = no/g' /etc/arangodb/arangod.conf

Verwenden Sie alternativ einen Texteditor, um den Parameter "+ disable-authentication " auf " no +" zu setzen.

Starten Sie die Datenbank neu:

sudo service arangodb restart

Binden Sie ArangoDB an die öffentliche Netzwerkschnittstelle

Konfigurieren Sie ArangoDB so, dass es die öffentliche Netzwerkschnittstelle überwacht. Öffnen Sie zuerst die Datei + / etc / arangodb / arangodb.conf zum Bearbeiten:

sudo nano /etc/arangodb/arangod.conf

Suchen Sie die aktive Zeile "+ Endpunkt ", die sich am Ende des Blocks " [Server] " unter einem Abschnitt mit Beispielen befinden sollte. Aktualisieren Sie die Einstellung wie unten gezeigt, indem Sie die IP-Adresse Ihres eigenen Servers und den Port " 8529 +" verwenden.

/etc/arangodb/arangod.conf

. . .

endpoint = tcp://:8529

Da "+ arangosh " seine eigene Standardkonfiguration verwendet, müssen wir den Endpunkt auch in der Datei " /etc/arangodb/arangosh.conf +" ändern:

sudo nano /etc/arangodb/arangosh.conf

Stellen Sie erneut sicher, dass die Zeile "+ endpoint " auf " tcp: //: 8529 +" gesetzt ist.

/etc/arangodb/arangosh.conf

pretty-print = true

[server]
endpoint = tcp://:8529
disable-authentication = true

. . .

Starten Sie nun ArangoDB erneut:

sudo service arangodb restart

Schritt 5 - Zugriff auf das ArangoDB-Webinterface

Jetzt sollten Sie in Ihrem Browser auf das Webinterface zugreifen können:

http://:8529

Bitte melden Sie sich mit dem Benutzernamen und Passwort an, die Sie in Schritt 3 für die Datenbank erstellt haben.

Der erste Bildschirm, den Sie sehen sollten, ist das Dashboard mit grundlegenden Metriken zum Datenbankserver:

Bild: https://assets.digitalocean.com/articles/arangodb-ubuntu1404/iKDjIgx.png [Das Dashboard der ArangoDB-Weboberfläche]

In der Mitte der oberen Navigation sehen Sie * DB: _system *. Dies zeigt die aktuell ausgewählte Datenbank an. Die Standardeinstellung ist die Datenbank "+ _system ". Bestimmte administrative Aufgaben können nur in der Datenbank " _system +" ausgeführt werden.

In den folgenden Abschnitten erstellen wir eine Datenbank, mit der Sie arbeiten können. Bewegen Sie den Mauszeiger über den Menüpunkt * DB: _system * und klicken Sie auf den Link * DBs verwalten *.

Klicken Sie auf der folgenden Seite auf die Schaltfläche * Datenbank hinzufügen *. Füllen Sie das Formular aus, um eine Datenbank mit dem Namen "+ music_library +" zu erstellen. Sie müssen in diesem Dialogfeld denselben Benutzernamen und dasselbe Kennwort wie zuvor eingeben, sonst können Sie später nicht mehr auf die neue Datenbank zugreifen:

image: https://assets.digitalocean.com/articles/arangodb-ubuntu1404/DA8kRTO.png [Neue Datenbank in der Weboberfläche erstellen]

Jetzt können wir anfangen, etwas mit ArangoDB zu tun.

Schritt 6 - CRUD-Operationen mit arangosh ausführen

Wir werden das Webinterface vorerst verlassen und zur Kommandozeilenschnittstelle "+ arangosh +" zurückkehren, um grundlegende CRUD-Operationen in ArangoDB zu behandeln. Später werden wir die gleichen Vorgänge in der Webschnittstelle noch einmal behandeln, aber wenn wir dies in der Shell tun, können wir besser verstehen, wie die Dinge funktionieren.

Kehren Sie zur Befehlszeile für Ihren Server zurück, um fortzufahren. Verbinde dich mit deinem Benutzer und Passwort mit der neuen + music_library + Datenbank:

arangosh --server.database music_library --server.username  --server.password

Erstellen Sie eine Dokumentensammlung

Wenn Sie aus einer relationalen Datenbank stammen, ist eine Sammlung das ArangoDB-Äquivalent einer Tabelle in einer SQL-Datenbank. Wir werden eine Sammlung erstellen, um Songs in unserer Musikbibliothek zu speichern:

db._createDocumentCollection('songs')

ArangoDB bietet eine Reihe von Methoden zum Verwalten von Sammlungen. Die meisten von ihnen sind derzeit nicht von Interesse, aber bitte schauen Sie sie sich an, wenn Sie weiter in ArangoDB vorankommen. Im Moment konzentrieren wir uns auf CRUD-Vorgänge (Erstellen, Lesen, Aktualisieren und Löschen) - das heißt, wie tatsächliche Daten in die Datenbank und aus der Datenbank abgerufen werden.

Dokumente erstellen

Wo Sie Zeilen in einer SQL-basierten Datenbank hätten, hat ArangoDB Documents. Dokumente in ArangoDB sind JSON-Objekte. Jedes Dokument ist einer Sammlung zugeordnet und verfügt über drei Hauptattribute: "+ _id ", " _rev " und " _key +".

Ein Dokument wird in einer Datenbank durch sein document handle eindeutig identifiziert, das aus dem Sammlungsnamen und dem durch ein "+ / " getrennten " _key " besteht. Das Dokumenthandle wird im Feld " _id " eines Dokuments gespeichert. Sowohl das " _key " als auch das " _id +" ähneln dem Primärschlüssel in einer Beziehungsdatenbank.

Fügen wir Ihr erstes Dokument zur "+ songs" -Sammlung hinzu:

db.songs.save(
{ title: "Immigrant Song", album: "Led Zeppelin III", artist: "Led Zeppelin", year: 1970, length: 143, _key: "immigrant_song" }
)
Output{
 "error" : false,
 "_id" : "songs/immigrant_song",
 "_rev" : "11295857653",
 "_key" : "immigrant_song"
}

Das + db + Objekt enthält alle Sammlungen als Eigenschaften. Jede Sammlung bietet Funktionen zur Interaktion mit den Dokumenten in dieser Sammlung. Die Funktion "+ save +" nimmt ein beliebiges JSON-Objekt und speichert es als Dokument in der Auflistung. Dabei werden die oben genannten Kernattribute zurückgegeben und es wird überprüft, ob ein Fehler aufgetreten ist. Die Rückkehr von jeder Operation ist wieder ein JSON-Objekt.

Um etwas zum Spielen zu haben, brauchen wir noch ein paar Dokumente. Kopieren Sie einfach das nächste Snippet und fügen Sie es ein, um der Datenbank weitere Einträge hinzuzufügen:

db.songs.save(
{album: "Led Zeppelin III", title: "Friends", artist: "Led Zeppelin", year: 1970, length: 235, _key: "friends"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Celebration Day", artist: "Led Zeppelin", year: 1970, length: 209, _key: "celebration_day"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Since I've Been Loving You", artist: "Led Zeppelin", year: 1970, length: 445, _key: "since_i_ve_been_loving_you"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Out On the Tiles", artist: "Led Zeppelin", year: 1970, length: 244, _key: "out_on_the_tiles"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Gallows Pole", artist: "Led Zeppelin", year: 1970, length: 298, _key: "gallows_pole"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Tangerine", artist: "Led Zeppelin", year: 1970, length: 192, _key: "tangerine"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "That's the Way", artist: "Led Zeppelin", year: 1970, length: 338, _key: "that_s_the_way"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Bron-Y-Aur Stomp", artist: "Led Zeppelin", year: 1970, length: 260, _key: "bron_y_aur_stomp"}
);

db.songs.save(
{album: "Led Zeppelin III", title: "Hats Off to (Roy) Harper", artist: "Led Zeppelin", year: 1970, length: 221, _key: "hats_off_to_roy_harper"}
);

Dokumente lesen

Zum Abrufen eines Dokuments können Sie entweder das Dokument-Handle oder die Taste "+ _" verwenden. Das Verwenden des Dokument-Handles ist nur erforderlich, wenn Sie die Sammlung selbst nicht durchgehen. Wenn Sie eine Sammlung haben, können Sie die Funktion "+ document" verwenden:

db.songs.document('immigrant_song');
Output{
 "year" : 1970,
 "length" : 143,
 "title" : "Immigrant Song",
 "album" : "Led Zeppelin III",
 "artist" : "Led Zeppelin",
 "_id" : "songs/immigrant_song",
 "_rev" : "11295857653",
 "_key" : "immigrant_song"
}

Jetzt, da wir Dokumente erstellen und lesen können, werden wir untersuchen, wie Sie sie ändern können:

Dokumente aktualisieren

Bei der Aktualisierung Ihrer Daten haben Sie zwei Möglichkeiten: https://docs.arangodb.com/Documents/DocumentMethods.html#replace [+ replace +] und https://docs.arangodb.com/Documents/DocumentMethods .html # update [+ update +].

Die Funktion "+ Ersetzen +" ersetzt das gesamte Dokument durch ein neues, auch wenn Sie völlig andere Attribute angeben.

Die "+ update " - Funktion verbindet ein Dokument lediglich mit den angegebenen Attributen. Versuchen wir zuerst ein weniger destruktives " Update", bei dem wir das "+ Genre" eines unserer Songs aktualisieren:

db.songs.update("songs/immigrant_song",

{ genre: "Hard Rock" }

);

Werfen wir einen Blick auf den aktualisierten Titeleintrag:

db.songs.document("songs/immigrant_song");
Output{
 "year" : 1970,
 "length" : 143,
 "title" : "Immigrant Song",
 "album" : "Led Zeppelin III",
 "artist" : "Led Zeppelin",
 "genre" : "Hard Rock",
 "_id" : "songs/immigrant_song",
 "_rev" : "11421424629",
 "_key" : "immigrant_song"
}

Die Funktion "+ update +" ist besonders hilfreich, wenn Sie ein großes Dokument haben und nur eine kleine Teilmenge seiner Attribute aktualisieren müssen.

Im Gegensatz dazu werden Ihre Daten zerstört, wenn Sie denselben JSON-Code mit der Funktion "+ replace +" verwenden.

db.songs.replace("songs/immigrant_song",

{ genre: "Hard Rock" }

);

Sehen Sie sich jetzt das aktualisierte Lied an:

db.songs.document("songs/immigrant_song")

Wie Sie sehen, wurden die Originaldaten aus dem Dokument entfernt:

Output{
 "genre" : "Hard Rock",
 "_id" : "songs/immigrant_song",
 "_rev" : "11495939061",
 "_key" : "immigrant_song"
}

Dokumente entfernen

Um ein Dokument aus einer Sammlung zu entfernen, rufen Sie die Funktion + remove + mit dem Dokument-Handle auf:

db.songs.remove("songs/immigrant_song")

Während die "+ arangosh +" - Shell ein großartiges Werkzeug ist, ist es umständlich, die anderen Funktionen von ArangoDB zu erkunden. Als nächstes werden wir uns die eingebaute Weboberfläche ansehen, um mehr über ihre Funktionen zu erfahren.

Schritt 7 - CRUD-Operationen mit dem Webinterface ausführen

Wir haben gesehen, wie mit Dokumenten auf dem "+ arangosh " umgegangen wird, und kehren jetzt zur Weboberfläche zurück. Besuchen Sie " http: //: 8529 / _db / music_library +" in Ihrem Browser.

Erstellen Sie eine Dokumentensammlung

Klicken Sie in der oberen Navigationsleiste auf die Registerkarte * Sammlungen *.

Sie können die vorhandene Sammlung "+ songs +", die wir hinzugefügt haben, über die Befehlszeile anzeigen. Klicken Sie einfach darauf und sehen Sie sich die Einträge an, wenn Sie möchten.

Klicken Sie auf der Hauptseite * Sammlungen * auf die Schaltfläche * Sammlung hinzufügen *.

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/V05LxrP.png [Sammlung im Webinterface hinzufügen]

Da wir bereits "+ songs " haben, werden wir eine " albums " - Sammlung hinzufügen. Geben Sie im daraufhin angezeigten Dialogfeld "Neue Sammlung" " Alben +" als * Name * ein. Der Standardtyp * Dokument * ist in Ordnung.

Klicken Sie auf * Speichern * und Sie sollten jetzt zwei Sammlungen auf der Seite sehen.

Klicken Sie auf die Sammlung "+ Albums +". Sie erhalten eine leere Sammlung:

image: https: //assets.digitalocean.com/articles/arangodb-ubuntu1404/d8qIcmh.png [Sammlungsansicht]

Dokumente erstellen

Klicken Sie oben rechts auf das Zeichen * + *, um ein Dokument hinzuzufügen. Sie werden zuerst nach einem + _key + gefragt. Geben Sie als Schlüssel "+ led_zeppelin_III +" ein.

Als nächstes gibt es ein Formular, in dem Sie den Inhalt eines Dokuments bearbeiten können. Es gibt eine grafische Möglichkeit, Attribute mit dem Namen * Tree * hinzuzufügen. Wechseln Sie jedoch zunächst in die Ansicht * Code *, indem Sie sie aus dem Dropdown-Menü * Tree * auswählen:

image: https://assets.digitalocean.com/articles/arangodb-ubuntu1404/0DfPNao.png [Dokument erstellen]

Kopieren Sie den folgenden JSON-Code und fügen Sie ihn in den Editorbereich ein (stellen Sie sicher, dass Sie nur einen Satz geschweifte Klammern verwenden):

{
"name": "Led Zeppelin III",
"release_date": "1970-10-05",
"producer": "Jimmy Page",
"label": "Atlantic",
"length": 2584
}

Beachten Sie, dass die Schlüssel in diesem Modus in Anführungszeichen gesetzt werden müssen. Wenn Sie fertig sind, klicken Sie auf die Schaltfläche * Speichern *. Die Seite sollte einen Moment lang grün blinken, um einen erfolgreichen Speichervorgang anzuzeigen.

Dokumente lesen

Nach dem Speichern des neuen Dokuments müssen Sie manuell zur Seite "Sammlungen" zurückkehren.

Wenn Sie auf die Sammlung "+ Albums +" klicken, wird der neue Eintrag angezeigt.

Dokumente aktualisieren

Um den Inhalt eines Dokuments zu bearbeiten, klicken Sie einfach in der Dokumentübersicht auf die Zeile, die Sie bearbeiten möchten. Sie erhalten denselben Editor wie beim Erstellen neuer Dokumente.

Dokumente entfernen

Das Löschen von Dokumenten ist so einfach wie das Drücken des Symbols * - * am Ende jeder Dokumentzeile. Bestätigen Sie den Löschvorgang, wenn Sie dazu aufgefordert werden.

Darüber hinaus können Sie auf der Übersichtsseite * Sammlungen * für eine bestimmte Sammlung Daten exportieren und importieren, Indizes verwalten und die Dokumente filtern.

Wie bereits erwähnt, hat das Webinterface viel zu bieten. Alle Funktionen werden in diesem Lernprogramm nicht behandelt. Sie können die anderen Funktionen daher auch selbst erkunden. In diesem Tutorial werden wir nur auf eine weitere Funktion eingehen: den AQL-Editor.

Schritt 8 - Abfragen der Daten mit AQL

Wie in der Einführung erwähnt, wird ArangoDB mit einer vollwertigen Abfragesprache namens AQL ausgeliefert.

Um mit AQL in der Weboberfläche zu interagieren, klicken Sie in der oberen Navigation auf die Registerkarte * AQL Editor *. Sie erhalten einen leeren Editor.

Verwenden Sie die Registerkarten * Abfrage * und * Ergebnis * in der oberen rechten Ecke, um zwischen dem Editor und der Ergebnisansicht zu wechseln:

image: https://assets.digitalocean.com/articles/arangodb-ubuntu1404/eKTShDh.png [Der AQL-Editor]

Der Editor verfügt über Syntaxhervorhebungs-, Rückgängig- / Wiederherstellungs- und Abfragespeicherungsfunktionen. Im folgenden Abschnitt werden einige der Funktionen von AQL erläutert. Eine vollständige Referenz finden Sie unter comprehensive documentation.

AQL-Grundlagen

AQL ist eine deklarative Sprache, dh eine Abfrage drückt aus, welches Ergebnis erzielt werden soll, aber nicht, wie es erreicht werden soll. Es ermöglicht das Abfragen von Daten, aber auch das Ändern der Daten. Beide Ansätze können kombiniert werden, um komplexe Aufgaben zu lösen.

Das Lesen und Ändern von Abfragen in AQL ist vollständig ACID-kompatibel. Operationen werden entweder ganz oder gar nicht beendet. Sogar das Lesen von Daten erfolgt anhand einer konsistenten Momentaufnahme der Daten.

Wir beginnen erneut mit der Erstellung von Daten. Fügen wir unserer Sammlung "+ songs +" weitere Titel hinzu. Kopieren Sie einfach die folgende Abfrage und fügen Sie sie ein:

FOR song IN [

{ album: "Led Zeppelin", title: "Good Times Bad Times", artist: "Led Zeppelin", length: 166, year: 1969, _key: "good_times_bad_times" }

,

{ album: "Led Zeppelin", title: "Dazed and Confused", artist: "Led Zeppelin", length: 388, year: 1969, _key: "dazed_and_confused" }

,

{ album: "Led Zeppelin", title: "Communication Breakdown", artist: "Led Zeppelin", length: 150, year: 1969, _key: "communication_breakdown" }

]

INSERT song IN songs

Klicken Sie auf die Schaltfläche * Senden *.

Diese Abfrage ist bereits ein gutes Beispiel für die Funktionsweise von AQL: Sie durchlaufen mit "+ FOR +" eine Liste von Dokumenten und führen für jedes Dokument eine Operation aus. Die Liste kann ein Array mit JSON-Objekten oder eine beliebige Sammlung in Ihrer Datenbank sein. Zu den Vorgängen gehören Filtern, Ändern, Auswählen weiterer Dokumente, Erstellen neuer Strukturen oder (wie in diesem Beispiel) Einfügen von Dokumenten in die Datenbank. Tatsächlich unterstützt AQL auch alle CRUD-Operationen.

Führen Sie die folgende Abfrage aus, um eine Übersicht aller Titel in der Datenbank zu erhalten. Es ist das Äquivalent eines "+ SELECT * FROM songs +" in einer SQL-basierten Datenbank (da sich der Editor die letzte Abfrage merkt, sollten Sie auf das Papierkorbsymbol klicken, um den Editor zu löschen):

FOR song IN songs RETURN song

Jetzt werden alle Einträge aus der Songdatenbank im Textfeld angezeigt. Gehen Sie zurück zur Registerkarte * Abfrage * und löschen Sie den Editor erneut.

Ein weiteres Beispiel beinhaltet die grundlegende Filterung für Songs oberhalb einer Spielzeit von drei Minuten:

FOR song IN songs

FILTER song.length > 180

RETURN song

Das Ergebnis wird auf der Registerkarte * Ergebnis * des Editors angezeigt:

image: https://assets.digitalocean.com/articles/arangodb-ubuntu1404/tFZRf5R.png [Abfrageergebnis]

Komplexes AQL-Beispiel

AQL wird mit einem Funktionssatz für alle unterstützten Datentypen geliefert und ermöglicht sogar die Zugabe neuer Funktionen. . In Kombination mit der Möglichkeit, Variablen innerhalb einer Abfrage zuzuweisen, können Sie sehr komplexe Konstrukte erstellen. Auf diese Weise können Sie datenintensive Vorgänge näher an die Daten selbst heranrücken, anstatt sie auf dem Client auszuführen. Um dies zu veranschaulichen, formatieren wir die Dauer eines Songs wie folgt:

FOR song IN songs

FILTER song.length > 180

LET minutes = FLOOR(song.length / 60)

LET seconds = song.length % 60

RETURN

{ title: song.title, duration: CONCAT_SEPARATOR(':', minutes, seconds) }

Dieses Mal geben wir nur den Songtitel zusammen mit der Dauer zurück. Mit + RETURN + können Sie ein neues JSON-Objekt erstellen, das für jedes Eingabedokument zurückgegeben wird.

AQL ist eine komplexe Sprache mit vielen Funktionen. Aber es gibt noch eine weitere erwähnenswerte Funktion, insbesondere im Zusammenhang mit NoSQL-Datenbanken: Joins.

Schließt sich AQL an

Die Verwendung eines Dokumentenspeichers als Datenbank hat verschiedene Auswirkungen. Sie sollten Ihre Daten anders modellieren als bei Verwendung einer relationalen Datenbank.

In einem Dokumentenspeicher können Sie Daten einbetten, die ansonsten als Beziehung modelliert würden. Dieser Ansatz ist jedoch nicht immer möglich. Es gibt Fälle, in denen eine Beziehung viel sinnvoller ist. Ohne die Fähigkeit, die Datenbank die erforderlichen Verknüpfungen ausführen zu lassen, würden Sie am Ende die Daten auf dem Client verbinden oder Ihr Datenmodell denormalisieren und Unterdokumente einbetten. Dies ist insbesondere bei komplexen und großen Datenmengen problematisch.

Machen wir also einen Join.

Um diese Funktion zu veranschaulichen, ersetzen wir das Attribut "+ album " der Songs durch einen Verweis auf die Sammlung " albums +". Das Album Led Zeppelin III haben wir bereits als Dokument erstellt. Bitte gehen Sie zurück und fügen Sie das Album erneut hinzu, wenn Sie es im vorherigen Beispiel gelöscht haben.

Diese Abfrage wird zum Trick:

FOR album IN albums

FOR song IN songs

FILTER song.album == album.name

LET song_with_album_ref = MERGE(UNSET(song, 'album'),

{ album_key: album._key }

)

REPLACE song WITH song_with_album_ref IN songs

Wir durchlaufen zuerst alle Alben und suchen dann alle Songs, denen dieses Album zugeordnet ist. Der nächste Schritt besteht darin, ein neues Dokument zu erstellen, das das Attribut "+ album_key " und " UNSET " das Attribut " album " enthält. Wir werden " REPLACE" und nicht "+ UPDATE" verwenden, um die Songdokumente zu aktualisieren. Dies ist möglich, weil wir zuvor ein neues Songdokument erstellt haben.

Nach dieser Datenmigration können wir das Albumdokument jetzt an einem Ort aufbewahren. Beim Abrufen der Songdaten können wir den Albumnamen mithilfe eines Joins erneut zu den Songdokumenten hinzufügen:

FOR song IN songs

FOR album IN albums

FILTER album._key == song.album_key

RETURN MERGE(song,

{ album: album.name }

)

Wir haben die Oberfläche dessen, was mit AQL erreicht werden kann, kaum abgekratzt, aber Sie sollten einen guten Eindruck davon haben, was möglich ist. Eine vollständige Sprachreferenz und weitere Beispiele finden Sie in der ausführlichen documentation.

(Optional) Schritt 9 - Backups erstellen

Sie sollten über Backups nachdenken, sobald Sie eine ArangoDB-Datenbank in Betrieb genommen haben. Es ist jedoch empfehlenswert, vorher Backups zu erstellen.

Die Verwendung der Backup-Funktion von DigitalOcean ist ein guter Anfang. Darüber hinaus möchten Sie möglicherweise die Verwendung von https://docs.arangodb.com/Arangodump [+ arangodump +] und https://docs.arangodb.com/Arangorestore [+ arangorestore +] genauer untersuchen Kontrolle darüber, was gesichert werden soll und wo die Backups gespeichert werden sollen.

(Optional) Schritt 10 - Upgrade durchführen

Wenn eine neue Version von ArangoDB veröffentlicht wird, wird diese über das konfigurierte Paket-Repository veröffentlicht. Um die neueste Version zu installieren, müssen Sie zuerst den Repository-Index aktualisieren:

sudo apt-get update

Stoppen Sie nun die Datenbank:

sudo service arangodb stop

Aktualisieren Sie es auf die neueste Version:

sudo apt-get install arangodb

Möglicherweise müssen Sie die Datenbankdateien selbst aktualisieren:

sudo service arangodb upgrade

Starten Sie danach den Server wie gewohnt:

sudo service arangodb start

ArangoDB mit Foxx-Anwendungen erweitern

Bevor wir fertig sind, sollten wir noch eines erwähnen: Da ArangoDB über eine integrierte V8-Engine verfügt, die das gesamte JavaScript verarbeitet, und über einen integrierten HTTP-Server, können wir die vorhandene HTTP-API um benutzerdefinierte Endpunkte erweitern. Diese Funktionalität heißt Foxx.

Foxx ist ein Framework zur Verwendung von ArangoDB, um benutzerdefinierte Microservices mit persistenten Daten zu erstellen. Foxx-Apps sind in JavaScript geschrieben und werden im V8-Kontext von ArangoDB ausgeführt. Die App hat direkten Zugriff auf die native JavaScript-Oberfläche und kann somit ohne HTTP-Roundtrips auf die Daten zugreifen. Foxx bietet ein minimales Framework im Sinne von Sinatra für Ruby oder Flask für Python. Sie schreiben Controller, um eingehende Anforderungen zu verarbeiten und die Geschäftslogik in Modellen zu implementieren.

Foxx-Apps können über das Webinterface verwaltet und wie jede andere App entwickelt werden. Sie können sie der Versionskontrolle unterstellen und sogar direkt aus einem Git-Repository bereitstellen. Da es sich nur um JavaScript handelt, ist das Testen von Einheiten unkompliziert. Für einfache Anwendungsfälle ähneln sie gespeicherten Prozeduren in einem relationalen Datenbanksystem, aber Foxx-Code ist viel einfacher zu warten und zu testen.

Die Verwendung von Foxx-Apps als gespeicherte Prozeduren ist nur der Anfang. Stellen Sie sich vor, Sie haben mehrere Anwendungen, die eine bestimmte Geschäftslogik gemeinsam haben. Mit Foxx können Sie diese Geschäftslogik näher an die Daten heranrücken, um die Verarbeitung zu beschleunigen und die Komplexität der Verteilung der gemeinsam genutzten Implementierung auf die Komponenten zu verringern. Wenn Sie ArangoDB als Cluster ausführen, müssen Sie sogar dafür sorgen, dass Foxx-Apps für jedes Mitglied im Cluster verfügbar sind.

Mit Foxx sind sogar ganze Webanwendungen möglich. Durch die Verwendung von Frontend-Frameworks wie Angular oder Ember können Sie Anwendungen vollständig aus der Datenbank ausführen. Hierfür wird keine zusätzliche Infrastruktur benötigt. In einer Produktionsumgebung würden Sie eventuell Nginx oder ähnliches vor ArangoDB setzen. ArangoDB wird mit einigen Foxx-Apps geliefert, die allgemeine Funktionen wie Authentifizierung und einen Sitzungsspeicher bereitstellen. Sie können auch npm-Pakete verwenden, wenn diese nicht auf der HTTP-Funktionalität basieren.

Eine gute Einführung in Foxx finden Sie unter cookbook.

Fazit

ArangoDB ist eine leistungsstarke Datenbank mit einer Vielzahl von unterstützten Anwendungsfällen. Es ist gut gepflegt und hat eine sehr gute Dokumentation. Der Einstieg ist einfach, da es Pakete für jedes wichtige Betriebssystem gibt. Die Webschnittstelle verringert die Belastung durch das Erkunden der Funktionen. Wenn Sie einen relationalen Hintergrund haben, unterscheidet sich die Verwendung von AQL nicht wesentlich von der Verwendung von SQL.

Durch die Möglichkeit, die Datenbank mit JavaScript-Anwendungen und den Grafikfunktionen zu erweitern, wird ArangoDB zu einem vollständigen Paket, mit dem eine Anwendung gestartet und erweitert werden kann.

Bisher haben wir das große Bild von ArangoDB geteilt.

Als nächste Schritte empfehlen wir Folgendes:

  • Für jede reale Anwendung interagieren Sie mit der HTTP-API. Wir haben es hier nicht behandelt, weil Sie es höchstwahrscheinlich nicht direkt verwenden werden, sondern über einen der vielen native language drivers.

  • Die Interaktion mit den Daten in ArangoDB erfolgt die meiste Zeit über AQL. Die Gewöhnung ist ein Muss, wenn Sie ArangoDB in einer Produktionsumgebung verwenden möchten.

  • ArangoDB ist nicht nur ein Dokumentenspeicher, sondern verfügt auch über sehr leistungsstarke Grafikfunktionen. Sie können Ihre Daten als Eckpunkte in einem gerichteten Diagramm modellieren. Relationen können als Kanten zwischen diesen Scheitelpunkten modelliert werden, anstatt "+ _key +" - Referenzen zu verwenden. Das Modellieren Ihrer Daten auf diese Weise kann gegenüber dem relationalen Ansatz, der in SQL-Datenbanken verwendet wird, Vorteile haben.

Related