Es handelt sich bei Neo4j um eine Graph Datenbank.
Es ist eine Schema optionale und ACID konforme Datenbank.
Neo4j ist im Februar 2010 erschienen und wurde in Java geschrieben.

Daten werden in Knoten (Nodes) gespeichert, jeder Knoten kann Eigenschaften besitzen. Knoten können zusätzlich Label haben, um Gruppen von Knoten zu kennzeichnen. Zwischen diesen Knoten können Kanten (Relationen) erstellt werden, auch die Kanten können Eigenschaften besitzen. Kanten können zusätzlich einen Typ haben und sind immer gerichtet, dass bedeutet sie sind entweder ein- oder ausgehend zur einem Knoten, somit hat jede Kante einen Start- und einen Endknoten.

Nachdem man die Community Version heruntergeladen hat kann man Neo4j einfach auf der Konsole starten.

sudo neo4j-community-3.4.7/bin/neo4j start

Pro Instanz stellt Neo4j einen Graphen zur Verfügung, natürlich kann man einfach zwei Graphen aufbauen. Diese existieren dann nebeneinander oder sind durch einen Root Knoten miteinander verbunden.

Das Admin Interface steht dann unter http://localhost:7474/webadmin/ zur Verfügung.

Über den Graph traversieren bedeutet die Knoten abfragen und den Kanten zu folgen.

Referenzielle Integrität wird von Neo4j verwaltet, man kann keine Knoten löschen die Kanten besitzen.

Eindeutigkeitseinschränkungen kann man mit Regeln in der Datenbank sicherstellen, um die Eigenschaftswerte für alle Knoten mit einem bestimmten Label eindeutig zu halten.

CREATE CONSTRAINT ON (n:User) ASSERT n.name IS UNIQUE
DROP CONSTRAINT ON (n:User) ASSERT n.name IS UNIQUE

HTTP API

Neo4j bietet eine transaktionssichere HTTP API. Eine JSON Datei in der folgenden Form kann als POST Request an den Server gesendet werden. Man kann mehrer Cypher Abfragen und Eigenschaften pro Abfrage vergeben.

{
"statements": [
    {
    "statement" : "UNWIND {props} as row MERGE (u:User {name: row.name})",
    "parameters" : {
        "props" : [{
        "name" : "Peter"
        },
        {
        "name" : "Hans"
        }]
    }
    },
    ...
]
}

Ein Request öffnet eine Transaktion, die Transaktion ID ist im Response enthalten.

curl -i -X POST -H "Content-Type: application/json" -d @./cypher.json http://localhost:7474/db/data/transaction
{"commit":"http://localhost:7474/db/data/transaction/1/commit", ...}

Ein zweiter Request schliesst die Transaktion ab.

curl -i -X POST -H "Content-Type: application/json" http://localhost:7474/db/data/transaction/1/commit

Cypher

Neo4j hat zusätzlich Cypher als Abfrage Sprache zur Verfügung. Mit EXPLAIN und PROFILE kann man die Performanz der Abfragen sehen.

Einen Knoten erstellen, mit Label oder Eigenschaften.

CREATE (n)
CREATE (n:User)
CREATE (n:User {name: "Peter"})

Ein zusätzliches Label zu einem bestehendem Knoten hinzufügen.

MATCH (n:User {name:"Peter"}) SET n:Admin RETURN n

Eine zusätzliche Eigenschaft zu einem bestehendem Knoten hinzufügen oder eine Eigenschaften ändern.

MATCH (n:User {name:"Peter"}) SET u.surname="Hansen" RETURN n

Einen Knoten löschen, die Referentielle Integrität erlaubt nur Knoten zu löschen die keine Kanten besitzen.

MATCH (n:User {name:"Peter"}) DELETE n

Man kann Knoten mit den Kanten zusammen löschen.

OPTIONAL MATCH (u:User)<-[r]-()
WHERE u.name = "Peter"
DELETE r, u

MATCH (u { name: "Peter" })
DETACH DELETE u

Alle Knoten mit den anderen Knoten über eine Kante verbinden.

MATCH (n:User), (m:User)
WHERE n <> m
CREATE (n)-[r:INTRODUCED]->(m)
RETURN n, m

Kanten können auch Eigenschaften haben.

MATCH (n:User), (m:User)
WHERE n <> m
CREATE (n)-[r:INTRODUCED {status: false}]->(m)
RETURN n, m

Alle Knoten abfragen und die ein- oder ausgehende Kanten.

MATCH (n) RETURN n
MATCH (n)<--(m) RETURN n
MATCH (n)-->(m) RETURN n

Die Anzahl aller Knoten ausgeben.

MATCH (n) RETURN count(n)

Alle ausgehende Kanten vom Knoten mit der Eigenschaft name gleich Peter.

MATCH (n)-->(m) WHERE n.name="Peter" RETURN m

Alle Knoten und Kanten löschen.

MATCH (n)
OPTIONAL MATCH (n)-[r]-()
DELETE n, r