TuringDB Query Language Cheatsheet

MATCH: Pattern Matching

MATCH (n) RETURN n
MATCH (n:Person {name: 'Alice'}) RETURN n.age
MATCH (a:Person)-->(b:Company) RETURN a.name, b.name

() → Node
[] → Edge
- → Undirected edge
Labels: :Label
Properties: {key: 'value', age: 30}

CREATE: Add Nodes & Edges

CREATE (:Person {name: 'Alice', age: 30})
CREATE (:Person {name: 'Mick'})-[:FRIEND_OF]->(:Person {name: 'John'})
CREATE (a)-[:EDGE]->(b), (b)-[:EDGE]->(c), (c)-[:EDGE]->(a)

CREATE (gabby:Person {name: 'Gabby', age: 27}),
(susan:Person {name: 'Susan', age: 35}),
(lynette:Person {name: 'Lynette', age: 41}),
(bree:Person {name: 'Bree', age: 42}),
(gabby)-[FRIEND_OF]->(susan),
(gabby)-[FRIEND_OF]->(lynette),
...

Labels required for node creation
No RETURN clause
Use commas to create multiple items at once

MATCH + CREATE and MATCH + CREATE + RETURN

// Create two nodes Person
CREATE (:Person {name: 'Alice', age: 24}),
	   (:Person {name: 'John', age: 27})

// Match two nodes to create the edge between them
MATCH (n:Person {name: 'Alice'}), (m:Person {name: 'John'})
CREATE (n)-[:FRIENDS_WITH]->(m)

// RETURN clause can also be added
MATCH (n:Person {name: 'Alice'}), (m:Person {name: 'John'})
CREATE (n)-[:FRIENDS_WITH]->(m)
RETURN n.name, n.age, m.name, m.age

SET: Update Properties

// Update a single property
MATCH (n:Person {name: 'Alice'})
SET n.age = 30

// Update multiple properties at once
MATCH (n:Person {name: 'Alice'})
SET n.position = 'Developer', n.surname = 'Taylor'

// Update from an expression
MATCH (p:Product)
SET p.discountPrice = p.price * (1 - 0.15)

// Update edge property
MATCH (n:Person {name: 'Alice'})-[e:KNOWS]->(m:Person {name: 'Bob'})
SET e.since = 2020

// Set an embedding vector
MATCH (n:Person {name: 'Alice'})
SET n.emb = (1.2, 2.0, 0.0, 12.0)

// Set an embedding vector by node ID
MATCH (n) WHERE n = 1234
SET n.emb = (1.2, 2.0, 0.0, 12.0)

// Conditional update with WHERE
MATCH (n:Person)
WHERE n.age < 18
SET n.isMinor = true

Always used with MATCH, not CREATE
Creates the property if it does not already exist
Use COMMIT to persist changes

WHERE: Filter nodes and edges by properties

To filter on node label:

MATCH (n)
WHERE n:Person
RETURN n, n.age

To filter on node property:

MATCH (n)
WHERE n.name = 'Alice'
RETURN n, n.age

To filter on edge label:

MATCH (n)-[e]->(m)
WHERE e:PLAY_POKER_TOGETHER
RETURN n.name, m.age

To filter on edge property:

MATCH (n)-[e]->(m:Person)
WHERE n.name = 'Gabby'
AND e.play_poker_together = true
RETURN n.name, m.age

SKIP and LIMIT

// Return first 10 results
MATCH (n) RETURN n LIMIT 10

// Pagination: skip 10, return next 10
MATCH (n) RETURN n SKIP 10 LIMIT 10

ORDER BY

// Sort ascending (default)
MATCH (n:Person) RETURN n.name, n.age ORDER BY n.age

// Sort descending
MATCH (n:Person) RETURN n.name, n.age ORDER BY n.age DESC

// Sort by multiple properties
MATCH (n:Person) RETURN n.name, n.age, n.city ORDER BY n.city, n.age DESC

// Combined with pagination
MATCH (n:Person) RETURN n.name, n.age ORDER BY n.age DESC SKIP 10 LIMIT 10

Joins and Cartesian Products

// Cartesian product: all combinations of Person × Interest
MATCH (a:Person), (b:Interest) RETURN a.name, b.name

// Three-way cartesian product
MATCH (p:Person), (i:Interest), (c:Category) RETURN p.name, i.name, c.name

// Join on shared variable: persons sharing an interest
MATCH (a:Person)-->(b:Interest)<--(c:Person)
WHERE a.name <> c.name
RETURN a.name, b.name, c.name

// With explicit edge types
MATCH (a:Person)-[:INTERESTED_IN]->(b:Interest)<-[:INTERESTED_IN]-(c:Person)
WHERE a.name <> c.name
RETURN a.name, b.name, c.name

