Cypher Query Language¶

// Pattern: (startNode)-[relationship]->(endNode)
MATCH (person:Person)-[:KNOWS]->(friend:Person)
WHERE person.age > 30
RETURN friend.name

[MATCH clause]      -- Pattern matching
[WHERE clause]      -- Filtering
[WITH clause]       -- Intermediate processing
[RETURN clause]     -- Output projection
[ORDER BY clause]   -- Sorting
[SKIP/LIMIT clause] -- Pagination

MATCH (p:Paper)-[:AUTHORED_BY]->(a:Author)
WHERE p.year >= 2020 AND a.affiliation = 'MIT'
RETURN p.title, a.name, p.year
ORDER BY p.year DESC
LIMIT 10

// Any node
MATCH (n)

// Node with label
MATCH (p:Paper)

// Node with multiple labels
MATCH (n:Paper:Preprint)

// Node with variable binding
MATCH (paper:Paper)
RETURN paper.title

// Anonymous node (no variable)
MATCH (:Paper)-[:CITES]->(cited)
RETURN cited.title

// Filter in pattern (equivalent to WHERE)
MATCH (p:Paper {year: 2023})
RETURN p.title

// Multiple properties
MATCH (p:Paper {year: 2023, venue: 'NeurIPS'})
RETURN p.title

// Outgoing relationship
MATCH (a)-[:KNOWS]->(b)

// Incoming relationship
MATCH (a)<-[:KNOWS]-(b)

// Either direction
MATCH (a)-[:KNOWS]-(b)

// Any relationship type
MATCH (a)-[r]->(b)

// Relationship with variable
MATCH (p:Paper)-[c:CITES]->(cited:Paper)
RETURN c  // Access edge properties

// 2-hop path
MATCH (a:Paper)-[:CITES]->(b:Paper)-[:CITES]->(c:Paper)
RETURN a.title, b.title, c.title

// Chain multiple relationships
MATCH (p:Paper)-[:AUTHORED_BY]->(a:Author)-[:AFFILIATED_WITH]->(u:University)
RETURN p.title, a.name, u.name

// 1 to 3 hops
MATCH (a:Paper)-[:CITES*1..3]->(b:Paper)
RETURN a.title, b.title

// Exactly 2 hops
MATCH (a)-[:KNOWS*2]->(b)

// Any length (use with caution on large graphs)
MATCH (a)-[:KNOWS*]->(b)

// Zero or more hops
MATCH (a)-[:KNOWS*0..]->(b)

// With path variable
MATCH path = (a:Paper)-[:CITES*1..5]->(b:Paper)
WHERE a.title = 'Attention Is All You Need'
RETURN path, length(path) AS hops

// Equality
WHERE p.year = 2023

// Inequality
WHERE p.year <> 2020
WHERE p.year != 2020

// Comparison
WHERE p.year > 2020
WHERE p.year >= 2020
WHERE p.year < 2025
WHERE p.year <= 2025

// AND
WHERE p.year > 2020 AND p.venue = 'NeurIPS'

// OR
WHERE p.venue = 'NeurIPS' OR p.venue = 'ICML'

// NOT
WHERE NOT p.is_retracted

// Parentheses for grouping
WHERE (p.year > 2020 AND p.venue = 'NeurIPS') OR p.citations > 1000

// Check for NULL
WHERE p.doi IS NULL
WHERE p.doi IS NOT NULL

// COALESCE (use default if NULL)
RETURN COALESCE(p.nickname, p.name) AS display_name

// Starts with
WHERE p.title STARTS WITH 'Attention'

// Ends with
WHERE p.title ENDS WITH 'Networks'

// Contains (uses JSON FTS index if available)
WHERE p.title CONTAINS 'Transformer'

// Full-text search on JSON document column (requires JSON FTS index)
WHERE a._doc CONTAINS 'graph database'

// Path-specific JSON FTS search
WHERE a._doc.title CONTAINS 'graph'

