openCypher, with two extra time axes.

InvariantDB targets openCypher syntax for everything you know — MATCH, CREATE, MERGE, SET, DELETE, WITH, UNWIND, aggregates, list comprehensions, quantifiers. On top of that, every property is bitemporal, so AT VALID / AT RECORDED / OVER VALID BETWEEN are first-class keywords.

Reads

// Standard match
MATCH (p:Person {name: 'Alice'})-[:WORKS_AT]->(c:Company)
RETURN p.name, c.name

// At a point in time (real-world)
MATCH (p:Policy) AT VALID '2024-06-01'
WHERE p.holder = 'acme' RETURN p

// As the database knew it at a point in time (transaction)
MATCH (p:Policy) AT RECORDED '2024-06-01' RETURN p

// Both axes at once — "what was true on June 1 according to what we
// knew on June 1"
MATCH (p:Policy)
  AT VALID '2024-06-01'
  AT RECORDED '2024-06-01'
RETURN p

// Walk every version that overlaps a window
MATCH (p:Policy {id: $id})
  OVER VALID BETWEEN '2024-01-01' AND '2024-12-31'
RETURN p.premium, p._valid_from, p._valid_to
ORDER BY p._valid_from

Writes

CREATE (p:Person {name: 'Alice', email: 'alice@example.com'})

MERGE (p:Person {email: 'alice@example.com'})
ON CREATE SET p.created_at = datetime()
ON MATCH  SET p.last_seen = datetime()

// Map-merge: keep existing keys, overwrite supplied
SET p += {a: 1, b: 2}

DELETE p

// Cascade across edges
DETACH DELETE p

Aggregation

Pattern features

// Variable-length paths
MATCH (a)-[*1..5]->(b) WHERE a.id = $start AND b.id = $end RETURN length(path)

// Named paths
MATCH p = (a)-[r]->(b)
RETURN length(p), nodes(p), relationships(p)

// shortestPath / allShortestPaths
MATCH (a:Person {id:$a}), (b:Person {id:$b})
MATCH p = shortestPath((a)-[*..6]-(b))
RETURN p

// Pattern comprehension
MATCH (a:Person {id:$id})
RETURN [(a)-[:KNOWS]->(friend) WHERE friend.active | friend.name] AS active_friends

// Quantifier predicates
MATCH (p:Project)
WHERE ANY(x IN p.tags WHERE x STARTS WITH 'urgent')
  AND ALL(c IN p.checks WHERE c.passed)
RETURN p

// reduce()
RETURN reduce(s = 0, x IN [1, 2, 3] | s + x * x) AS sum_of_squares

WHERE conditions

// Standard comparison
WHERE n.score >= 0.5 AND n.label IN ['A', 'B']

// Regex
WHERE n.name =~ '(?i)alice.*'

// String predicates
WHERE n.name STARTS WITH 'A'
WHERE n.url ENDS WITH '.com'
WHERE n.body CONTAINS 'pricing'

// Not-equals
WHERE a.x <> b.x

// Null handling
WHERE n.email IS NULL
WHERE n.email IS NOT NULL

Aggregating subqueries

// COUNT { ... } — Cypher-5 count subquery
RETURN COUNT { MATCH (a:Person {name:'Alice'})-[:KNOWS]->() } AS friend_count

// CALL { ... } — sub-query with parameters
MATCH (a:Account {id:$id})
CALL {
  WITH a
  MATCH (a)-[:OWNS]->(p:Position)
  RETURN sum(p.value) AS total
}
RETURN a.id, total

Indexes

// Property index — current data
CREATE INDEX FOR (n:Person) ON (n.email)

// Vector index (HNSW)
// Schema-driven via /graphs/{name}/schema; see docs.html

// Drop
DROP INDEX FOR (n:Person) ON (n.email)

Procedures

Time + history

Provenance + lineage

Agent memory

Compliance

Graph algorithms

Inline vector functions

// In WHERE
MATCH (d:Doc) WHERE cosine(d.embedding, $query) > 0.75 RETURN d

// In RETURN
MATCH (d:Doc) RETURN d.title, cosine(d.embedding, $query) AS sim
ORDER BY sim DESC LIMIT 10

// Available: cosine, euclidean, dotProduct

When a vector index is declared, the planner pushes the WHERE cosine() > t filter into HNSW automatically.

Parameter substitution

// Anywhere a literal goes — including LIMIT / SKIP
MATCH (p:Person) WHERE p.role = $role RETURN p LIMIT $page_size

EXPLAIN + EXPLAIN ANALYZE

EXPLAIN MATCH (n:Person) WHERE n.email = $e RETURN n
// → planner text, no execution

EXPLAIN ANALYZE MATCH (n:Person) WHERE n.email = $e RETURN n
// → actual row counts + per-stage timing, the query runs

Things to watch

Quickstart →  ·  SDK →  ·  MCP tools →  ·  All features →