In unseren Tutorials zu den Themen MySQL Datenbank erstellen und löschen, PostgreSQL 10 auf Ubuntu 16.04 / 14.04 installieren, MongoDB auf Ubuntu installieren, Apache Cassandra auf Ubuntu installieren, Redis auf Ubuntu 16.04 LTS installieren und RethinkDB auf Ubuntu installieren stellen wir dir Basisinformationen zu SQL- und NoSQL-Datenbanken bereit und machen dich u.a. damit vertraut, wie du diese installieren und konfigurieren kannst. Mit unserem Tutorial zum Thema InfluxDB unter Ubuntu 16.04/18.04 installieren und einrichten stellen wir eine neue Form von Datenbank vor, die das Konzept Datenbank im Sinne einer NoSQL-Datenbank-Plattform für Zeitreihen basierte Datenerhebungen weiter denkt und die Analyse von gespeicherten Informationen via Monitoring und Graph-Plotting fortschrittlicher werden lässt. Nun, in diesem folgenden Tutorial geht es auch um eine Graph orientierte Datenbank-Plattform, nämlich Neo4j.

Zu Neo4j

Bei Neo4j handelt es sich – wie in der Einleitung erwähnt – um eine Diagramm-Datenbank, die als Art Plattform fungiert. Neo4j ermöglicht es Daten zu verbinden und Beziehungen visuell aufbereitet im Kontext eines skalierbaren und zuverlässigen Datenbanksystems zu erkennen. Neo4j bietet seinen Service als Online-Datenbankverwaltungssystem mit Operationen zum Erstellen, Lesen, Aktualisieren und Löschen (CRUD) an. Mit all diesen Operationen kann an einem Graphdaten-Modell gearbeitet werden. Dabei wird mit einer herstellerneutralen und offenen Abfragesprache mit eigener Syntax agiert, die von der geläufigen SQL-Abfragesprache abweicht. Mit der Datenbanksprache Cypher können Muster von Knoten und Beziehungen in Graph-Datasets verglichen werden.

Wie SQL ist Cypher eine deklarative Abfragesprache, mit der Benutzer angeben können, welche Aktionen sie für ihre Diagrammdaten ausführen möchten (z. B. Übereinstimmung, Einfügen, Aktualisieren oder Löschen), ohne dass sie diese genau beschreiben oder programmieren müssen.

Das Datenmodell für eine Graphdatenbank ist wesentlich einfacher und aussagekräftiger als das von relationalen oder anderen NoSQL-Datenbanken.

Anwendungsszenario

In Neo4j besteht ein Graph aus zwei Elementen, nämlich einem Knoten und einer Beziehung. Jeder Knoten repräsentiert hierbei eine Entität (eine Person, ein Ort, eine Sache, eine Kategorie oder einen anderen Typ von Datenelement), und jede Beziehung stellt dar, wie Knoten miteinander verknüpft sind. Einem Knoten kann eine beliebige Menge von Eigenschaften zugewiesen werden. Eine Eigenschaft setzt sich hierbei aus je einem Paar aus Bezeichnung der Eigenschaft und Wert der Eigenschaft zusammen. Zum Beispiel könnte ein Knoten der Entität “Person” die Eigenschaften besitzen, die sich aus dem Namen der Person und ihrer Herkunft zusammensetzen. “Name” und “Herkunft” könnten dann jeweils Bezeichnungen der zwei Eigenschaften sein mit je einem dahinter stehenden Wert pro Knoten. Jeder Knoten einer Entität ist Element der betreffenden Entität. Elemente ein und derselben Entität lassen sich über Label gruppieren, indem für jedes Mitglied der Entität ein Label angewendet wird. So müsste jedes neue Element der Entität Person mit dem Label “Person” gekennzeichnet werden, damit die Zugehörigkeit in der Datenbank eindeutig ist.

Mit dem Graph basierten Datenbankkonzept von Neo4j lassen sich alle denkbaren Arten von Szenarien modellieren – von einem Straßensystem über ein Netzwerk von Bekanntschaften bis hin zur Demographie einer Population. Schlicht alles, was durch Beziehungen definiert werden kann, lässt sich in einem Graphen abbilden.
Für dieses Tutorial habe ich mir ein eigenes Szenario ausgedacht. Ich möchte ein Netzwerk zwischen zwei Universitäten kreieren. In diesem Netzwerk soll zum einen transportiert werden, welche Studiengänge die betreffende Universität anbietet und zum anderen soll visuell ersichtlich werden, welche Studiengänge ähnliche Studieninhalte haben.

Voraussetzung