// Multi-hop join
MATCH (a:Person)-->(i:Interest)-->(c:Category)
RETURN a.name, i.name, c.name

// Mix path + cartesian product
MATCH (a:Person)-->(i:Interest), (c:Category)
WHERE c.name = 'Cat1'
RETURN a.name, i.name, c.name

// Two independent paths (cartesian of each path's results)
MATCH (a:Person)-->(i1:Interest), (b:Person)-->(i2:Interest)
WHERE a.name <> b.name
RETURN a.name, i1.name, b.name, i2.name

Comma , separates independent patterns
Shared variables between patterns create joins
Unrelated patterns create cartesian products (N × M rows)

Property Match Operators

MATCH (n {name: 'Alice'}) RETURN n
// exact equivalent of
MATCH (n) WHERE n.name = 'Alice' RETURN n

: → exact match using property filter in node directly
= → exact match using property filter in WHERE clause

Boolean operators

OR

MATCH (n:Person)
WHERE n.medication = "Aspirin"
OR n.medication = "Ibuprofen"
RETURN n.name

AND

MATCH (n)
WHERE n.name = 'Matt'
AND n.age = 20
AND n.hasPhD = false
RETURN n

Comparison operators

Equal: =

# Find antibodies targeting proteins in Human
MATCH (ab:Antibody)-->(prot:Protein)
WHERE prot.host = 'Human'
RETURN ab.name, prot.name

Inequal: <>

# Find antibodies (associated to a protein) used together
# in same publication (2-hop)
MATCH (ab1:Antibody)-->(prot:Protein), (ab2:Antibody)-->(prot:Protein)
WHERE ab1.name <> ab2.name
RETURN ab1.name, ab2.name, prot.name, prot.gene_name

Less than: <
Less than or equal to: <=
Greater than: >

Greater than or equal to: >=

# Publications published on 2020 or after
MATCH (pub:Publication)
WHERE pub.published_year >= 2020
RETURN pub.displayName, pub.pubmedid, pub.published_year, pub.country

is null:IS NULL

is not null:IS NOT NULL

# Publications from the United States
MATCH (pub:Publication)
WHERE pub.country = 'United States'
AND pub.institution IS NOT NULL
RETURN pub.displayName, pub.institution, pub.published_year

Data Types

Type	Example
String	`'hello'` or `"hello"`
Integer	`age=30`
Boolean	`flag=true`
Double	`score=3.14`
Embedding	`emb=(1.2, 2.0, 0.0)`

RETURN Clause

MATCH (n)-->(m) RETURN n.name, n.age, m.name, m.age

Select fields with RETURN n.prop, m.prop

Expression evaluation

// Multiply property by constant
MATCH (n) RETURN n.price * 1.1

// Divide two properties
MATCH ()-[r]->() RETURN r.a / r.b

// Add two properties
MATCH (n) RETURN n.val + n.tax

LOAD graphs

Load TuringDB graph

Files have to be available in graphs subdirectory of turing-dir.

LOAD GRAPH graph_name

Load external data into TuringDB graph

Files have to be available in data subdirectory of turing-dir.

LOAD GML 'mygml.gml' AS my_graph

LOAD JSONL 'myjsonl.jsonl' AS my_graph

Procedures (`CALL`)

Query	Description
`CALL db.labels()`	All node labels
`CALL db.propertyTypes()`	All node/edge property keys & types
`CALL db.edgeTypes()`	All edge types
`CALL db.history()`	Commit history
`CALL db.describeCommit('<hash>')`	Counts for a single commit
`CALL db.procedures()`	List available procedures
`CALL db.showIndexes()`	List property indexes

Procedure outputs can be YIELDed and chained: CALL db.labels() YIELD label MATCH (n) WHERE n.name = label RETURN n.

DELETE

// Delete a node
MATCH (n:Person {name: 'Alice'}) DELETE n

// Delete an edge
MATCH (n)-[e:KNOWS]->(m) DELETE e

Variable-length paths

// Postfix quantifiers (not Neo4j's -[*1..3]-)
MATCH (a:Person)-[e]->+(b:Person) RETURN a, b      // one or more hops
MATCH (a:Person)-[e]->*(b:Person) RETURN a, b      // zero or more hops
MATCH (a:Person)-[e]->{2,4}(b:Interest) RETURN a, b // 2 to 4 hops

Graph algorithms

Function	Description
`shortestPath(n, m, distanceProperty, distOutputVar, pathOutputVar)`	Shortest path between nodes using the Dijkstra processor

Functions

Function	Description
`labels(n)`	Node label as a string
`edgeType(e)`	Edge type as a string
`toInteger(expr)`	Parses a string as an integer
`toFloat(expr)`	Parses a string as a float
`toBoolean(expr)`	Parses a string as a boolean
`cosine_similarity(a, b)`	Cosine similarity of two embeddings
`euclidean_distance(a, b)`	Euclidean distance of two embeddings