// Regular expression matching
WHERE p.title =~ '.*Transform.*'

// Case-insensitive regex
WHERE p.email =~ '(?i)john@.*'

// Email pattern matching
WHERE p.email =~ '^[\\w.-]+@[\\w.-]+\\.\\w+$'

// IN list
WHERE p.venue IN ['NeurIPS', 'ICML', 'ICLR']

// NOT IN
WHERE p.venue NOT IN ['Workshop', 'Demo']

// Check if property exists
WHERE p.abstract IS NOT NULL

// In pattern
WHERE EXISTS(p.doi)

// Single property
RETURN p.title

// Multiple properties
RETURN p.title, p.year, p.venue

// All properties (*)
RETURN p.*

// Entire node
RETURN p

// AS keyword
RETURN p.title AS paper_title, a.name AS author_name

// Expression aliases
RETURN p.year + 1 AS next_year

// Arithmetic
RETURN p.citations * 2 AS double_citations

// String concatenation
RETURN p.title + ' (' + p.venue + ')' AS formatted

// Conditional (CASE)
RETURN CASE
  WHEN p.citations > 1000 THEN 'High Impact'
  WHEN p.citations > 100 THEN 'Medium Impact'
  ELSE 'Low Impact'
END AS impact_level

// Remove duplicates
RETURN DISTINCT p.venue

// Distinct combinations
RETURN DISTINCT p.venue, p.year

// Group by venue, count papers per venue
MATCH (p:Paper)
RETURN p.venue, COUNT(p) AS paper_count
ORDER BY paper_count DESC

// Count papers per author
MATCH (p:Paper)-[:AUTHORED_BY]->(a:Author)
RETURN a.name, COUNT(p) AS papers, AVG(p.citations) AS avg_citations
ORDER BY papers DESC

// Most cited papers per venue
MATCH (p:Paper)
RETURN p.venue, MAX(p.citations) AS top_citations, COUNT(p) AS total
ORDER BY top_citations DESC

function_name(args) OVER (
  [PARTITION BY partition_expr, ...]
  [ORDER BY order_expr [ASC|DESC], ...]
)

MATCH (p:Paper)
RETURN p.title, p.venue, p.citations,
       rank() OVER (PARTITION BY p.venue ORDER BY p.citations DESC) AS venue_rank
ORDER BY p.venue, venue_rank

MATCH (p:Paper)
WHERE p.author = 'Alice'
RETURN p.title, p.year, p.citations,
       sum(p.citations) OVER (ORDER BY p.year) AS cumulative_citations
ORDER BY p.year

MATCH (p:Paper)
WITH p, row_number() OVER (PARTITION BY p.venue ORDER BY p.citations DESC) AS rn
WHERE rn <= 3
RETURN p.venue, p.title, p.citations
ORDER BY p.venue, p.citations DESC

-- Single vector source with auto-embedding
MATCH (d:Document) WHERE similar_to(d.embedding, 'search query') > 0.6
RETURN d.title, similar_to(d.embedding, 'search query') AS score

-- Multi-source hybrid (vector + FTS)
MATCH (d:Document)
RETURN d.title, similar_to([d.embedding, d.content], 'query') AS relevance
ORDER BY relevance DESC

-- Weighted fusion
MATCH (d:Document)
RETURN d.title, similar_to([d.embedding, d.content], 'query',
  {method: 'weighted', weights: [0.7, 0.3]}) AS score

// String manipulation
MATCH (p:Paper)
RETURN toUpper(p.title) AS upper_title,
       substring(p.abstract, 0, 100) AS abstract_preview

// Math operations
MATCH (p:Paper)
RETURN p.title, round(p.citations / 10.0) * 10 AS rounded_citations

// List operations
MATCH (a:Author)
WHERE size(a.affiliations) > 1
RETURN a.name, head(a.affiliations) AS primary_affiliation