Neo4j wird in Java implementiert, was das Vorhandensein eines Java Runtime Environment (JRE) bedingt. Hierzu werde ich einen Teil dieses Tutorials zur Installation und Einrichtung von Java unter Ubuntu widmen.

Java installieren und einrichten

Bevor du Neo4j installierst, musst du die Java-Laufzeit-Umgebung (JRE) auf deinem Server installieren. Zunächst führst du mittels dem folgenden Kommando ein Update durch.

apt-get update

apt-get upgrade

Danach installierst du dann die Software, die erforderlich ist, um Java-Anwendungen auszuführen. Für vergangene Versionen würdest du einfach die Versionsnummer im unten eingeblendeten Kommando austauschen.

apt-get install openjdk-8-jre

Als nächstes installierst du via dem unten gezeigten Kommando das „IcedTea“-Java-Plugin, das nötig ist, um Java in Webseiten zu verwenden. Das besagte Plugin funktioniert mit Firefox, Chromium Chrome, Konqueror und Epiphany.

apt-get install icedtea-8-plugin

Die Installation von Java auf dem Server reicht nicht aus. Zusätzlich ist es notwendig die Umgebungsvariable zu setzen, die via $JAVA_HOME erreichbar ist.
Um zu prüfen, ob diese bereits gesetzt ist und vielleicht angepasst werden muss oder gar fehlt, führen wir das folgende Kommando aus. Wenn du kein Output erhälst, ist die Umgebungsvariable nicht gesetzt.

echo $JAVA_HOME

Um die Umgebungsvariable schließlich zu definieren, ist die Information über den Pfad wichtig, unter dem die Java JRE installiert wurde.

Der folgende Befehl

which java

oder der Befehl unterhalb

whereis java

können dir dazu dienen, dies herauszufinden. Beide werden dir als Output den jre-Pfad in /usr/bin/java wiedergeben. Hierbei handelt es sich dann aber nicht um die aktuelle jre-Datei, sondern um eine Art symbolischem Link, der weiterführend Aufschluss zum Standort bzw. zum Pfad der aktuellen jre-Datei geben kann. Diese Information in Kombination mit dem Kommando-Präfix readlink -f liefert dir als Output dann letztlich den korrekten Pfad.

readlink -f /usr/bin/java

Mit Hilfe der beiden im Code-Snippet unten präsentierten Kommentare setze ich letztlich die Umgebungsvariable. In meinem Beispiel ist der Pfad, unter dem Java JRE installiert wurde /usr/lib/jvm/java-8-openjdk-amd64/jre/bin.

JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/jre/bin

PATH=$JAVA_HOME/bin:$PATH

Neo4j installieren und einrichten

Bevor du Neo4j installierst, musst du den Repository-Schlüssel dem Repository hinzufügen. Hierzu führst du das folgende Kommando im Terminal aus.

wget --no-check-certificate -O - https://debian.neo4j.org/neotechnology.gpg.key | apt-key add -

Daraufhin bindest du das Repository via dem folgenden Kommando in die Liste der apt-Quellen ein.

echo 'deb http://debian.neo4j.org/repo stable/' > /etc/apt/sources.list.d/neo4j.list

Hiernach führst du mittels der unten aufgeführten Kommandozeile ein Update des Repositories durch und installierst Neo4j.

apt-get update && apt-get install neo4j

Danach sollte der Server automatisch gestartet sein und auch über den Server-Boot neu gestartet werden. Bevor du Neo4j allerdings auch nutzen kannst, musst du in der Konfigurationsdatei ein paar Anpassungen vornehmen, die darauf hinauslaufen, dass du drei als Kommentar kenntlich gemachte Zeilen auskommentierst. In der Konfigurationsdatei werden Kommentare mit einer vorstehenden Raute kenntlich gemacht, also mit #. Um eine Zeile wieder einzukommentieren, musst du die jeweilige Raute entfernen. Hierfür öffnest du die Konfigurationsdatei im nano-Editor, indem du den untenstehenden Befehl ausführst.

nano /etc/neo4j/neo4j.conf

Im nano-Editor suchst du dann nach den Zeilen Code, die im Snippet unten zu sehen sind. Durch Entfernen der davorstehenden Raute machst du diese drei Inhalte wieder lesbar. Im Anschluss daran leitest du das Speichern deiner Updates mit der Tastenkombination aus Strg und O ein und bestätigst den daraufhin in einem weißen Balken eingeblendeten Dateinamen mit der Taste Enter.

#dbms.connectors.default_listen_address=0.0.0.0 

#dbms.connector.https.enabled=true 

#dbms.connector.https.listen_address=:7473

#dbms.connector.bolt.listen_address=:7687

