Schema clauses

Schema statements manage the indexes, constraintsconstraint A rule the store enforces on every write, such as a unique property, a required property, a property type or a node key; a violating write fails. Read more in the glossary and graph typegraph type A schema for a whole graph, declared in Cypher, that lists node and relationship types with their properties; writes that break it fail. Read more in the glossary of a storestore A relate database: a directory, a single .rl file, or :memory:, opened with --database. Read more in the glossary. An index speeds up lookups and searches; a constraint is a rule every write must satisfy; a graph type declares the node and relationship types of the whole graph and turns each declaration into constraints. Each statement takes effect when it commits. On success, CREATE and DROP return no rows, and the CLI prints nothing; SHOW INDEXES and SHOW CONSTRAINTS are how to see what changed.

Synopsis

CREATE [RANGE] INDEX [<name>] [IF NOT EXISTS]
  FOR (<v>:<Label>) ON (<v>.<property> [, <v>.<property> …]) [OPTIONS {…}]
CREATE [RANGE] INDEX [<name>] [IF NOT EXISTS]
  FOR ()-[<v>:<TYPE>]-() ON (<v>.<property> [, <v>.<property> …]) [OPTIONS {…}]
CREATE TEXT INDEX [<name>] [IF NOT EXISTS]
  FOR (<v>:<Label>) | ()-[<v>:<TYPE>]-() ON (<v>.<property>) [OPTIONS {…}]
CREATE POINT INDEX [<name>] [IF NOT EXISTS]
  FOR (<v>:<Label>) | ()-[<v>:<TYPE>]-() ON (<v>.<property>) [OPTIONS {…}]
CREATE LOOKUP INDEX [<name>] [IF NOT EXISTS] FOR (<v>) ON EACH labels(<v>) [OPTIONS {…}]
CREATE LOOKUP INDEX [<name>] [IF NOT EXISTS] FOR ()-[<v>]-() ON EACH type(<v>) [OPTIONS {…}]
CREATE VECTOR INDEX …      (see the search reference)
CREATE FULLTEXT INDEX …    (see the search reference)
DROP INDEX <name> [IF EXISTS]
SHOW [ALL | RANGE | TEXT | POINT | LOOKUP | VECTOR | FULLTEXT] INDEXES
  [YIELD <column> [, …] | YIELD *] [WHERE <predicate>] [RETURN …]

CREATE CONSTRAINT [<name>] [IF NOT EXISTS]
  FOR (<v>:<Label>) | ()-[<v>:<TYPE>]-()
  REQUIRE <property list> IS [NODE | RELATIONSHIP] UNIQUE
        | <property list> IS NOT NULL
        | <property list> IS [NODE | RELATIONSHIP] KEY
        | <v>.<property> IS :: <type> | IS TYPED <type>
  <property list> = <v>.<property> | (<v>.<property>, <v>.<property> …)
DROP CONSTRAINT <name> [IF EXISTS]
SHOW [<filter>] CONSTRAINTS [YIELD <column> [, …] | YIELD *] [WHERE <predicate>] [RETURN …]
  <filter> = ALL | [NODE | REL | RELATIONSHIP] [[PROPERTY] UNIQUE | UNIQUENESS | EXIST | EXISTENCE | TYPE | KEY]

CREATE GRAPH TYPE <name> [AS] { <element type or constraint> [, …] }
ALTER CURRENT GRAPH TYPE SET { … } | SET GRAPH TYPE <name> | ADD { … } | ALTER { … } | DROP { … }
SHOW CURRENT GRAPH TYPE [YIELD specification RETURN …]
SHOW CURRENT GRAPH TYPE AS GRAPH [SINGLE | SEPARATE]

Indexes

A new store has no indexes. A point indexpoint index An index over a property holding point values that narrows bounding-box and radius predicates to nearby nodes through an R-tree. Read more in the glossary narrows distance and bounding-box predicates on point values (geospatial).

SHOW INDEXES columns

Constraints

Constraint violations

A write that breaks a constraint fails, and the statement changes nothing. The message names the constraint and the rule:

Under the CLI the first three exit with code 6, the implied-label violation with code 1.

SHOW CONSTRAINTS filters and columns

The <filter> in the synopsis has an entity part and a kind part, both optional. NODE limits the list to node constraints, REL or RELATIONSHIP to relationship constraints; PROPERTY before UNIQUE, UNIQUENESS, EXIST, EXISTENCE or TYPE changes nothing in the result.

The columns are id (0 for every constraint), name, type, entityType, labelsOrTypes, properties, ownedIndex, propertyType and enforcedLabel; YIELD * adds options, createStatement and classification.

Graph types

A graph type lists node element types, (:<Label> => {<property> :: <type> [NOT NULL], …}), and relationship element types, (:<Label> =>)-[:<TYPE> => {…}]->(:<Label> =>). The => (or IMPLIES) after a label is required before a property block. A property declaration can end in IS KEY or IS UNIQUE, and a CONSTRAINT … REQUIRE … entry can sit in the list. A graph type is open: nodes with labels it does not declare are accepted.

Setting a type creates the constraints it implies, which SHOW CONSTRAINTS lists under generated names, including RELATIONSHIP_SOURCE_LABEL and RELATIONSHIP_TARGET_LABEL for a relationship's endpoints. Data that breaks the new type makes the ALTER fail with the violation message. Constraints created with CREATE CONSTRAINT while a type is current appear in its specification. Optional properties, default values and inheritance between element types are preview features (Cypher overview).