// Type conversion
MATCH (p:Paper)
WHERE toInteger(p.year_str) > 2020
RETURN p.title

// Ascending (default)
ORDER BY p.year

// Descending
ORDER BY p.year DESC

// Multiple columns
ORDER BY p.year DESC, p.title ASC

// By alias
RETURN p.title, p.citations AS cites
ORDER BY cites DESC

// First 10 results
LIMIT 10

// Skip first 20, take next 10
SKIP 20
LIMIT 10

// Combined
RETURN p.title
ORDER BY p.year DESC
SKIP 100
LIMIT 25

// Simple node
CREATE (p:Paper {title: 'My Paper'})

// With properties
CREATE (p:Paper {
  title: 'New Research',
  year: 2024,
  venue: 'ArXiv',
  citations: 0
})
RETURN p

// Multiple nodes
CREATE (a:Author {name: 'Alice'}), (b:Author {name: 'Bob'})

// Between existing nodes
MATCH (p:Paper {title: 'Paper A'}), (a:Author {name: 'Alice'})
CREATE (p)-[:AUTHORED_BY {position: 1}]->(a)

// Create node and relationship together
CREATE (p:Paper {title: 'New Paper'})-[:AUTHORED_BY]->(a:Author {name: 'New Author'})

CREATE (p:Paper {title: 'My Paper', year: 2024})
RETURN p.title, p.year

// Filter after aggregation
MATCH (p:Paper)-[:AUTHORED_BY]->(a:Author)
WITH a, COUNT(p) AS paper_count
WHERE paper_count > 5
RETURN a.name, paper_count

// First find top authors, then their papers
MATCH (a:Author)<-[:AUTHORED_BY]-(p:Paper)
WITH a, COUNT(p) AS papers
ORDER BY papers DESC
LIMIT 10
MATCH (a)<-[:AUTHORED_BY]-(recent:Paper)
WHERE recent.year >= 2022
RETURN a.name, recent.title

// Expand literal list
UNWIND [1, 2, 3] AS num
RETURN num

// Expand list property
MATCH (p:Paper)
UNWIND p.keywords AS keyword
RETURN keyword, COUNT(*) AS usage
ORDER BY usage DESC

// Create multiple from list
UNWIND ['Alice', 'Bob', 'Charlie'] AS name
CREATE (a:Author {name: name})

// Basic vector search
CALL uni.vector.query('Paper', 'embedding', $query_vector, 10)
YIELD node, distance
RETURN node.title, distance

// With threshold
CALL uni.vector.query('Paper', 'embedding', $query_vector, 100, NULL, 0.3)
YIELD node, distance
WHERE distance < 0.2
RETURN node.title, distance

// List labels
CALL uni.schema.labels()
YIELD label
RETURN label

// List relationship types
CALL uni.schema.relationshipTypes()
YIELD relationshipType
RETURN relationshipType

// List indexes
CALL uni.schema.indexes()
YIELD name, type, label, properties, state
RETURN *

// Scalar index
CREATE INDEX ON :Paper(year)

// Named index
CREATE INDEX paper_year FOR (p:Paper) ON (p.year)

// Vector index
CREATE VECTOR INDEX paper_embeddings
FOR (p:Paper) ON p.embedding
OPTIONS {type: 'hnsw'}

// JSON Full-Text index
CREATE JSON FULLTEXT INDEX article_fts
FOR (a:Article) ON _doc
OPTIONS {with_positions: true}

DROP INDEX paper_year

SHOW INDEXES

// In query
MATCH (p:Paper)
WHERE p.year = $year AND p.venue = $venue
RETURN p.title

uni query "MATCH (p:Paper) WHERE p.year = \$year RETURN p" \
    --params '{"year": 2023}' \
    --path ./storage

// Basic validAt usage
MATCH (e:Event)
WHERE uni.temporal.validAt(e, 'valid_from', 'valid_to', datetime($time))
RETURN e.name, e.valid_from, e.valid_to