Schließlich startest du dann noch den Service von Neo4j mit dem unten aufgeführten Kommando.

service neo4j start

Getting started mit Neo4j Browser

Sobald du die Installation und die Anpassungen in der Konfigurationsdatei abgeschlossen hast, sollte es dir möglich sein, den Datenbank-Server zu erreichen, indem du die URL http://localhost:7474/browser/ in deinem Browser aufrufst, wobei du localhost mit der IP-Adresse deines Servers austauschen musst.

Sollte Neo4j Browser danach nicht abrufbar sein, dann führe in deiner Konsole die beiden unten eingeblendeten Befehle aus und versuche es im Anschluss erneut via URL in deinem Browser.

service neo4j stop

service neo4j start

Neo4j Browser ist ein Kommando-gesteuerter Client, der wie eine webbasierte Shell-Umgebung funktioniert. Hier kannst du u.a. Graph-Abfragen mit der Datenbanksprache Cypher schreiben und ausführen, oder dir die Tabellen eines bestimmten Abfrageergebnisses exportieren lassen oder die REST API von Neo4j praktisch erkunden.

Nach erfolgreicher Umsetzung, wirst du auf die Anmeldeseite von Neo4j weitergeleitet, was du dem Screenshot unten entnehmen kannst. Hier wirst du neben dem Host nach dem Usernamen und dem Passwort gefragt. Der Host ist bolt://localhost:7687. Auch hier musst du localhost mit der IP-Adresse deines Servers austauschen, falls dies nicht per default schon beim Aufrufen der Seite im Browser korrekt für das betreffende Eingabefeld generiert wurde. Auch ist bereits ein default-Username generiert worden, wie du erkennst. Es ist dir noch nicht möglich, dich mit einem von dir gewählten Passwort anzumelden. Zunächst musst du ein Passwort erstellen. Hierzu meldest du dich erst einmal unter dem default-Username und dem default-Passwort in der Datenbank-Plattform an. Das default-Passwort entspricht dem default-Username. In beiden Fällen ist es neo4j.

Daraufhin gelangst du auf eine Seite, auf der du die Möglichkeit hast, dein Passwort zu erstellen und dieses durch erneute Eingabe sicherzustellen.

Mit Klick auf den Change password-Button bestätigst du das Passwort und gelangst auf die Hauptseite von Neo4j.

Durch Klick auf den grünen Neo4j Browser Sync-Button oder den obersten Menüpunkt (rotes Cloud-Icon) in der unteren Hälfte der links eingeblendeten Menüleiste, wird direkt neben der Menüleiste eine Schaltfläche eingeblendet, in der du eine Checkmark-Box ankreuzen und im Anschluss daran den Sign in/Register-Button betätigen kannst, um die Neo4j Browser-Synchronisation durchzuführen.

Wenn diese aktiv ist, ist das Cloud-Icon in der Menüleiste bei MouseOver-Effekt oder bei Betätigung nicht mehr rot, sondern grün und du kannst Neo4j Browser im vollen Umfang nutzen. Du kannst das Cloud-Icon jederzeit klicken, um die Einstellungen dahingehend zu ändern, dass du nach Belieben die Browser-Synchronisation ausschaltest oder einschaltest. Hierzu bietet der Sign-Out-Button in der eingeblendeten Schaltfläche direkt neben der Menüleiste analog zum Sign in/Register-Button die Möglichkeit. Ist die Browser-Synchronisation aktiv, ist es dir jederzeit möglich lokale Daten zu löschen, indem du den Clear local data-Button nutzt.

Wenn du das ebenfalls in der Menüleiste befindliche Zahnrad-Icon betätigst, wird eine Schaltfläche eingeblendet, in der du die Browser-Settings ändern kannst.

Wie dir der Screenshot unten präsentiert, bietet dir der letzte Menüpunkt in der Menüleiste formale Informationen zu Neo4j, wie über die Lizenz und über die auf deinem Server laufende Version.

