Graphdatenbanken

Speichern Daten als Knoten (Nodes) und Kanten (Relationships)
Optimiert für stark vernetzte Daten und Traversierungsabfragen
Relevante Systeme

Neo4j
Amazon Neptune
Apache TinkerPop & JanusGraph
TigerGraph
TigerGraph
Oracle
Azure Cosmos DB
DuckPGQ

Unterschied zu RDBMS: keine JOINs nötig – Beziehungen sind first-class citizens
Abfragesprachen/API

Cypher
SPARQL
Gremlin API

Anwendungsfälle

Labeled Property Graph

Bestandteile

Knoten (Node): repräsentiert eine Entität
Label: Typ-Markierung eines Knotens (Person, Stadt …)
Kante (Relationship): gerichtete Verbindung mit Typ
Properties: Key-Value-Paare auf Knoten und Kanten

Knowledge Graphs

Übersicht

Semantisches Netz aus Entitäten, Konzepten und Fakten
Basis: RDF-Triples oder Property-Graph
Ontologien beschreiben Typen und Relationen
Reasoning: automatisches Schlussfolgern aus bekannten Fakten

Bekannte Knowledge Graphs

Google Knowledge Graph: 500 Mrd. Fakten (Search)
Wikidata: öffentlich, 100 Mio. Entitäten
DBpedia: extrahiert aus Wikipedia
Microsoft Satori: Bing-Suchmaschine
Enterprise KGs: Pharma, Finanzwesen, Medien

GQL & SQL/PGQ: ISO-Graphstandards

GQL – Graph Query Language (ISO 2024)

Erster eigenständiger ISO-Standard für Graphabfragen (ISO/IEC 39075)
Basiert auf openCypher, PGQL, G-CORE und GSQL
Deklarativ, musterbasiert wie Cypher
Definiert: Graphtypen, Schemata, Musterabgleich, Komposition
Unterstützt gerichtete und ungerichtete Kanten, Mehrfachkanten

SQL/PGQ (ISO 2023)

Erweiterung von SQL:2023 um Property-Graph-Abfragen
Graph-Mustersuche eingebettet in SQL (GRAPH_TABLE)
Erlaubt JOINs zwischen Graphmustern und relationalen Tabellen

GQL Beispiel

-- GQL: Freunde zweiten Grades
MATCH (a:Person WHERE a.name = 'Alice')
      -[:KENNT]->(b:Person)
      -[:KENNT]->(c:Person)
WHERE NOT EXISTS {
  MATCH (a)-[:KENNT]->(c)
}
RETURN c.name AS Empfehlung

SQL/PGQ Beispiel

-- SQL/PGQ: Freunde von Alice
SELECT person_b.name
FROM GRAPH_TABLE (social_graph
  MATCH (a IS Person)
        -[IS KENNT]->(b IS Person)
  WHERE a.name = 'Alice'
  COLUMNS (b.name AS name)
) AS person_b

Abfragesprache Cypher

Deklarative Abfragesprache für Neo4j (seit 2011)
Musterabgleich mit ASCII-Art-Notation
(n) = Knoten, -[r]-> = gerichtete Kante

// Knoten anlegen
CREATE (a:Person {name: "Alice", age: 32})
CREATE (b:Person {name: "Bob"})

// Beziehung anlegen
MATCH (a:Person {name: "Alice"}),
      (b:Person {name: "Bob"})
CREATE (a)-[:KENNT {seit: 2018}]->(b)

// Abfrage: alle Freunde von Alice
MATCH (a:Person {name: "Alice"})
      -[:KENNT]->(friend)
RETURN friend.name

Abfragesprache SPARQL

W3C-Standard für RDF Triple Stores
Abfragen basieren auf Triple-Mustern: ?s ?p ?o
SPARQL-Endpunkte: HTTP-Interface für Linked Data

-- foaf - friend of a friend
PREFIX ex: <http://example.org/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

-- Alle Personen aus Berlin
SELECT ?name ?age
WHERE {
  ?person a foaf:Person ;
          foaf:name ?name ;
          foaf:age  ?age ;
          ex:wohntIn ex:Berlin .
  FILTER (?age > 25)
}
ORDER BY ?name

-- Wikidata: Hauptstädte aller Länder
SELECT ?land ?hauptstadt WHERE {
  ?l wdt:P31 wd:Q6256 ;
     wdt:P36 ?hs .
}