// Macro form (uses 'valid_from' and 'valid_to' by default)
MATCH (e:Event)
WHERE e VALID_AT datetime('2024-06-15T12:00:00Z')
RETURN e.name

// With custom property names
MATCH (c:Contract)
WHERE c VALID_AT(datetime($check_time), 'start_date', 'end_date')
RETURN c.name, c.value

MATCH (e:Employee)
WHERE uni.temporal.validAt(e, 'hire_date', 'termination_date', datetime())
RETURN e.name, e.department

MATCH (p:Price)
WHERE p.product_id = $product_id
  AND uni.temporal.validAt(p, 'effective_from', 'effective_to', datetime('2024-01-01'))
RETURN p.amount

MATCH (e:Employee)-[r:WORKS_IN]->(d:Department)
WHERE uni.temporal.validAt(r, 'start_date', 'end_date', datetime($as_of_date))
RETURN e.name, d.name

// Records with NULL valid_to are considered currently valid
MATCH (m:Membership)
WHERE m.valid_to IS NULL
  OR m.valid_to > datetime()
RETURN m

// Create an event with a year-precision interval
CREATE (e:Event {name: 'WW2', period: btic('1939/1945')})

// Query: find events overlapping with the 1940s
MATCH (e:Event) WHERE btic_overlaps(e.period, btic('1940')) RETURN e.name

// Comparison operators work on BTIC
MATCH (e:Event) WHERE e.period < btic('1950') RETURN e.name

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

// Set multiple properties at once
MATCH (n:Person {name: 'Alice'})
SET n.age = 25, n.email = 'alice@example.com'

// Set a property on a relationship
MATCH (a:Person)-[r:KNOWS]->(b:Person)
WHERE a.name = 'Alice' AND b.name = 'Bob'
SET r.since = 2020

MATCH (p:Person {name: $name})
SET p.age = $new_age

// Replace ALL properties on a node (keeps internal fields like _vid)
MATCH (n:Person {name: 'Alice'})
SET n = {name: 'Alice', age: 30, city: 'Boston'}

// Merge properties — existing keys are overwritten, others are preserved
MATCH (n:Person {name: 'Alice'})
SET n += {city: 'New York', verified: true}

// Add a label to an existing node
MATCH (p:Person {name: 'Alice'})
SET p:Employee

// Remove a property from a node
MATCH (u:User {name: 'Alice'})
REMOVE u.age
RETURN u.age  // returns null

// Remove a property from a relationship
MATCH (:User {name: 'Alice'})-[r:FOLLOWS]->(:User {name: 'Bob'})
REMOVE r.since
RETURN r.since  // returns null

// Remove a label from a node
MATCH (p:Person)
REMOVE p:Employee

// Create node if it doesn't exist, otherwise match it
MERGE (n:Person {name: 'Alice'})

// MERGE with property defaults
MERGE (n:Person {name: 'Alice'})
ON CREATE SET n.created_at = datetime()
ON MATCH SET n.last_seen = datetime()

// Different actions depending on create vs match
MERGE (p:Person {name: 'Alice'})
ON CREATE SET p.created = 1
ON MATCH SET p.matched = 1
RETURN p.created, p.matched

// Merge a relationship between existing nodes
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
MERGE (a)-[r:KNOWS]->(b)
RETURN r

// Find all people and their friends (if any)
MATCH (p:Person)
OPTIONAL MATCH (p)-[:KNOWS]->(friend:Person)
RETURN p.name, friend.name

// Find people who DON'T know anyone
MATCH (n:Person)
OPTIONAL MATCH (n)-[r:KNOWS]->()
WITH n, r
WHERE r IS NULL
RETURN n.name

// Optional traversal with variable-length paths
MATCH (a:Person {name: 'Alice'})
OPTIONAL MATCH (a)-[*1..3]->(b:Person)
RETURN a.name, b.name