Der dritte Menüpunkt (Dokument-Icon) in der oberen Hälfte der Menüleiste bietet dir in der ausgeklappten Schaltfläche eine Reihe von unterstützenden Links, die dir den Einstieg in die Nutzung von Neo4j und die Datenbanksprache Cypher erleichtern. Die Links sind grob in zwei Arten zu unterscheiden. Wie dir der Screenshot unten vor Auge führt, gibt es dort Links, vor denen ein Pfeil- oder Fragezeichen-Icon platziert ist, und welche, bei denen dies nicht der Fall ist. Bei letzteren handelt es sich um externe Links, die sich in der Sparte Useful Resources befinden und zu weiterführenden Informationen und Handbüchern führen. Hierfür öffnet sich dann ein neues Browser-Fenster.
Bei der ersteren Kategorie von genannten Links handelt es sich eher um Button-Typen, die bei Betätigung ein Kommando in die von Neo4j mitgelieferte Kommandozeile generieren. Wenn du daraufhin in die Kommandozeile klickst und die Enter-Taste betätigst, lässt sich das generierte Kommando ausführen. Hinter dem jeweiligen generierten Kommando steht dann ein in Neo4j integriertes Tutorial, dass dir das hinter dem angeklickten Button stehende Thema Step-by-Step nahe bringt. So kannst du z.B. Graph-Szenarien anhand einer vorgegebenen Anleitung nachsimulieren oder beispielhaft Queries auf Basis der Sprache Cypher nachempfinden und ein Gefühl dafür bekommen, welche Art von Projekt geeignet ist und wie du dieses mit Neo4j umsetzen kannst.
Im Screenshot unten habe ich beispielhaft den Button Basic graph concepts angeklickt und damit das Kommando :play concepts in der Kommandozeile generiert.

Daraufhin wird – wie im Screenshot unten abgebildet – das Tutorial Graph Fundamentals eingeblendet, das Step-by-Step durchgearbeitet werden kann.

Die Kommandozeile dient quasi als Editor und ist die primäre Schnittstelle zum Eingeben und Ausführen von Befehlen. Hier gibst du schließlich dann auch Cypher-Abfragen ein, um mit Diagrammdaten zu arbeiten. Du kannst die Kommandozeile entweder für die einzeilige Bearbeitung nutzen, wenn sich dein Anliegen mittels kurzen Abfragen oder Befehlen umsetzen lässt. Oder du nutzt die Kommandozeile zur mehrzeiligen Bearbeitung, indem du mit der Tastenkombination Shift+Enter Zeilen hinzufügst. Eine Abfrage führst du dann mit der Tastenkombination Strg+Enter aus. Vergangene Abfragen lassen sich jederzeit wieder abrufen, da diese in der unterhalb der Kommandozeile befindlichen Historie behalten lassen, solange du diese nicht löscht.

Einen Graphen erstellen

Da sich ein Graph aus Knoten und Beziehungen zusammensetzt, müssen diese zunächst via Kommandozeile angelegt werden, um sich den Graphen im Neo4j Browser schließlich ausgeben lassen zu können. Hierzu dient das aus SQL bekannte CREATE-Statement, wobei die Syntax letztlich durch Cypher definiert ist.

Wie die Syntax des CREATE-Statements in Cypher aussieht, entnimmst du dem Code-Snippet unten.

CREATE (identifier:label {property1:value1, property2:value2 ...})

Da ein Graph erst aus mindestens einer Beziehung heraus entstehen kann und letztlich eine Beziehung im Graphen mindestens zwei in einer Relation zueinander stehende Knoten bedingt, müssen via CREATE-Statement mindestens zwei Identifier ein und demselben Label zugeordnet werden und entsprechend die Beziehung zwischen den Elementen via spezieller Syntax definiert werden.

Anstelle jedes neue Element und jede neue Beziehung zwischen Elementen via CREATE-Statement zu implementieren, ist es möglich, eine Reihe von Elementen eines Labels und deren Beziehungen zueinander in einem einzelnen CREATE-Statement an die Datenbasis weiterzureichen.

Die Syntax eines vollständigen CREATE-Statements würde dem Inhalt gleichen, der dir im folgenden Code-Block präsentiert wird. Die Syntax sieht es vor, dass für jedes neue Element einer Entität, eine selbst gewählte Identifier-Bezeichnung gewählt und der hinter der Entität stehenden Label-Bezeichnung zugewiesen wird. Bei allen Elementen des Labels ist die Bezeichnung des Labels dieselbe, lediglich die Identifier-Bezeichnung ändert sich, damit die Elemente in der Datenbasis differenzierbar sind. Jedem Element kann eine beliebige Anzahl an Eigenschaften mittels Property-Value-Paaren zugeschrieben werden. Im Code-Block unten habe ich beispielhaft fünf Elemente implementiert, die teilweise jeweils über eine unterschiedliche Anzahl an Property-Value-Paaren verfügen. Unterhalb der Syntax zur Definition der Elemente eines Labels entnimmst du die Syntax, die notwendig ist, um Relationen zwischen den Elementen herzustellen. Hierbei sind pro Relation, die beiden an der betreffenden Relation teilnehmenden Identifier, in runde Klammern gesetzt und der Name der Relation befindet sich in eckigen Klammern und wird mit einem Doppelpunkt eingeleitet. Eine Relation kann variabel mit einer zusätzlichen Menge an Attribut-Wert-Paaren versehen werden.

