Baradb/docs/de/crossmodal.md

Cross-Modal Abfragen

BaraDB's einzigartige Fähigkeit ist die Ausführung von Abfragen, die mehrere Speicher-Engines in einer einzigen vereinheitlichten BaraQL-Anweisung umfassen.

Überblick

Traditionelle Datenbanken erfordern separate Abfragen und applikationsseitige Joins bei der Arbeit mit verschiedenen Datenmodellen. BaraDB's Cross-Modal Query Planner optimiert die Ausführung über:

• Document/KV (LSM-Tree) — strukturierte Datensätze
• Graph (Adjacency List) — Beziehungen
• Vector (HNSW/IVF-PQ) — Ähnlichkeitssuche
• Full-Text (Inverted Index) — Textsuche
• Columnar — analytische Aggregatfunktionen

Abfragemuster

Vector + Full-Text (Semantisch + Schlüsselwortsuche)

Finde Dokumente, die semantisch ähnlich zu einem Query-Vektor sind UND bestimmte Schlüsselwörter enthalten:

SELECT title, score
FROM articles
WHERE MATCH(body) AGAINST('machine learning')
ORDER BY cosine_distance(embedding, [0.1, 0.2, 0.3, ...])
LIMIT 10;

Ausführungsplan:

1. FTS-Engine filtert Artikel mit "machine learning"
2. Vector-Engine rankt gefilterte Ergebnisse nach Embedding-Ähnlichkeit
3. Top-K Ergebnisse zurückgegeben

Graph + Vector (Soziale Empfehlungen)

Finde Freunde eines Benutzers mit ähnlichen Geschmacksvektoren:

MATCH (u:User)-[:KNOWS]->(friend:User)
WHERE u.name = 'Alice'
ORDER BY cosine_distance(friend.taste_vector, u.taste_vector)
RETURN friend.name, friend.age;

Ausführungsplan:

1. Graph-Engine traversiert "KNOWS"-Kanten von Alice
2. Vector-Engine berechnet Ähnlichkeit für jeden Freund
3. Ergebnisse sortiert und projiziert

Document + Graph (Entity-Anreicherung)

Erhalte Bestelldetails mit Kunden-Beziehungsgraph:

SELECT o.id, o.total, c.name,
       (SELECT count(*) FROM orders WHERE customer_id = c.id) as order_count
FROM orders o
JOIN customers c ON o.customer_id = c.id
WHERE c.id IN (
  SELECT node_id FROM graph
  WHERE MATCH pattern (c:Customer)-[:REFERRED]->(:Customer)
);

Full-Text + Aggregate (Content-Analyse)

Analysiere welche Abteilungen am meisten über ein Thema schreiben:

SELECT department, count(*) as article_count,
       avg(length(content)) as avg_length
FROM docs
WHERE MATCH(content) AGAINST('Nim programming')
GROUP BY department
ORDER BY article_count DESC;

Vector + Aggregate (Cluster-Analyse)

Gruppiere ähnliche Vektoren und analysiere jedes Cluster:

SELECT cluster_id, count(*) as size,
       centroid(embedding) as center,
       avg(created_at) as avg_date
FROM products
GROUP BY vector_cluster(embedding, k=10)
ORDER BY size DESC;

Alle Modalitäten kombiniert

Eine komplexe Abfrage unter Verwendung aller Engines:

WITH relevant_docs AS (
  SELECT id, title, embedding
  FROM articles
  WHERE MATCH(body) AGAINST('database optimization')
    AND created_at > '2024-01-01'
),
author_graph AS (
  MATCH (a:Author)-[:COAUTHORED]->(b:Author)
  WHERE a.name = 'Dr. Smith'
  RETURN b.id as coauthor_id
)
SELECT rd.title, rd.score,
       a.name as author,
       cosine_distance(rd.embedding, query_vec) as similarity
FROM relevant_docs rd
JOIN authors a ON rd.author_id = a.id
WHERE a.id IN (SELECT coauthor_id FROM author_graph)
ORDER BY similarity ASC, rd.score DESC
LIMIT 20;

Optimierung

Cross-Modal Query Planner

BaraDB's adaptiver Query-Optimizer (query/adaptive.nim) wählt die Ausführungsreihenfolge basierend auf Selektivität:

1. Selektivstes Filter zuerst (normalerweise FTS oder Vector)
2. Prädikate zu jeder Engine pushen
3. Bloom-Filter für KV-Lookups verwenden
4. Unabhängige Zweige parallelisieren

Index-Auswahl

Der Optimizer wählt automatisch den besten Index:

Abfragemuster	Primäre Engine	Sekundäre Engine
MATCH ... ORDER BY cosine_distance	Vector	FTS
MATCH ... WHERE graph condition	Graph	FTS
WHERE id = ? AND vector_search	KV	Vector
GROUP BY + MATCH	FTS	Columnar

Hints

Bestimmte Ausführungsreihenfolge erzwingen:

SELECT /*+ USE_INDEX(vector) */ *
FROM products
WHERE category = 'electronics'
ORDER BY cosine_distance(embedding, [...])
LIMIT 10;

Performance

Cross-Modal Abfragen sind optimiert um Datenbewegung zu minimieren:

Abfragetyp	Latenz (10K Zeilen)	Latenz (100K Zeilen)
FTS + Vector	15 ms	85 ms
Graph + Vector	25 ms	120 ms
FTS + Aggregate	12 ms	55 ms
Alle Modalitäten	45 ms	220 ms

Anwendungsfälle

E-Commerce Suche

-- Finde Produkte passend zu einem Suchbegriff, ähnlich zu einem betrachteten Artikel,
-- gekauft von ähnlichen Benutzern
SELECT p.name, p.price
FROM products p
WHERE MATCH(p.description) AGAINST('wireless headphones')
  AND cosine_distance(p.embedding, viewed_embedding) < 0.3
  AND p.id IN (
    SELECT product_id FROM orders o
    JOIN graph ON o.customer_id = graph.node_id
    WHERE graph.similarity > 0.8
  )
ORDER BY p.rating DESC
LIMIT 20;

Betrugserkennung

-- Finde Transaktionen ähnlich zu bekannten Betrugsmustern,
-- wo der Benutzer mit markierten Konten verbunden ist
SELECT t.id, t.amount
FROM transactions t
WHERE cosine_distance(t.pattern_vector, fraud_vector) < 0.2
  AND t.user_id IN (
    MATCH (u:User)-[*1..3]->(f:FlaggedAccount)
    RETURN u.id
  );

Knowledge Graph + RAG

-- Relevante Dokumente für eine Query abrufen,
-- dann den Knowledge Graph für verwandte Konzepte traversieren
WITH docs AS (
  SELECT id, content, embedding
  FROM documents
  ORDER BY cosine_distance(embedding, query_embedding)
  LIMIT 5
)
SELECT d.content, c.name as related_concept
FROM docs d
JOIN graph ON d.id = graph.doc_id
MATCH (d)-[:MENTIONS]->(c:Concept)
RETURN d.content, c.name;