// Delete a specific relationship
MATCH (a:Author)-[r:AUTHORED]->(p:Paper)
WHERE a.name = 'Alice' AND p.title = 'Old Paper'
DELETE r

// Delete all relationships of a type
MATCH ()-[r:DEPRECATED]->()
DELETE r

// Delete a node (must have no relationships)
MATCH (p:Paper {title: 'Deleted Paper'})
DELETE p

// Delete node and all its relationships (DETACH)
MATCH (p:Paper {title: 'Deleted Paper'})
DETACH DELETE p

// Delete multiple nodes
MATCH (p:Paper)
WHERE p.year < 1990
DETACH DELETE p

// Delete only if condition is met
MATCH (p:Paper)
WHERE p.citations = 0 AND p.year < 2000
DETACH DELETE p
RETURN COUNT(*) AS deleted_count

// Combine results, removing duplicates
MATCH (a:Author {affiliation: 'MIT'})
RETURN a.name AS name
UNION
MATCH (a:Author {affiliation: 'Stanford'})
RETURN a.name AS name

// Combine results, keeping all rows
MATCH (p:Paper)-[:CITES]->(:Paper {title: 'Paper A'})
RETURN p.title AS title
UNION ALL
MATCH (p:Paper)-[:CITES]->(:Paper {title: 'Paper B'})
RETURN p.title AS title

// Combine multiple queries
MATCH (a:Author) WHERE a.h_index > 50
RETURN a.name AS name, 'high_impact' AS category
UNION
MATCH (a:Author) WHERE a.papers > 100
RETURN a.name AS name, 'prolific' AS category
UNION
MATCH (a:Author) WHERE a.citations > 10000
RETURN a.name AS name, 'highly_cited' AS category

// Find all transitive citations (papers cited by papers cited by...)
WITH RECURSIVE citation_chain AS (
    -- Base case: direct citations
    MATCH (start:Paper {title: 'Original Paper'})-[:CITES]->(cited:Paper)
    RETURN cited, 1 AS depth

    UNION

    -- Recursive case: citations of citations
    MATCH (prev)-[:CITES]->(cited:Paper)
    WHERE prev IN citation_chain AND depth < 5
    RETURN cited, depth + 1
)
SELECT cited.title, depth FROM citation_chain

// Show query plan
EXPLAIN MATCH (p:Paper)-[:CITES]->(cited:Paper)
WHERE p.year > 2020
RETURN cited.title, COUNT(*) AS citation_count
ORDER BY citation_count DESC
LIMIT 10

Plan:
├─ Scan: Paper
│  ├─ Filter: year > 2020
│  │  └─ Index: paper_year_btree (BTREE) ✓
│  ├─ Estimated rows: 500
│  └─ Cost: 12.5
├─ Expand: CITES (OUTGOING)
│  ├─ Estimated paths: 2500
│  └─ Cost: 125.0
└─ Target: Paper
   └─ Estimated rows: 2500

Index Usage:
  ✓ Paper.year → paper_year_btree (BTREE)
  ✗ Paper.venue → paper_venue_idx (not in filter)

Total estimated cost: 137.5

MATCH (start:Paper {title: 'Attention Is All You Need'})
MATCH (start)-[:CITES]->(cited)
RETURN cited.title, cited.year
ORDER BY cited.year DESC

// Papers that cite each other
MATCH (a:Paper)-[:CITES]->(b:Paper)-[:CITES]->(a)
RETURN a.title, b.title

// Basic shortest path
MATCH path = shortestPath((a:Author {name: 'Alice'})-[:COAUTHOR*]-(b:Author {name: 'Bob'}))
RETURN path

// With hop constraints (minimum and maximum hops)
MATCH path = shortestPath((a:Person)-[:KNOWS*2..6]-(b:Person))
WHERE a.name = 'Alice' AND b.name = 'Bob'
RETURN path, length(path) AS hops

// Minimum hops only (at least 2 hops)
MATCH path = shortestPath((a)-[:FOLLOWS*2..]-(b))
RETURN path