Schließlich dient das RETURN-Statement, um sich die implementierten Informationen ausgeben zu lassen.

CREATE (identifier1:label {property1:value1, property2:value2}),
(identifier2:label {property1:value1}),
(identifier3:label {property1:value1, property2:value2}),
(identifier4:label {property1:value1, property2:value2, property3:value3}),
(identifier5:label {property1:value1, property2:value2}),

(identifier1)-[:RELATION {attribute1:value1}]->(identifier2),
(identifier1)-[:RELATION]->(identifier3),
(identifier2)-[:RELATION]->(identifier3),
(identifier2)-[:RELATION]->(identifier4),
(identifier3)-[:RELATION]->(identifier2),
(identifier3)-[:RELATION]->(identifier5),
(identifier4)-[:RELATION]->(identifier5)

RETURN identifier1, identifier2, identifier3, identifier4, identifier5

Eine Query wird mittels dem Stichwort MATCH eingeleitet. MATCH fungiert analog dem aus SQL bekannten SELECT. Der folgenden Code-Snippet verdeutlicht dir, wie sich die Syntax hierbei zusammensetzt. Nach dem Stichwort MATCH wird im Sinne eines pattern ausgedrückt, was gesucht wird. Nach dem Stichwort WHERE wird im Sinne von conditions eine oder mehrer Bedingung gesetzt, falls notwendig. Somit ist der WHERE-Bestandteil der Anfrage wie auch die WHERE-Klausel beim SQL-SELECT-Statement variabel. Wie im Code-Snippet oben, dient auch bei einer Query das RETURN dazu, eine Reihe von Elementen anzusprechen, auf die sich die Ausgabe der Ergebnisse beziehen soll. Hier werden ebenfalls die Identifier aufgerufen. Wenn man einen Identifier in Kombination in Bezug auf bestimmte Properties ausgeben lassen möchte und nicht mit allen seinen Eigenschaften, ruft man bei RETURN den betreffenden Identifier in Kombination mit der entsprechenden Property – getrennt mit einem Punkt – auf. Mit Bezug auf den unten eingeblendeten Code-Snippet würde dies im expressions-Platzhalter passieren.

MATCH pattern WHERE conditions RETURN expressions

Das im Code-Snippet oben integrierte pattern kann entweder ein Element z.B. nach dem Schema (identifier:label) enthalten oder eine komplette Relation z.B. nach dem Schema (identifier:label)-[:RELATION]->(identifier:label).
Im conditions-Platzhalter können dann eine oder mehrere Bedingung(en) nach dem Schema identifier.property = value gesetzt werden, um die Ergebnismenge der Query zu spezifizieren. Mittels den Booleschen Operatoren lassen sich mehrere Bedingungen dann je nach erforderlicher Logik miteinander verbinden.

Die Syntax von Cypher beinhaltet neben dem CREATE– und MATCH-Statement die Nutzung weiterer Statements. Hierzu bietet der Neo4j Browser, Tutorials, deren Kommandos via Klick auf die im Screenshot gehighlighteten Buttons in die Kommandozeile generiert werden und via Betätigung der Enter-Taste aufgerufen werden können.

Anknüpfend an das im Kapitel Anwendungsszenario beschriebene Szenario, werde ich dieses nun in den Neo4j Browser implementieren.
Der Graph soll via der Relation PROVIDES zeigen, welche Studiengänge die betreffende Universität anbietet und mittels einer weiteren Relation, nämlich der Relation IS_SIMILAR_WITH, soll demonstriert werden, welche Studiengänge ähnliche Inhalte haben. Der Graph bildet zwei Entitäten/Labels ab, bzw. Elemente dieser zwei Entitäten. Zum einen gibt es Elemente der Entität University und zum anderen gibt es Elemente der Entität StudiesCourse.
Der unten abgebildete Code-Block reflektiert, wie das CREATE-Statement für mein Beispiel zum Anwendungsszenario aussieht. Den Code kannst du via Copy&Paste in die Kommandozeile des Neo4j Browsers implementieren und mit der Tastenkombination Strg+Enter ausführen.

CREATE
(university_cologne:University {name: "University of Cologne", location: "Cologne"}),
(university_dusseldorf:University {name: "Heinrich Heine University", location: "Dusseldorf"}),