-- Alle Nobelpreisträger aus Deutschland
SELECT ?person ?name WHERE {
  ?person wdt:P27  wd:Q183 ;   # Deutsch
          wdt:P166 ?prize .     # Auszeichnung
  ?prize  wdt:P31  wd:Q7191 .  # Nobelpreis
  ?person rdfs:label ?name .
  FILTER (lang(?name) = "de")
}

Abfrage-API Gremlin

Imperatives Traversal-API von Apache TinkerPop
Unterstützt von: JanusGraph, Amazon Neptune, CosmosDB, TigerGraph
Pipeline-Stil: Traversal-Schritte verkettet

g.V(): alle Knoten
g.E(): alle Kanten

Einbettbar in Java, Python, JavaScript, Go …

// Alle Freunde von Alice
g.V().has("name", "Alice")
 .out("KENNT")
 .values("name")

// Freunde zweiten Grades
g.V().has("name", "Alice")
 .out("KENNT").out("KENNT")
 .dedup()
 .values("name")

// Kuerzester Pfad
g.V().has("name","Alice")
 .repeat(out().simplePath())
 .until(has("name","Charlie"))
 .path().limit(1)

Neo4j

Nativer Graph Storage: Knoten- und Kanten-Record-Dateien
Abfragesprache: Cypher (OpenCypher-Standard)
Graph Data Science Library: 65+ Algorithmen
Neo4j AuraDB: vollständig verwalteter Cloud-Dienst

Amazon Neptune

Verwalteter Graphdienst von AWS (seit 2018)
Unterstützt Property Graph (Gremlin, openCypher) und RDF (SPARQL)
Serverless-Option: automatische Skalierung
Multi-AZ-Replikation, bis zu 15 Read-Replicas
Neptune Analytics: In-Memory-Graphanalyse auf großen Graphen
Integriert mit S3, Lambda, SageMaker, Bedrock
Storage von Compute getrennt
Verteilter Storage: 6 Kopien über 3 AZs
Bulk-Loader direkt aus S3

Apache TinkerPop & JanusGraph

Apache TinkerPop

Open-Source Graph-Computing-Framework
Definiert die Gremlin-Traversal-Sprache
Abstraktionsschicht für verschiedene Graph-Engines
TinkerGraph: In-Memory-Referenzimplementierung

JanusGraph

Verteilte Graphdatenbank (Linux Foundation)
TinkerPop-kompatibel (Gremlin-API)
Pluggable Storage Backends: HBase, Cassandra, BerkeleyDB
Index-Backends: Elasticsearch, Solr, Lucene
Milliarden von Vertices und Edges skalierbar

TigerGraph

Native parallele Graphdatenbank für Echtzeit-Analytik (seit 2012)
Eigene Abfragesprache: GSQL (SQL-ähnlich, Turing-vollständig)
Stärke: tiefe Multi-Hop-Traversierungen auf sehr großen Graphen
MPP-Architektur (Massively Parallel Processing): Algorithmen auf Partitionen verteilt
Native Unterstützung für OLTP und OLAP gleichzeitig (HTAP)
TigerGraph Cloud: verwalteter SaaS-Dienst

GSQL Beispiel

// Freunde zweiten Grades
CREATE QUERY fof(VERTEX src)
FOR GRAPH SocialGraph {
  SetAccum @@friends, @@fof;

  start = {src};

  hop1 = SELECT t FROM start:s
         -(KENNT:e)-> Person:t
         ACCUM @@friends += t;

  hop2 = SELECT t FROM hop1:s
         -(KENNT:e)-> Person:t
         WHERE t NOT IN @@friends
           AND t != src
         ACCUM @@fof += t;

  PRINT @@fof;
}

Oracle

Implementiert SQL/PGQ (ISO SQL:2023)
Property Graphs direkt über relationale Tabellen und Views definiert
Kein separates Graphsystem – Graph als Sicht auf bestehende Daten
CREATE PROPERTY GRAPH: deklariert Knoten- und Kantentabellen
Musterabfragen mit GRAPH_TABLE eingebettet in SQL
Vollständige ACID-Garantien, keine Datenmigration nötig

Oracle Graph Server (PGX)

Separater In-Memory-Graphanalytik-Server (PGQL-Abfragesprache)
60+ vorgefertigte Graph-Algorithmen (PageRank, Louvain, Betweenness …)
Integration mit Oracle ML, Python-Client, Jupyter Notebooks
Bulk-Load aus Oracle DB oder externe Formate (CSV, RDF)