// Maximum hops only (at most 5 hops)
MATCH path = shortestPath((a)-[:KNOWS*..5]-(b))
RETURN path

// Zero-length path (source equals target with min_hops=0)
MATCH path = shortestPath((a)-[:KNOWS*0..3]-(a))
RETURN path

// Count outgoing relationships
MATCH (p:Paper)-[c:CITES]->()
RETURN p.title, COUNT(c) AS out_degree
ORDER BY out_degree DESC

MATCH (p:Paper)
WITH p, p.citations AS cites
ORDER BY cites DESC
LIMIT 10
RETURN p.title, cites

// PageRank
CALL algo.pageRank(['Paper'], ['CITES'])
YIELD nodeId, score
RETURN nodeId, score
ORDER BY score DESC

// Betweenness Centrality
CALL algo.betweenness(['Author'], ['COAUTHOR'], true, 100)
YIELD nodeId, score

// Closeness Centrality
CALL algo.closeness(['Station'], ['CONNECTS'])
YIELD nodeId, score

// Louvain
CALL algo.louvain(['User'], ['INTERACTS'])
YIELD nodeId, communityId

// Label Propagation
CALL algo.labelPropagation(['User'], ['INTERACTS'])
YIELD nodeId, communityId

// Weakly Connected Components
CALL algo.wcc(['User'], ['INTERACTS'])
YIELD nodeId, componentId

// Strongly Connected Components
CALL algo.scc(['Task'], ['DEPENDS_ON'])
YIELD nodeId, componentId

// K-Core Decomposition
CALL algo.kCore(['User'], ['FRIEND'], 3)
YIELD nodeId, coreNumber

// Triangle Count
CALL algo.triangleCount(['User'], ['FRIEND'])
YIELD nodeId, triangleCount

// Dijkstra shortest path
CALL algo.dijkstra(['Station'], ['CONNECTS'], $startId, $endId, 'distance')
YIELD path, cost

// K-Shortest Paths
CALL algo.kShortestPaths(['Station'], ['CONNECTS'], $startId, $endId, 5)
YIELD path, cost

// All Pairs Shortest Path
CALL algo.allPairsShortestPath(['Station'], ['CONNECTS'])
YIELD sourceNodeId, targetNodeId, distance

// Node Similarity (Jaccard)
CALL algo.nodeSimilarity(['Product'], ['PURCHASED'])
YIELD node1, node2, similarity

// Random Walk
CALL algo.randomWalk(['Page'], ['LINKS'], 10, 5)
YIELD path

// Topological sort (for DAGs)
CALL algo.topologicalSort(['Task'], ['DEPENDS_ON'])
YIELD nodeId, order

// Find articulation points
CALL algo.articulationPoints(['Router'], ['CONNECTS'])
YIELD nodeId

// Minimum Spanning Tree
CALL algo.mst(['City'], ['ROAD'], 'distance')
YIELD edge, cost

// Maximum Matching
CALL algo.maxMatching(['Worker', 'Job'], ['CAN_DO'])
YIELD node1, node2

// Create a label with properties
CREATE LABEL Paper (
  title STRING NOT NULL,
  year INT32,
  abstract STRING,
  embedding VECTOR(768)
)

// Create label with default values
CREATE LABEL Author (
  name STRING NOT NULL,
  h_index INT32 DEFAULT 0,
  active BOOLEAN DEFAULT true
)

// Create edge type with source/destination constraints
CREATE EDGE TYPE AUTHORED FROM Author TO Paper (
  position INT32,
  corresponding BOOLEAN DEFAULT false
)

// Edge type between multiple label types
CREATE EDGE TYPE COLLABORATES FROM Author TO Author (
  papers_count INT32
)

// Add a property to an existing label
ALTER LABEL Paper ADD abstract STRING

// Drop a property
ALTER LABEL Paper DROP deprecated_field