(ancient_culture:StudiesCourse {name: "Ancient Culture"}),
(ancient_languages_culture:StudiesCourse {name: "Ancient languages and cultures"}),
(archeology:StudiesCourse {name: "Archeology"}),
(art:StudiesCourse {name: "Art"}),
(art_history:StudiesCourse {name: "Art History"}),
(biochemistry:StudiesCourse {name: "Biochemistry"}),
(biology:StudiesCourse {name: "Biology"}),
(chemistry:StudiesCourse {name: "Chemistry"}),
(china_studies:StudiesCourse {name: "China Studies"}),
(communication_media_studies:StudiesCourse {name: "Communication and media studies"}),
(computer_linguistics:StudiesCourse {name: "Computer Linguistics"}),
(computer_science:StudiesCourse {name: "Computer Science"}),
(earth_sciences:StudiesCourse {name: "Earth Sciences"}),
(economics:StudiesCourse {name: "Economics"}),
(educational_sciences:StudiesCourse {name: "Educational Sciences"}),
(english_studies:StudiesCourse {name: "English Studies"}),
(ethnology:StudiesCourse {name: "Ethnology"}),
(geography:StudiesCourse {name: "Geography"}),
(german_languages_literature:StudiesCourse {name: "German Languages and Literature"}),
(history:StudiesCourse {name: "History"}),
(information_processing:StudiesCourse {name: "Information Processing"}),
(information_science:StudiesCourse {name: "Information Science"}),
(intermedia:StudiesCourse {name: "Intermedia"}),
(japanese_culture_pp:StudiesCourse {name: "Japanese Culture in Past and Present"}),
(japanese_studies:StudiesCourse {name: "Japanese Studies"}),
(law:StudiesCourse {name: "Law"}),
(linguistics:StudiesCourse {name: "Linguistics"}),
(literary_translation:StudiesCourse {name: "Literary Translation"}),
(mathematics:StudiesCourse {name: "Mathematics"}),
(media_culture_studies:StudiesCourse {name: "Media and Culture Studies"}),
(media_studies:StudiesCourse {name: "Media Studies"}),
(medicine:StudiesCourse {name: "Medicine"}),
(pedagogy:StudiesCourse {name: "Pedagogy"}),
(pharmacy:StudiesCourse {name: "Pharmacy"}),
(philosophy:StudiesCourse {name: "Philosophy"}),
(physics:StudiesCourse {name: "Physics"}),
(political_economy:StudiesCourse {name: "Political Economy"}),
(political_science:StudiesCourse {name: "Political Science"}),
(politics:StudiesCourse {name: "Politics"}),
(psychology:StudiesCourse {name: "Psychology"}),
(romance_languages_literature:StudiesCourse {name: "Romance Languages and Literature"}),
(yiddish_cll:StudiesCourse {name: "Yiddish Culture, Language and Literature"}),
(social_sciences_ssdg:StudiesCourse {name: "Social Sciences – Social Structures and Democratic Governance"}),
(sociology:StudiesCourse {name: "Sociology"}),

(university_dusseldorf)-[:PROVIDES]->(ancient_culture),
(university_dusseldorf)-[:PROVIDES]->(art_history),
(university_dusseldorf)-[:PROVIDES]->(biochemistry),
(university_dusseldorf)-[:PROVIDES]->(biology),
(university_dusseldorf)-[:PROVIDES]->(chemistry),
(university_dusseldorf)-[:PROVIDES]->(communication_media_studies),
(university_dusseldorf)-[:PROVIDES]->(computer_linguistics),
(university_dusseldorf)-[:PROVIDES]->(computer_science),
(university_dusseldorf)-[:PROVIDES]->(economics),
(university_dusseldorf)-[:PROVIDES]->(german_languages_literature),
(university_dusseldorf)-[:PROVIDES]->(history),
(university_dusseldorf)-[:PROVIDES]->(information_science),
(university_dusseldorf)-[:PROVIDES]->(japanese_studies),
(university_dusseldorf)-[:PROVIDES]->(law),
(university_dusseldorf)-[:PROVIDES]->(linguistics),
(university_dusseldorf)-[:PROVIDES]->(literary_translation),
(university_dusseldorf)-[:PROVIDES]->(mathematics),
(university_dusseldorf)-[:PROVIDES]->(media_culture_studies),
(university_dusseldorf)-[:PROVIDES]->(medicine),
(university_dusseldorf)-[:PROVIDES]->(pharmacy),
(university_dusseldorf)-[:PROVIDES]->(philosophy),
(university_dusseldorf)-[:PROVIDES]->(physics),
(university_dusseldorf)-[:PROVIDES]->(political_economy),
(university_dusseldorf)-[:PROVIDES]->(political_science),
(university_dusseldorf)-[:PROVIDES]->(psychology),
(university_dusseldorf)-[:PROVIDES]->(romance_languages_literature),
(university_dusseldorf)-[:PROVIDES]->(yiddish_cll),
(university_dusseldorf)-[:PROVIDES]->(social_sciences_ssdg),
(university_dusseldorf)-[:PROVIDES]->(sociology),