Aggregate Functions

Function	Description
`count(expr)`	Returns the number of non-null rows in the column corresponding to `expr`
`avg(expr)`	Returns the average value of non-null rows in the numeric-valued column corresponding to `expr`

// Introspection
MATCH (n)-[e]->(m) RETURN labels(n), edgeType(e)

// Type conversion
MATCH (n) WHERE n.year > toInteger("2020") RETURN n.name
MATCH (n) RETURN n.price * toFloat("1.07")

// Aggregation
MATCH (n:Person) RETURN count(*)

Engine Commands

Command	Description
`CREATE GRAPH <name>`	Create a new named graph
`LOAD GRAPH <name>`	Load an existing graph
`LOAD GML 'mygraph.gml' AS my_graph`	Load the specified GML as TuringDB graph. Requires the GML to be accessible in TuringDB directory (`-turing-dir`, `data` subdir)
`LOAD JSONL 'mygraph.jsonl' AS my_graph`	Load the specified JSONL as TuringDB graph. Requires the JSONL to be accessible in TuringDB directory (`-turing-dir`, `data` subdir)
`COMMIT`	Persist intermediate state within a change (needed between separate node/edge create steps)
`LOAD COMMIT '<hash>'`	Load a past commit into memory (needed for REST API queries on non-HEAD commits; CLI and SDK do this automatically)
`LIST GRAPH`	List all available graphs
`HISTORY`	Show commit history (versioning)
`CHANGE NEW`	Create a new isolated change
`CHANGE SUBMIT`	Merge current change into main
`CHANGE DELETE`	Delete current change
`CHANGE LIST`	List active uncommitted changes
`CREATE VECTOR INDEX <name> WITH DIMENSION <n> METRIC <COSINE\|EUCLID>`	Create a vector index
`VECTOR SEARCH IN <index> FOR <k> (<vec>) YIELD ids`	k-nearest-neighbor vector search
`SHOW VECTOR INDEXES` / `DELETE VECTOR INDEX <name>`	List / delete vector indexes
`CREATE INDEX <name> FOR (n) ON n.prop` / `FOR [e] ON e.prop`	Create a property index (write; commit to take effect)
`DROP INDEX <name>`	Drop a property or vector index
`MERGE_DATAPARTS`	Compact the current graph’s DataParts into one
`INSTALL <ext>` / `SHOW EXTENSIONS` / `SHOW PROCEDURES`	Load a procedure extension / list extensions / list procedures
`LOAD CSV "<file>" [WITH HEADERS] [ON ERROR SKIP\|FAIL] AS row`	Stream CSV rows (see CSV import)

UNWIND

// Expand a literal list into rows (literal lists only)
UNWIND [1, 2, 3] AS x RETURN x

// Return a list literal directly
RETURN [1, 2, 3] AS nums

Property indexes

// Indexes are writes — create inside a change, then commit
CHANGE NEW
CREATE INDEX age_index FOR (n) ON n.age
CHANGE SUBMIT
MATCH (n) WHERE n.age = 30 RETURN n   // optimizer uses the index

DROP INDEX age_index                  // remove

Useful Patterns

// Two-hop connection
MATCH (a)-[r1]->(b)-[r2]->(c) RETURN c

// All people named John
MATCH (n:Person {name: 'John'}) RETURN n
/// exact equivalent of
MATCH (n:Person) WHERE n.name = 'John' RETURN n

// Find co-authors: two persons linked to the same publication
MATCH (a:Person)-->(p:Publication)<--(b:Person)
WHERE a.name <> b.name
RETURN a.name, b.name, p.title

// Match existing nodes then create edge between them
MATCH (n:Person {name: 'Alice'}), (m:Person {name: 'Bob'})
CREATE (n)-[:KNOWS]->(m)

// Cartesian: pair every person with every city
MATCH (p:Person), (c:City) RETURN p.name, c.name

​MATCH: Pattern Matching

​CREATE: Add Nodes & Edges

​MATCH + CREATE and MATCH + CREATE + RETURN

​SET: Update Properties

​WHERE: Filter nodes and edges by properties

​SKIP and LIMIT

​ORDER BY

​Joins and Cartesian Products

​Property Match Operators

​Boolean operators

​Comparison operators

​Data Types

​RETURN Clause

​Expression evaluation

​LOAD graphs

​Load TuringDB graph

​Load external data into TuringDB graph

​Procedures (CALL)

​DELETE

​Variable-length paths

​Graph algorithms

​Functions

​Aggregate Functions

​Engine Commands

​UNWIND

​Property indexes

​Useful Patterns