// Rename a property
ALTER LABEL Paper RENAME old_name TO new_name

// Drop a label (must have no vertices)
DROP LABEL TempLabel

// Drop an edge type
DROP EDGE TYPE OLD_RELATIONSHIP

// Unique constraint
CREATE CONSTRAINT paper_doi_unique
FOR (p:Paper) REQUIRE p.doi IS UNIQUE

// Existence constraint (property must be present)
CREATE CONSTRAINT author_name_exists
FOR (a:Author) REQUIRE a.name IS NOT NULL

// Check constraint (custom validation)
CREATE CONSTRAINT paper_year_valid
FOR (p:Paper) REQUIRE p.year >= 1900 AND p.year <= 2100

// List all constraints
SHOW CONSTRAINTS

// Filter by label
SHOW CONSTRAINTS FOR :Paper

DROP CONSTRAINT paper_doi_unique

// Backup to local path
BACKUP TO './backups/backup_2026_01_17'

// Backup to S3
BACKUP TO 's3://my-bucket/backups/backup_2026_01_17'

CHECKPOINT

VACUUM

// Trigger storage compaction
CALL uni.admin.compact()
YIELD files_compacted, bytes_before, bytes_after, duration_ms

// Check compaction status
CALL uni.admin.compactionStatus()
YIELD l1_runs, l1_size_bytes, in_progress, pending

// Create a named snapshot
CALL uni.admin.snapshot.create('before_migration')
YIELD snapshot_id

// List available snapshots
CALL uni.admin.snapshot.list()
YIELD snapshot_id, name, created_at, version_hwm

// Restore to a snapshot
CALL uni.admin.snapshot.restore('before_migration')
YIELD status

// List all labels
CALL uni.schema.labels()
YIELD label, propertyCount, nodeCount, indexCount
RETURN label, nodeCount

// List all relationship types
CALL uni.schema.relationshipTypes()
YIELD type, sourceLabels, targetLabels, propertyCount
RETURN type

// List all edge types (alias)
CALL uni.schema.edgeTypes()
YIELD type, sourceLabels, targetLabels, propertyCount

// List all indexes
CALL uni.schema.indexes()
YIELD name, type, label, properties, state
WHERE type = 'VECTOR'
RETURN name, label

// List all constraints
CALL uni.schema.constraints()
YIELD name, type, label, properties, enabled
RETURN name, type

// Get detailed label info
CALL uni.schema.labelInfo('Paper')
YIELD property, dataType, nullable, indexed, unique
RETURN property, dataType

// Create a new label
CALL uni.schema.createLabel('Product', {
  properties: {
    name: { type: 'STRING', nullable: false },
    price: { type: 'FLOAT64' },
    embedding: { type: 'VECTOR' }
  }
})

// Create an edge type
CALL uni.schema.createEdgeType('PURCHASED', ['Customer'], ['Product'], {
  properties: {
    quantity: { type: 'INT32' },
    timestamp: { type: 'TIMESTAMP' }
  }
})

// Create an index
CALL uni.schema.createIndex('Product', 'name', { type: 'BTREE' })

// Create a vector index
CALL uni.schema.createIndex('Product', 'embedding', {
  type: 'VECTOR'
})

// Create a constraint
CALL uni.schema.createConstraint('Product', 'UNIQUE', ['sku'])

// Drop operations
CALL uni.schema.dropLabel('TempLabel')
CALL uni.schema.dropEdgeType('OLD_RELATIONSHIP')
CALL uni.schema.dropIndex('Product', 'old_index')
CALL uni.schema.dropConstraint('Product', 'constraint_name')

{
  "properties": {
    "Paper": {
      "title": { "type": "String", "nullable": false },
      "view_count": { "type": "Crdt", "crdt_type": "GCounter" },
      "tags": { "type": "Crdt", "crdt_type": "ORSet" },
      "metadata": { "type": "Crdt", "crdt_type": "LWWMap" }
    }
  }
}