(university_cologne)-[:PROVIDES]->(ancient_languages_culture),
(university_cologne)-[:PROVIDES]->(archeology),
(university_cologne)-[:PROVIDES]->(art),
(university_cologne)-[:PROVIDES]->(art_history),
(university_cologne)-[:PROVIDES]->(biochemistry),
(university_cologne)-[:PROVIDES]->(biology),
(university_cologne)-[:PROVIDES]->(chemistry),
(university_cologne)-[:PROVIDES]->(china_studies),
(university_cologne)-[:PROVIDES]->(earth_sciences),
(university_cologne)-[:PROVIDES]->(economics),
(university_cologne)-[:PROVIDES]->(educational_sciences),
(university_cologne)-[:PROVIDES]->(english_studies),
(university_cologne)-[:PROVIDES]->(ethnology),
(university_cologne)-[:PROVIDES]->(geography),
(university_cologne)-[:PROVIDES]->(german_languages_literature),
(university_cologne)-[:PROVIDES]->(history),
(university_cologne)-[:PROVIDES]->(information_processing),
(university_cologne)-[:PROVIDES]->(intermedia),
(university_cologne)-[:PROVIDES]->(japanese_culture_pp),
(university_cologne)-[:PROVIDES]->(law),
(university_cologne)-[:PROVIDES]->(mathematics),
(university_cologne)-[:PROVIDES]->(media_culture_studies),
(university_cologne)-[:PROVIDES]->(media_studies),
(university_cologne)-[:PROVIDES]->(medicine),
(university_cologne)-[:PROVIDES]->(pedagogy),
(university_cologne)-[:PROVIDES]->(philosophy),
(university_cologne)-[:PROVIDES]->(physics),
(university_cologne)-[:PROVIDES]->(politics),
(university_cologne)-[:PROVIDES]->(psychology),

(ancient_culture)-[:IS_SIMILAR_WITH]->(ancient_languages_culture),
(ancient_languages_culture)-[:IS_SIMILAR_WITH]->(ancient_culture),
(art)-[:IS_SIMILAR_WITH]->(art_history),
(art_history)-[:IS_SIMILAR_WITH]->(art),
(biochemistry)-[:IS_SIMILAR_WITH]->(biology),
(biochemistry)-[:IS_SIMILAR_WITH]->(chemistry),
(biology)-[:IS_SIMILAR_WITH]->(biochemistry),
(chemistry)-[:IS_SIMILAR_WITH]->(biochemistry),
(communication_media_studies)-[:IS_SIMILAR_WITH]->(media_culture_studies),
(communication_media_studies)-[:IS_SIMILAR_WITH]->(intermedia),
(communication_media_studies)-[:IS_SIMILAR_WITH]->(media_studies),
(media_culture_studies)-[:IS_SIMILAR_WITH]->(communication_media_studies),
(media_culture_studies)-[:IS_SIMILAR_WITH]->(intermedia),
(media_culture_studies)-[:IS_SIMILAR_WITH]->(media_studies),
(intermedia)-[:IS_SIMILAR_WITH]->(communication_media_studies),
(intermedia)-[:IS_SIMILAR_WITH]->(media_culture_studies),
(intermedia)-[:IS_SIMILAR_WITH]->(media_studies),
(media_studies)-[:IS_SIMILAR_WITH]->(communication_media_studies),
(media_studies)-[:IS_SIMILAR_WITH]->(media_culture_studies),
(media_studies)-[:IS_SIMILAR_WITH]->(intermedia),
(computer_linguistics)-[:IS_SIMILAR_WITH]->(computer_science),
(computer_linguistics)-[:IS_SIMILAR_WITH]->(information_science),
(computer_linguistics)-[:IS_SIMILAR_WITH]->(information_processing),
(computer_science)-[:IS_SIMILAR_WITH]->(computer_linguistics),
(computer_science)-[:IS_SIMILAR_WITH]->(information_science),
(computer_science)-[:IS_SIMILAR_WITH]->(information_processing),
(information_science)-[:IS_SIMILAR_WITH]->(computer_linguistics),
(information_science)-[:IS_SIMILAR_WITH]->(computer_science),
(information_science)-[:IS_SIMILAR_WITH]->(information_processing),
(information_processing)-[:IS_SIMILAR_WITH]->(computer_linguistics),
(information_processing)-[:IS_SIMILAR_WITH]->(computer_science),
(information_processing)-[:IS_SIMILAR_WITH]->(information_science),
(politics)-[:IS_SIMILAR_WITH]->(political_economy),
(political_economy)-[:IS_SIMILAR_WITH]->(politics),
(politics)-[:IS_SIMILAR_WITH]->(political_science),
(political_science)-[:IS_SIMILAR_WITH]->(politics)