-- Property Graph definieren (Oracle 23c)
CREATE PROPERTY GRAPH social_graph
  VERTEX TABLES (
    person
      KEY (id)
      LABEL Person
      PROPERTIES (name, age)
  )
  EDGE TABLES (
    freundschaft
      KEY (id)
      SOURCE KEY (person_id)
        REFERENCES person
      DESTINATION KEY (freund_id)
        REFERENCES person
      LABEL KENNT
      PROPERTIES (seit)
  );

-- Graphmuster in SQL abfragen
SELECT f.name AS freund
FROM GRAPH_TABLE (social_graph
  MATCH (p IS Person)
        -[IS KENNT]->(f IS Person)
  WHERE p.name = 'Alice'
  COLUMNS (f.name)
)
ORDER BY freund;

Azure Cosmos DB

Verwalteter Graphdienst von Microsoft Azure
Basiert auf Apache TinkerPop – Gremlin als Abfragesprache
Cosmos DB Multi-Modell: gleiche Daten auch als Dokument, Key-Value oder Tabelle abfragbar
Globale Verteilung: Replikation in beliebig viele Azure-Regionen
Fünf Konsistenzmodelle wählbar (Strong, Bounded Staleness, Session, Consistent Prefix, Eventual)
Serverless und Provisioned Throughput (RU/s)

// Verbindung (Python, Gremlin-Client)
from gremlin_python.driver import client

c = client.Client(
  'wss://myaccount.gremlin.cosmos.azure.com:443/', 
  graph='g',
  username='...',
  password='...')

// Knoten und Kante anlegen
c.submit(
  "g.addV('Person')"
  " .property('id','alice')"
  " .property('name','Alice')"
  " .property('pk','pk')")

c.submit(
  "g.V('alice').addE('KENNT')"
  " .to(g.V('bob'))"
  " .property('seit', 2018)")

// Freunde von Alice
c.submit(
  "g.V('alice').out('KENNT')"
  " .values('name')")

DuckPGQ

Extension von DuckDB, implementiert SQL/PGQ
Property-Graph-Abfragen direkt auf relationalen Tabellen
Kein separates Graphsystem nötig – Graphsicht über vorhandene Daten
CREATE PROPERTY GRAPH definiert Knoten- und Kantentabellen
FROM GRAPH_TABLE(...) eingebettet in normales SQL
Kombination mit DuckDB-Stärken: Spaltenformat, OLAP, In-Process
Analytische Workloads (kein OLTP), kleine bis mittlere Graphen
Data-Science-Workflows: Parquet/CSV direkt als Graph analysieren

CREATE TABLE Person AS 
SELECT * FROM 'https://.../person.csv';

CREATE TABLE Person_knows_person AS 
SELECT * FROM 'https://.../person_knows_person.csv';

CREATE PROPERTY GRAPH snb
VERTEX TABLES (
    Person
  )
EDGE TABLES (
    Person_knows_person 
        SOURCE KEY ( person1id ) REFERENCES Person ( id )
        DESTINATION KEY ( person2id ) REFERENCES Person ( id )
        LABEL Knows
  );

FROM GRAPH_TABLE(snb
    MATCH (a:Person WHERE a.firstName = 'Jan')-[k:Knows]->(b:Person)
    COLUMNS (b.firstName)
);

Graphdatenbanken vs. SQL

Gleiche Abfrage im Vergleich

-- SQL: Freunde zweiten Grades
SELECT DISTINCT f2.name
FROM person p
JOIN friendship f1
  ON p.id = f1.person_id
JOIN person p1
  ON f1.friend_id = p1.id
JOIN friendship f2
  ON p1.id = f2.person_id
JOIN person p2
  ON f2.friend_id = p2.id
WHERE p.name = 'Alice'
  AND p2.id != p.id
  AND p2.id NOT IN (
    SELECT friend_id
    FROM friendship
    WHERE person_id = p.id)

// Cypher: Freunde zweiten Grades
MATCH (a:Person {name: "Alice"})
      -[:KENNT*2]->(fof)
WHERE NOT (a)-[:KENNT]->(fof)
  AND fof <> a
RETURN DISTINCT fof.name

Wann Graphdatenbank?

Viele und tiefe Beziehungs-Traversierungen
Schema dynamisch oder heterogen
Mustersuche in vernetzten Daten
Pfadprobleme (kürzester Weg, Erreichbarkeit)