Schema procedures

The procedures page lists the rest.

Examples

The cells run in page order on one in-memory store, starting from the shared example graph:

CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
       (grace:Person {name: 'Grace', role: 'engineer'}),
       (noor:Person {name: 'Noor', role: 'maintainer'}),
       (relate:Project {name: 'relate', language: 'Rust'}),
       (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
       (ada)-[:WORKS_ON {since: 2024}]->(relate),
       (grace)-[:WORKS_ON {since: 2023}]->(relate),
       (grace)-[:WORKS_ON {since: 2022}]->(tck),
       (noor)-[:MAINTAINS]->(relate),
       (ada)-[:KNOWS]->(grace)

(no rows) · nodes created: 5, relationships created: 5, properties set: 13, labels added: 5

One index of three kinds, then the list:

CREATE INDEX works_on_since IF NOT EXISTS FOR ()-[w:WORKS_ON]-() ON (w.since);
CREATE TEXT INDEX person_role IF NOT EXISTS FOR (p:Person) ON (p.role);
CREATE LOOKUP INDEX node_labels IF NOT EXISTS FOR (n) ON EACH labels(n)

(no rows) · indexes added: 3

SHOW INDEXES YIELD name, type, entityType, labelsOrTypes, properties
RETURN name, type, entityType, labelsOrTypes, properties
ORDER BY name

| name             | type     | entityType     | labelsOrTypes | properties |
|------------------|----------|----------------|---------------|------------|
| "node_labels"    | "LOOKUP" | "NODE"         | null          | null       |
| "person_role"    | "TEXT"   | "NODE"         | ["Person"]    | ["role"]   |
| "works_on_since" | "RANGE"  | "RELATIONSHIP" | ["WORKS_ON"]  | ["since"]  |
3 rows

A uniqueness constraint owns an index, so the index cannot be dropped on its own:

CREATE CONSTRAINT person_name IF NOT EXISTS FOR (p:Person) REQUIRE p.name IS UNIQUE

(no rows) · constraints added: 1

DROP INDEX person_name

error: Unable to drop 'person_name': the index belongs to a constraint.

A second Ada breaks the constraint, and the write fails:

CREATE (:Person {name: 'Ada', role: 'designer'})

error: semantic error: ConstraintValidationFailed: `person_name` uniqueness

A constraint that existing data breaks is not created: two people share the role engineer:

CREATE CONSTRAINT person_role_unique FOR (p:Person) REQUIRE p.role IS UNIQUE

error: semantic error: ConstraintValidationFailed: `person_role_unique` uniqueness

Constraints listed by filter:

SHOW UNIQUE CONSTRAINTS YIELD name, type, labelsOrTypes, properties, ownedIndex
RETURN name, type, labelsOrTypes, properties, ownedIndex

| name          | type                       | labelsOrTypes | properties | ownedIndex    |
|---------------|----------------------------|---------------|------------|---------------|
| "person_name" | "NODE_PROPERTY_UNIQUENESS" | ["Person"]    | ["name"]   | "person_name" |
1 row

DROP CONSTRAINT removes the constraint and its index; a missing name with IF EXISTS is no error:

DROP CONSTRAINT person_name;
DROP CONSTRAINT person_name IF EXISTS;
SHOW INDEXES YIELD name RETURN collect(name) AS indexes

| indexes                                          |
|--------------------------------------------------|
| ["node_labels", "person_role", "works_on_since"] |
1 row · constraints removed: 1

A graph type for the example graph, registered and then made current:

CREATE GRAPH TYPE team {
  (p:Person => {name :: STRING NOT NULL, role :: STRING}),
  (r:Project => {name :: STRING NOT NULL, language :: STRING}),
  (p)-[:WORKS_ON => {since :: INTEGER}]->(r)
};
ALTER CURRENT GRAPH TYPE SET GRAPH TYPE team;
SHOW CURRENT GRAPH TYPE YIELD specification RETURN specification

| specification                                                                                                                                                                                                          |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| "{\n  (:`Person` => {`name` :: STRING NOT NULL, `role` :: STRING}),\n  (:`Project` => {`language` :: STRING, `name` :: STRING NOT NULL}),\n  (:`Person` =>)-[:`WORKS_ON` => {`since` :: INTEGER}]->(:`Project` =>)\n}" |
1 row · constraints added: 9

A person without a name now fails:

CREATE (:Person {role: 'engineer'})

error: semantic error: ConstraintValidationFailed: `constraint_238af3a3` requires properties

The inferred node schema:

CALL db.schema.nodeTypeProperties() YIELD nodeType, propertyName, propertyTypes, mandatory
RETURN nodeType, propertyName, propertyTypes, mandatory
ORDER BY nodeType, propertyName

| nodeType   | propertyName | propertyTypes       | mandatory |
|------------|--------------|---------------------|-----------|
| ":Person"  | "name"       | ["STRING NOT NULL"] | true      |
| ":Person"  | "role"       | ["STRING NOT NULL"] | true      |
| ":Project" | "language"   | ["STRING NOT NULL"] | true      |
| ":Project" | "name"       | ["STRING NOT NULL"] | true      |
4 rows

See also

• Indexes and constraints: choosing and adding them, step by step.
• Search: vector and full-text index options and the SEARCH clause.
• Differences from Neo4j: DROP INDEX and DROP CONSTRAINT print nothing on success.
• Procedures: every built-in procedure.
• Writing clauses: the writes constraints check.