RETURN university_dusseldorf, university_cologne, ancient_culture, ancient_languages_culture, archeology, art, art_history, biochemistry, biology, chemistry, china_studies, communication_media_studies, computer_linguistics, computer_science, earth_sciences, economics, educational_sciences, english_studies, ethnology, geography, german_languages_literature, history, information_processing, information_science, intermedia, japanese_culture_pp, japanese_studies, law, linguistics, literary_translation, mathematics, media_culture_studies, media_studies, medicine, pedagogy, pharmacy, philosophy, physics, political_economy, political_science, politics, psychology, romance_languages_literature, yiddish_cll, social_sciences_ssdg, sociology

Nach der Ausführung, wird das Output in einem hierfür generierten Frame auf vier Weisen zur Verfügung gestellt, die du via der zur linken Seite des Frames eingeblendeten Leiste erreichst, wie du dem Screenshot unten entnimmst. Hier kannst du dir das Output entweder als Graphen, im Tabellen- oder Textformat oder als Quellcode anzeigen lassen. Zusätzlich bieten sechs Werkzeug-Icons die Möglichkeit, mit dem betreffenden Output-Format in Interaktion zu treten. Diese Icons befinden sich oben rechts im Output-Frame. Via dem ersten Icon ist es dir möglich, das betreffende Output-Format entweder als .png oder.svg-Datei auf deinen Rechner zu exportieren. Des Weiteren kannst du die Icons u.a. nutzen, um den Output-Frame zu pinnen, das Fenster des Frames zu expandieren, neu zu laden oder zu löschen.

Der Screenshot unten verbildlicht dir, wie die Export-Datei dann aussehen würde. Falls die Knoten im Output-Frame unvorteilhaft zusammengewürfelt sind, sodass man nicht mehr durchblickt, kannst du die Knoten via Drag&Drop bewegen und an eine vorteilhaftere Stelle navigieren.

Alternativ zum RETURN im oben gezeigten Code-Block, hätte das RETURN auch so aussehen können, wie im unten eingeblendeten Code-Snippet. Dann wären jedoch zunächst lediglich die Knoten/Elemente zur Entität University abgebildet worden und erst mit Doppelklick auf den betreffende Knoten wären die Knoten/Elemente der Entität StudiesCourse mit in das Output generiert worden.

RETURN university_dusseldorf, university_cologne

Wenn du das erste Icon (Datenbank-Icon) in der linken Menüleiste des Neo4j Browsers aufrufst, hast du einen guten Überblick über die im Neo4j Browser verwendeten Knoten-Label, sowie die Relationen und die Identifier der Eigenschaften.

Via Klick auf das zweite Icon (Stern-Icon) in der linken Menüleiste, wird eine Schaltfläche generiert, in der du entweder die Möglichkeit hast, Dateien mit vorgefertigten Datenbank-Statements hochzuladen und diese in von dir angelegten Ordnern für einen jederzeit verfügbaren Zugriff abzuspeichern oder default-Beispiel-Skripte aufzurufen und dir diese in der Kommandozeile ausführen zu lassen, um zu sehen, was daraufhin passiert.

Fazit

Es hat mir Freude gemacht, dir bei der Installation und Einrichtung von Neo4j zu helfen und dir die Datenbank nahe zu bringen. Du hast Neo4j als eine moderne Datenbankplattform kennen gelernt, die es dir ermöglicht, interaktiv im Browser via Datenbanksprache Cypher Projekte anzulegen, Queries zu stellen, Graphen zu bestimmten Projekten zu erzeugen und diese zu exportieren und in der Datenbank jederzeit wieder auffindbar zu machen. Ich wünsche dir viel Erfolg und Spaß bei der Umsetzung deiner Ideen.

Aus unserer Rubrik zu Open Source Datenbanken und Datenbank-Plattformen auch noch interessant und hilfreich:

• ArangoDB unter Ubuntu 16.04 installieren und einrichten
• OrientDB unter Ubuntu 16.04/18.04 installieren und einrichten
• Elasticsearch und der ELK-Stack unter Ubuntu 16.04/18.04
• Apache CouchDB unter Ubuntu 16.04/18.04 installieren und einrichten
• Microsoft SQL Server unter Ubuntu 16.04/18.04 installieren und einrichten

Zurück zur Tutorial Übersicht Back to Tutorial Overview