diff --git a/modules/ROOT/content-nav.adoc b/modules/ROOT/content-nav.adoc index e07c65db3..6baa67e19 100644 --- a/modules/ROOT/content-nav.adoc +++ b/modules/ROOT/content-nav.adoc @@ -118,9 +118,18 @@ *** xref:indexes/semantic-indexes/vector-indexes.adoc[] ** xref:indexes/syntax.adoc[] -* xref:constraints/index.adoc[] -** xref:constraints/managing-constraints.adoc[] -** xref:constraints/syntax.adoc[] +* xref:schema/index.adoc[] +** xref:schema/graph-types/index.adoc[] +*** xref:schema/graph-types/set-graph-types.adoc[] +*** xref:schema/graph-types/extend-graph-types.adoc[] +*** xref:schema/graph-types/alter-element-types.adoc[] +*** xref:schema/graph-types/list-graph-types.adoc[] +*** xref:schema/graph-types/drop-graph-type-elements.adoc[] +** xref:schema/constraints/index.adoc[] +*** xref:schema/constraints/create-constraints.adoc[] +*** xref:schema/constraints/list-constraints.adoc[] +*** xref:schema/constraints/drop-constraints.adoc[] +** xref:schema/syntax.adoc[] * xref:planning-and-tuning/index.adoc[] ** xref:planning-and-tuning/execution-plans.adoc[] diff --git a/modules/ROOT/images/graph-types-alter-graph-type.svg b/modules/ROOT/images/graph-types-alter-graph-type.svg new file mode 100644 index 000000000..d0eab59f6 --- /dev/null +++ b/modules/ROOT/images/graph-types-alter-graph-type.svg @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-data-in-database.svg b/modules/ROOT/images/graph-types-data-in-database.svg new file mode 100644 index 000000000..dbf92d442 --- /dev/null +++ b/modules/ROOT/images/graph-types-data-in-database.svg @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-data-model.svg b/modules/ROOT/images/graph-types-data-model.svg new file mode 100644 index 000000000..8038f4d7d --- /dev/null +++ b/modules/ROOT/images/graph-types-data-model.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-element-type-constraints.svg b/modules/ROOT/images/graph-types-element-type-constraints.svg new file mode 100644 index 000000000..99f52a371 --- /dev/null +++ b/modules/ROOT/images/graph-types-element-type-constraints.svg @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-extend-graph-type.svg b/modules/ROOT/images/graph-types-extend-graph-type.svg new file mode 100644 index 000000000..07ecbc5fc --- /dev/null +++ b/modules/ROOT/images/graph-types-extend-graph-type.svg @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-node-element-type.svg b/modules/ROOT/images/graph-types-node-element-type.svg new file mode 100644 index 000000000..dd10917f6 --- /dev/null +++ b/modules/ROOT/images/graph-types-node-element-type.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-relationship-element-type.svg b/modules/ROOT/images/graph-types-relationship-element-type.svg new file mode 100644 index 000000000..5e75e966b --- /dev/null +++ b/modules/ROOT/images/graph-types-relationship-element-type.svg @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff --git a/modules/ROOT/images/graph-types-set-graph-type-populated-database.svg b/modules/ROOT/images/graph-types-set-graph-type-populated-database.svg new file mode 100644 index 000000000..f6fc430a2 --- /dev/null +++ b/modules/ROOT/images/graph-types-set-graph-type-populated-database.svg @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/modules/ROOT/pages/appendix/gql-conformance/additional-cypher.adoc b/modules/ROOT/pages/appendix/gql-conformance/additional-cypher.adoc index 04bf0de57..06bc7408e 100644 --- a/modules/ROOT/pages/appendix/gql-conformance/additional-cypher.adoc +++ b/modules/ROOT/pages/appendix/gql-conformance/additional-cypher.adoc @@ -619,16 +619,16 @@ GQL supports `GRAPH TYPES` as a way of constraining a graph schema, but does not | Cypher feature | Description -| xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[Property uniqueness constraints] +| xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[Property uniqueness constraints] | Ensures that the combined property values are unique for all nodes with a specific label or all relationships with a specific type. -| xref:constraints/managing-constraints.adoc#create-property-existence-constraints[Property existence constraints] +| xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[Property existence constraints] | Ensures that a property exists either for all nodes with a specific label or for all relationships with a specific type. -| xref:constraints/managing-constraints.adoc#create-property-type-constraints[Property type constraints] +| xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[Property type constraints] | Ensures that a property has the required property type for all nodes with a specific label or for all relationships with a specific type. -| xref:constraints/managing-constraints.adoc#create-key-constraints[Key constraints] +| xref:schema/constraints/create-constraints.adoc#create-key-constraints[Key constraints] | Ensures that all properties exist and that the combined property values are unique for all nodes with a specific label or all relationships with a specific type. |=== diff --git a/modules/ROOT/pages/appendix/tutorials/advanced-query-tuning.adoc b/modules/ROOT/pages/appendix/tutorials/advanced-query-tuning.adoc index 5d5816465..ca0b80f3a 100644 --- a/modules/ROOT/pages/appendix/tutorials/advanced-query-tuning.adoc +++ b/modules/ROOT/pages/appendix/tutorials/advanced-query-tuning.adoc @@ -936,7 +936,7 @@ Predicates that will not work: [NOTE] ==== -If there is a xref:constraints/managing-constraints.adoc#create-property-existence-constraints[property existence constraint] on the property, no predicate is required to trigger the optimization. +If there is a xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[property existence constraint] on the property, no predicate is required to trigger the optimization. For example, `CREATE CONSTRAINT constraint_name FOR (p:Person) REQUIRE p.name IS NOT NULL` Predicates with parameters, such as `WHERE n.prop > $param`, can trigger _index-backed ORDER BY_. diff --git a/modules/ROOT/pages/clauses/delete.adoc b/modules/ROOT/pages/clauses/delete.adoc index de7d8bf7c..6225c5f93 100644 --- a/modules/ROOT/pages/clauses/delete.adoc +++ b/modules/ROOT/pages/clauses/delete.adoc @@ -142,9 +142,9 @@ DETACH DELETE n Deleted 3 nodes, deleted 1 relationship ---- -`DETACH DELETE` is useful when experimenting with small example datasets, but it is not suitable for deleting large amounts of data, nor does it delete xref:indexes/search-performance-indexes/index.adoc[indexes] and xref:constraints/index.adoc[constraints]. +`DETACH DELETE` is useful when experimenting with small example datasets, but it is not suitable for deleting large amounts of data, nor does it delete xref:indexes/search-performance-indexes/index.adoc[indexes] or any xref:schema/index.adoc[schema]. -To delete large amounts of data without deleting indexes and constraints, use xref::subqueries/subqueries-in-transactions.adoc#delete-with-call-in-transactions[CALL subqueries in transactions] instead. +To delete large amounts of data without deleting indexes and any schema, use xref::subqueries/subqueries-in-transactions.adoc#delete-with-call-in-transactions[CALL subqueries in transactions] instead. .Delete all nodes and relationships using `CALL` subqueries [source, cypher] diff --git a/modules/ROOT/pages/clauses/index.adoc b/modules/ROOT/pages/clauses/index.adoc index cb62f13f4..747aa5b98 100644 --- a/modules/ROOT/pages/clauses/index.adoc +++ b/modules/ROOT/pages/clauses/index.adoc @@ -266,10 +266,10 @@ m| xref::indexes/search-performance-indexes/index-hints.adoc#query-using-join-hi |=== -[[index-and-constraint-clauses]] -== Index and constraint clauses +[[index-and-schema-clauses]] +== Index and schema clauses -These comprise clauses to create, show, and drop indexes and constraints. +These comprise clauses to manage indexes, constraints, and graph types. [options="header"] |=== @@ -278,8 +278,15 @@ These comprise clauses to create, show, and drop indexes and constraints. m| xref:indexes/syntax.adoc[CREATE \| SHOW \| DROP INDEX] | Create, show or drop an index. -m| xref::constraints/syntax.adoc[CREATE \| SHOW \| DROP CONSTRAINT] +m| xref::schema/syntax.adoc#constraints[CREATE \| SHOW \| DROP CONSTRAINT] | Create, show or drop a constraint. + +m| xref::schema/syntax.adoc#graph-types[ALTER CURRENT GRAPH TYPE SET \| ADD \| ALTER \|DROP] +| Set, extend, alter or drop elements in a graph type. + +m| xref::schema/syntax.adoc#list-graph-types[SHOW CURRENT GRAPH TYPE] +| Show the full graph type. + |=== [[administration-clauses]] diff --git a/modules/ROOT/pages/clauses/load-csv.adoc b/modules/ROOT/pages/clauses/load-csv.adoc index 79ca46b9c..bdbd58d63 100644 --- a/modules/ROOT/pages/clauses/load-csv.adoc +++ b/modules/ROOT/pages/clauses/load-csv.adoc @@ -661,7 +661,7 @@ For more `STRING` manipulation functions, see xref:functions/string.adoc[String === Create property uniqueness constraints -Always create xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraints] prior to importing data, to avoid duplicates or colliding entities. +Always create xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraints] prior to importing data, to avoid duplicates or colliding entities. If the source file contains duplicated data and the right constraints are in place, Cypher raises an error. .Create a node property uniqueness constraints on person ID diff --git a/modules/ROOT/pages/clauses/merge.adoc b/modules/ROOT/pages/clauses/merge.adoc index 6e20bd3f6..c0f143eec 100644 --- a/modules/ROOT/pages/clauses/merge.adoc +++ b/modules/ROOT/pages/clauses/merge.adoc @@ -25,7 +25,7 @@ If partial matches are needed, this can be accomplished by splitting a pattern i [NOTE] ==== Under concurrent updates, `MERGE` only guarantees the existence of the `MERGE` pattern, but not uniqueness. -To guarantee uniqueness of nodes with certain properties, a xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraint] should be used. +To guarantee uniqueness of nodes with certain properties, a xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraint] should be used. See xref::clauses/merge.adoc#query-merge-using-unique-constraints[Using property uniqueness constraints with `MERGE`]. ==== @@ -512,7 +512,7 @@ This is in contrast to the example shown above in xref::clauses/merge.adoc#merge [[query-merge-using-unique-constraints]] == Using node property uniqueness constraints with `MERGE` -Cypher prevents getting conflicting results from `MERGE` when using patterns that involve xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraints]. +Cypher prevents getting conflicting results from `MERGE` when using patterns that involve xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraints]. In this case, there must be at most one node that matches that pattern. For example, given two property node uniqueness constraints on `:Person(id)` and `:Person(ssn)`, a query such as `MERGE (n:Person {id: 12, ssn: 437})` will fail, if there are two different nodes (one with `id` 12 and one with `ssn` 437), or if there is only one node with only one of the properties. diff --git a/modules/ROOT/pages/clauses/optional-match.adoc b/modules/ROOT/pages/clauses/optional-match.adoc index 9526a71d4..414d059f2 100644 --- a/modules/ROOT/pages/clauses/optional-match.adoc +++ b/modules/ROOT/pages/clauses/optional-match.adoc @@ -49,7 +49,7 @@ For example, the matching variables from one `MATCH` clause will provide the con However, there are two important differences between Neo4j and SQL which helps to explain `OPTIONAL MATCH` further. . While it is both possible and advised to enforce partial schemas using indexes and constraints, Neo4j offers a greater degree of schema flexibility than a relational database. -Nodes and relationships in a Neo4j database do not have to have a specific property set to them because other nodes or relationships in the same graph have that property (unless there is a xref:constraints/managing-constraints.adoc#create-property-existence-constraints[property existence constraint] created on the specific property). +Nodes and relationships in a Neo4j database do not have to have a specific property set to them because other nodes or relationships in the same graph have that property (unless there is a xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[property existence constraint] created on the specific property). . Queries in Cypher are run as pipelines. If a clause returns no results, it will effectively end the query as subsequent clauses will have no data to execute upon. diff --git a/modules/ROOT/pages/constraints/index.adoc b/modules/ROOT/pages/constraints/index.adoc deleted file mode 100644 index 5ae7f1828..000000000 --- a/modules/ROOT/pages/constraints/index.adoc +++ /dev/null @@ -1,16 +0,0 @@ -:description: Overview of Neo4j's constraints used for ensuring data integrity. -include::https://raw.githubusercontent.com/neo4j-graphacademy/courses/main/asciidoc/courses/cypher-indexes-constraints/ad.adoc[] -= Constraints - -Neo4j offers several constraints to ensure the quality and integrity of data in a graph. -The following constraints are available in Neo4j: - -* xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[Property uniqueness constraints]: ensure that the combined property values are unique for all nodes with a specific label or all relationships with a specific type. -* xref:constraints/managing-constraints.adoc#create-property-existence-constraints[Property existence constraints]: ensure that a property exists either for all nodes with a specific label or for all relationships with a specific type. label:enterprise-edition[] -* xref:constraints/managing-constraints.adoc#create-property-type-constraints[Property type constraints]: ensure that a property has the required property type for all nodes with a specific label or for all relationships with a specific type. label:enterprise-edition[] -* xref:constraints/managing-constraints.adoc#create-key-constraints[Key constraints]: ensure that all properties exist and that the combined property values are unique for all nodes with a specific label or all relationships with a specific type.label:enterprise-edition[] - -To learn more about creating, listing, and dropping these constraints, as well as information about index-backed constraints, constraint creation failures and data violation scenarios, and more, see xref:constraints/managing-constraints.adoc[]. - -For reference material about the Cypher commands used to manage constraints, see xref:constraints/syntax.adoc[]. - diff --git a/modules/ROOT/pages/constraints/syntax.adoc b/modules/ROOT/pages/constraints/syntax.adoc deleted file mode 100644 index e381c7bf6..000000000 --- a/modules/ROOT/pages/constraints/syntax.adoc +++ /dev/null @@ -1,319 +0,0 @@ -:description: Syntax for how to manage constraints used for ensuring data integrity. - -[[constraints-syntax]] -= Syntax -:check-mark: icon:check[] - -This page contains the syntax for creating, listing, and dropping the constraints available in Neo4j. - -More details about the syntax can be found in the link:{neo4j-docs-base-uri}/operations-manual/current/database-administration/syntax/[Operations Manual -> Cypher syntax for administration commands]. - -[[constraints-syntax-create]] -== CREATE CONSTRAINT - -Constraints are created with the `CREATE CONSTRAINT` command. -When creating a constraint, it is recommended to provide a constraint name. -This name must be unique among both indexes and constraints. -If a name is not explicitly given, a unique name will be auto-generated. - -[NOTE] -Creating a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT` privilege]. - -The `CREATE CONSTRAINT` command is optionally idempotent. -This means its default behavior is to throw an error if an attempt is made to create the same constraint twice. -With the `IF NOT EXISTS` flag, no error is thrown and nothing happens should a constraint with the same name or same schema and constraint type already exist. -It may still throw an error if conflicting data, indexes, or constraints exist. -Examples of this are nodes with missing properties, indexes with the same name, or constraints with same schema but a different conflicting constraint type. -An informational notification is returned in case nothing happens showing the existing constraint which blocks the creation. - -[[create-property-uniqueness-constraints]] -=== Create property uniqueness constraints - -.Syntax for creating a node property uniqueness constraint on a single property -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR (n:LabelName) -REQUIRE n.propertyName IS [NODE] UNIQUE ----- - -.Syntax for creating a composite node property uniqueness constraint on multiple properties -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR (n:LabelName) -REQUIRE (n.propertyName_1, ..., n.propertyName_n) IS [NODE] UNIQUE ----- - -.Syntax for creating a relationship property uniqueness constraint on a single property -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR ()-"["r:RELATIONSHIP_TYPE"]"-() -REQUIRE r.propertyName IS [REL[ATIONSHIP]] UNIQUE ----- - -.Syntax for creating a composite relationship property uniqueness constraint on multiple properties -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR ()-"["r:RELATIONSHIP_TYPE"]"-() -REQUIRE (r.propertyName_1, ..., r.propertyName_n) IS [REL[ATIONSHIP]] UNIQUE ----- - -For examples on how to create property uniqueness constraints, see xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[Create, show, and drop constraints -> Create property uniqueness constraint]. -Property uniqueness constraints are xref:constraints/managing-constraints.adoc#constraints-and-indexes[index-backed]. - -[role=label--enterprise-edition] -[[create-property-existence-constraints]] -=== Create property existence constraints - -.Syntax for creating a node property existence constraint -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR (n:LabelName) -REQUIRE n.propertyName IS NOT NULL ----- - -.Syntax for creating a relationship property existence constraint -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR ()-"["r:RELATIONSHIP_TYPE"]"-() -REQUIRE r.propertyName IS NOT NULL ----- - -For examples on how to create property existence constraints, see xref:constraints/managing-constraints.adoc#create-property-existence-constraints[Create, show, and drop constraints -> Create property existence constraints]. - -[role=label--enterprise-edition] -[[create-property-type-constraints]] -=== Create property type constraints - -.Syntax for creating a node property type constraint -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR (n:LabelName) -REQUIRE n.propertyName {[IS] :: | IS TYPED} ----- - -.Syntax for creating a relationship property type constraint -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR ()-"["r:RELATIONSHIP_TYPE"]"-() -REQUIRE r.propertyName {[IS] :: | IS TYPED} ----- - -The three variations of the expression, `IS ::`, `::`, and `IS TYPED` are syntactic synonyms for the same expression. -The preferred syntax is the `IS ::` variant. - -Where `` is one of the following property types: - -* `BOOLEAN` -* `STRING` -* `INTEGER` -* `FLOAT` -* `DATE` -* `LOCAL TIME` -* `ZONED TIME` -* `LOCAL DATETIME` -* `ZONED DATETIME` -* `DURATION` -* `POINT` -* `VECTOR(DIMENSION)` label:cypher[Cypher 25 only] label:new[Introduced in Neo4j 2025.10] -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* `LIST` -* Any closed dynamic union of the above types, e.g. `INTEGER | FLOAT | STRING`. - -[NOTE] -Because storing lists of xref:values-and-types/vector.adoc[`VECTOR`] values is not supported, property type constraints cannot be created for `LIST(DIMENSION) NOT NULL>`. -Additionally, `VECTOR` property type constraints must be created with a specific dimension and coordinate value, where the dimension must be greater than `0` and less than or equal to `4096`. -For more information, see xref:values-and-types/vector.adoc[Values and types -> Vectors]. - -Allowed syntax variations of these types are listed in xref::values-and-types/property-structural-constructed.adoc#types-synonyms[Types and their synonyms]. - -For examples on how to create property type constraints, see xref:constraints/managing-constraints.adoc#create-property-type-constraints[Create, show, and drop constraints -> Create property type constraints]. - - -[role=label--enterprise-edition] -[[create-key-constraints]] -=== Create key constraints - -.Syntax for creating a node key constraint on a single property -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR (n:LabelName) -REQUIRE n.propertyName IS [NODE] KEY ----- - -.Syntax for creating a composite node key constraint on multiple properties -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR (n:LabelName) -REQUIRE (n.propertyName_1, ..., n.propertyName_n) IS [NODE] KEY ----- - -.Syntax for creating a relationship key constraint on a single property -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR ()-"["r:RELATIONSHIP_TYPE"]"-() -REQUIRE r.propertyName IS [REL[ATIONSHIP]] KEY ----- - -.Syntax for creating a composite relationship key constraint on multiple properties -[source, syntax] ----- -CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] -FOR ()-"["r:RELATIONSHIP_TYPE"]"-() -REQUIRE (r.propertyName_1, ..., r.propertyName_n) IS [REL[ATIONSHIP]] KEY ----- - -For examples on how to create key constraints, see xref:constraints/managing-constraints.adoc#create-key-constraints[Create, show, and drop constraints -> Create key constraints]. -Key constraints are xref:constraints/managing-constraints.adoc#constraints-and-indexes[index-backed]. - - -[[list-constraints]] -== SHOW CONSTRAINTS - -To list all constraints with the default output columns, use `SHOW CONSTRAINTS`. -If all columns are required, use `SHOW CONSTRAINTS YIELD *`. -If only specific columns are required, use `SHOW CONSTRAINTS YIELD field[, ...]`. -The `SHOW CONSTRAINTS` clause can also be filtered using the xref:clauses/where.adoc[`WHERE`] clause. - -[NOTE] -Listing constraints requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. - - -.Syntax to list constraints with default return columns -[source, syntax] ----- -SHOW [ - ALL - |NODE [PROPERTY] UNIQUE[NESS] - |REL[ATIONSHIP] [PROPERTY] UNIQUE[NESS] - |[PROPERTY] UNIQUE[NESS] - |NODE [PROPERTY] EXIST[ENCE] - |REL[ATIONSHIP] [PROPERTY] EXIST[ENCE] - |[PROPERTY] EXIST[ENCE] - |NODE PROPERTY TYPE - |REL[ATIONSHIP] PROPERTY TYPE - |PROPERTY TYPE - |NODE KEY - |REL[ATIONSHIP] KEY - |KEY -] CONSTRAINT[S] - [WHERE expression] ----- - -.Syntax for listing constraints with full return columns -[source, syntax] ----- -SHOW [ - ALL - |NODE [PROPERTY] UNIQUE[NESS] - |REL[ATIONSHIP] [PROPERTY] UNIQUE[NESS] - |[PROPERTY] UNIQUE[NESS] - |NODE [PROPERTY] EXIST[ENCE] - |REL[ATIONSHIP] [PROPERTY] EXIST[ENCE] - |[PROPERTY] EXIST[ENCE] - |NODE PROPERTY TYPE - |REL[ATIONSHIP] PROPERTY TYPE - |PROPERTY TYPE - |NODE KEY - |REL[ATIONSHIP] KEY - |KEY -] CONSTRAINT[S] -YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n] - [WHERE expression] - [RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]] ----- - -The type filtering keywords filters the returned constraints on constraint type: - -[[constraints-syntax-list-type-filter]] -.Type filters -[options="header", width="100%", cols="4m,6a"] -|=== -| Filter | Description - -|ALL -| Returns all constraints, no filtering on constraint type. -This is the default if none is given. - -|NODE [PROPERTY] UNIQUE[NESS] -| Returns the node property uniqueness constraints. - -|REL[ATIONSHIP] [PROPERTY] UNIQUE[NESS] -| Returns the relationship property uniqueness constraints. - -|[PROPERTY] UNIQUE[NESS] -| Returns all property uniqueness constraints, for both nodes and relationships. - -|NODE [PROPERTY] EXIST[ENCE] -| Returns the node property existence constraints. - -|REL[ATIONSHIP] [PROPERTY] EXIST[ENCE] -| Returns the relationship property existence constraints. - -|[PROPERTY] EXIST[ENCE] -| Returns all property existence constraints, for both nodes and relationships. - -|NODE PROPERTY TYPE -| Returns the node property type constraints. - -|REL[ATIONSHIP] PROPERTY TYPE -| Returns the relationship property type constraints. - -|PROPERTY TYPE -| Returns all property type constraints, for both nodes and relationships. - -|NODE KEY -| Returns the node key constraints. - -|REL[ATIONSHIP] KEY -| Returns the relationship key constraints. - -|KEY -| Returns all node and relationship key constraints. - -|=== - -For examples on how to list constraints, see xref:constraints/managing-constraints.adoc#list-constraints[Create, show, and drop constraints -> SHOW CONSTRAINTS]. -For full details of the result columns for the `SHOW CONSTRAINTS` command, see xref:constraints/managing-constraints.adoc#list-constraints-result-columns[Create, show, and drop constraints -> Result columns for listing constraints]. - -[[drop-constraint]] -== DROP CONSTRAINT - -Constraints are dropped using the `DROP` CONSTRAINT command. -Dropping a constraint is done by specifying the name of the constraint. - -[NOTE] -Dropping a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT` privilege]. - - -.Syntax for dropping a constraint by name -[source, syntax] ----- -DROP CONSTRAINT constraint_name [IF EXISTS] ----- - -This command is optionally idempotent. -This means its default behavior is to throw an error if an attempt is made to drop the same constraint twice. -With the `IF EXISTS` flag, no error is thrown and nothing happens should the constraint not exist. -Instead, an informational notification is returned detailing that the constraint does not exist. - -For examples on how to drop constraints, see xref:constraints/managing-constraints.adoc#drop-constraint[Create, show, and drop constraints -> DROP CONSTRAINT]. diff --git a/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc b/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc index 7e2276a36..6980dd0b8 100644 --- a/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc +++ b/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc @@ -22,6 +22,136 @@ Cypher 25 was introduced in Neo4j 2025.06 and can only be used on Neo4j 2025.06+ Features removed in Cypher 25 are still available on Neo4j 2025.06+ databases either by prepending a query with `CYPHER 5` or by having Cypher 5 as the default language for the database. For more information, see xref:queries/select-version.adoc[]. +[[cypher-deprecations-additions-removals-2025.xx]] +== Neo4j 2025.xx + +=== Updated in Cypher 25 + +[cols="2", options="header"] +|=== +| Feature +| Details + +a| +label:functionality[] +label:updated[] +[source, cypher, role="noheader"] +---- +SHOW CONSTRAINTS YIELD name, enforcedLabel, classification +---- + +a| +Introduced two new columns returned by `SHOW CONSTRAINTS`: + +* `enforcedLabel`: shows the implied labels belonging to a node element type, and the source and target node labels belonging to a relationship element type. +* `classification`: shows the status of a constraint in a graph type. + +For more information, see xref:schema/constraints/list-constraints.adoc#list-constraints-result-columns[Constraints -> Result columns for listing constraints] and xref:schema/graph-types/list-graph-types.adoc#graph-type-elements-in-show-constraints[Graph types -> Graph type elements in `SHOW CONSTRAINTS`]. + +a| +label:functionality[] +label:updated[] +[source, syntax, role="noheader"] +---- +SHOW [NODE] EXIST[ENCE] CONSTRAINTS +---- + +| The `NODE EXIST[ENCE]` and `EXIST[ENCE]` type filtering options allowed by the `SHOW CONSTRAINTS` command now also return node label existence constraints (created as part of node element types in a xref:schema/graph-types/index.adoc[graph type]). +For more information, see xref:schema/syntax.adoc#constraints-syntax-list-type-filter[Syntax -> Type filters]. + +a| +label:functionality[] +label:updated[] +[source, syntax, role="noheader"] +---- +SHOW CONSTRAINTS +---- + +a| The `type` column returned by xref:schema/constraints/list-constraints.adoc[`SHOW CONSTRAINTS`] can now return three additional constraint types: `NODE_LABEL_EXISTENCE`, `RELATIONSHIP_SOURCE_LABEL` and `RELATIONSHIP_TARGET_LABEL`. +These new constraint types are created as part of node and relationship element types when setting a graph type. +For more information, see xref:schema/graph-types/set-graph-types.adoc[]. + +|=== + +=== New in Cypher 25 + +[cols="2", options="header"] +|=== +| Feature +| Details + +a| +label:functionality[] +label:new[] +[source, cypher, role="noheader"] +---- +ALTER CURRENT GRAPH TYPE SET { + (:Person => :Resident {name :: STRING NOT NULL}), + (:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) +} +---- + +| Introduced the ability to set a xref:schema/graph-types/index.adoc[graph type] for a database using the `ALTER CURRENT GRAPH TYPE SET` command. +A graph type enforces holistically an open schema, providing a defined structure for an entire graph, and includes constraint types (node label existence, relationship source node, and relationship target node constraints) not possible to create using the older `CREATE CONSTRAINT` syntax. +For more information, see xref:schema/graph-types/set-graph-types.adoc[]. + +a| +label:functionality[] +label:new[] +[source, cypher, role="noheader"] +---- +ALTER CURRENT GRAPH TYPE ADD { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER, nationality :: STRING}) + REQUIRE (p.name, p.ssn) IS KEY, + CONSTRAINT pet_address FOR (pet:Pet) REQUIRE pet.address IS NOT NULL, + (:Animal => {type :: STRING NOT NULL}) +} +---- + +| Introduced the ability to extend graph types using the `ALTER CURRENT GRAPH TYPE ADD` command. +For more information, see xref:schema/graph-types/extend-graph-types.adoc[]. + +a| +label:functionality[] +label:new[] +[source, cypher, role="noheader"] +---- +ALTER CURRENT GRAPH TYPE ALTER { + (:Robot => :Resident&Machine {application :: STRING NOT NULL, id :: INTEGER NOT NULL}), + (:Resident)-[:LIVES_IN => {since :: ANY NOT NULL}]->(:City) +} +---- + +| Introduced the ability to alter element types in a graph type using the `ALTER CURRENT GRAPH TYPE ALTER` command. +For more information, see xref:schema/graph-types/alter-element-types.adoc[]. + +a| +label:functionality[] +label:new[] +[source, cypher, role="noheader"] +---- +SHOW CURRENT GRAPH TYPE +---- + +| Introduced the ability to show graph types using the `SHOW CURRENT GRAPH TYPE` command. +For more information, see xref:schema/graph-types/list-graph-types.adoc[]. + +a| +label:functionality[] +label:new[] +[source, cypher, role="noheader"] +---- +ALTER CURRENT GRAPH DROP { + (:Pet =>), + CONSTRAINT pet_address +} +---- + +| Introduced the ability to drop element types and constraints from graph types using the `ALTER CURRENT GRAPH TYPE DROP` command. +For more information, see xref:schema/graph-types/drop-graph-type-elements.adoc[]. +|=== [[cypher-deprecations-additions-removals-2025.10]] == Neo4j 2025.10 @@ -101,7 +231,7 @@ FOR ()-[r:CONTAINS]->() REQUIRE r.embedding IS :: VECTOR(1536) ---- a| Introduced `VECTOR` property type constraints. -For more information, see xref:constraints/managing-constraints.adoc#create-property-type-constraints[Create property type constraints]. +For more information, see xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[Create property type constraints]. |=== @@ -520,7 +650,7 @@ SHOW RELATIONSHIP PROPERTY UNIQUENESS CONSTRAINTS SHOW PROPERTY UNIQUENESS CONSTRAINTS ---- a| -The constraint type keyword filtering for xref:constraints/syntax.adoc#list-constraints[`SHOW CONSTRAINTS`] now allows the optional keyword `PROPERTY` when filtering on property uniqueness constraints. +The constraint type keyword filtering for xref:schema/syntax.adoc#list-constraints[`SHOW CONSTRAINTS`] now allows the optional keyword `PROPERTY` when filtering on property uniqueness constraints. The constraint type column returned is also updated to return `NODE_PROPERTY_UNIQUENESS` and `RELATIONSHIP_PROPERTY_UNIQUENESS`. a| @@ -2410,7 +2540,7 @@ CREATE CONSTRAINT name FOR ()-[r:TYPE]-() REQUIRE r.prop IS :: ---- a| -Extended xref::constraints/managing-constraints.adoc#create-property-type-constraint-union-type[node and relationship property type constraints]. +Extended xref::schema/constraints/create-constraints.adoc#create-property-type-constraint-union-type[node and relationship property type constraints]. Closed dynamic union types (`type1 \| type2 \| ...`) are now supported, allowing for types such as: * `INTEGER \| FLOAT` @@ -2492,7 +2622,7 @@ CREATE CONSTRAINT name FOR ()-[r:TYPE]-() REQUIRE r.prop IS :: ---- a| -Extended xref::constraints/managing-constraints.adoc#type-constraints-allowed-properties[node and relationship property type constraints]. +Extended xref::schema/constraints/create-constraints.adoc#type-constraints-allowed-properties[node and relationship property type constraints]. The new supported types are: * `LIST` @@ -2650,7 +2780,7 @@ CREATE CONSTRAINT name FOR ()-[r:TYPE]-() REQUIRE r.prop IS :: ---- a| -Added xref::constraints/managing-constraints.adoc#create-property-type-constraints[node and relationship property type constraints]. +Added xref::schema/constraints/create-constraints.adoc#create-property-type-constraints[node and relationship property type constraints]. The available property types are: * `BOOLEAN` @@ -2800,7 +2930,7 @@ CREATE CONSTRAINT name FOR ()-[r:TYPE]-() REQUIRE r.prop IS RELATIONSHIP KEY ---- a| -Added relationship xref:constraints/managing-constraints.adoc#create-key-constraints[key] and xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness] constraints. +Added relationship xref:schema/constraints/create-constraints.adoc#create-key-constraints[key] and xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness] constraints. a| label:functionality[] diff --git a/modules/ROOT/pages/indexes/search-performance-indexes/managing-indexes.adoc b/modules/ROOT/pages/indexes/search-performance-indexes/managing-indexes.adoc index a70f9a43a..faf9df946 100644 --- a/modules/ROOT/pages/indexes/search-performance-indexes/managing-indexes.adoc +++ b/modules/ROOT/pages/indexes/search-performance-indexes/managing-indexes.adoc @@ -235,7 +235,7 @@ However, other predicates are only used when it is known that the property is co * `n.prop = "string"` * `n.prop IN ["a", "b", "c"]` -This means that a text index is not able to solve, for example, e.g. `a.prop = b.prop`, unless a xref:constraints/managing-constraints.adoc#create-property-type-constraints[property type constraint] also exists on the property. +This means that a text index is not able to solve, for example, e.g. `a.prop = b.prop`, unless a xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[property type constraint] also exists on the property. Text indexes support the following predicates: @@ -1095,7 +1095,7 @@ Unable to drop index: Index belongs to constraint: `uniqueBookIsbn` ---- Dropping the index-backed constraint will also remove the backing index. -For more information, see xref:constraints/managing-constraints.adoc#drop-constraint[Drop a constraint by name]. +For more information, see xref:schema/constraints/drop-constraints.adoc[Drop a constraint by name]. [discrete] [[drop-a-non-existing-index]] diff --git a/modules/ROOT/pages/indexes/search-performance-indexes/using-indexes.adoc b/modules/ROOT/pages/indexes/search-performance-indexes/using-indexes.adoc index 14ca99722..586b9067f 100644 --- a/modules/ROOT/pages/indexes/search-performance-indexes/using-indexes.adoc +++ b/modules/ROOT/pages/indexes/search-performance-indexes/using-indexes.adoc @@ -893,7 +893,7 @@ The xref:functions/string.adoc#functions-tostring[`toString`] function can also For indexes that are compatible only with specific types (i.e. text and point indexes), the Cypher planner needs to deduce that a predicate will evaluate to `null` for non-compatible values in order to use the index. If a predicate is not explicitly defined as the required type (`STRING` or `POINT`), this can lead to situations where a text or point index is not used. -Since xref:constraints/managing-constraints.adoc#create-property-type-constraints[property type constraints] guarantee that a property is always of the same type, they can be used to extend the scenarios in which text and point indexes are compatible with a predicate. +Since xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[property type constraints] guarantee that a property is always of the same type, they can be used to extend the scenarios in which text and point indexes are compatible with a predicate. To show this, the following example will first drop the existing range index on the `name` property (this is necessary because property type constraints only extend the compatibility of type-specific indexes - range indexes are not limited by a value type). It will then run the same query with a `WHERE` predicate on the `name` property (for which there exists a previously created text index) before and after creating a property type constraint, and compare the resulting execution plans. @@ -972,7 +972,7 @@ Because of the property type constraint on the `name` property, the planner is n Point indexes can be extended in the same way if a property type constraint is created to ensure that all properties are `POINT` values. -Note that xref:constraints/managing-constraints.adoc#create-property-existence-constraints[property existence constraints] do not currently leverage index use in the same way. +Note that xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[property existence constraints] do not currently leverage index use in the same way. [[Heuristics]] == Heuristics: deciding what to index diff --git a/modules/ROOT/pages/introduction/cypher-neo4j.adoc b/modules/ROOT/pages/introduction/cypher-neo4j.adoc index 2edbedf60..9e2fcf760 100644 --- a/modules/ROOT/pages/introduction/cypher-neo4j.adoc +++ b/modules/ROOT/pages/introduction/cypher-neo4j.adoc @@ -29,15 +29,16 @@ a| link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/manage-users[Multi-user management]. All users have full access rights. -| Constraints +| Schema a| -All constraints: -xref::constraints/managing-constraints.adoc#create-property-existence-constraints[node and relationship property existence constraints], -xref::constraints/managing-constraints.adoc#create-property-type-constraints[node and relationship property type constraints], -xref::constraints/managing-constraints.adoc#create-property-uniqueness-constraints[node and relationship property uniqueness constraints], -xref::constraints/managing-constraints.adoc#create-key-constraints[node and relationship key constraints]. +xref:schema/graph-types/index.adoc[] and the following individual constraints: + +* xref::schema/constraints/create-constraints.adoc#create-property-existence-constraints[node and relationship property existence constraints] +* xref::schema/constraints/create-constraints.adoc#create-property-type-constraints[node and relationship property type constraints] +* xref::schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[node and relationship property uniqueness constraints] +* xref::schema/constraints/create-constraints.adoc#create-key-constraints[node and relationship key constraints] a| -Only xref::constraints/managing-constraints.adoc#create-property-uniqueness-constraints[node and relationship property uniqueness constraints]. +Only xref::schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[node and relationship property uniqueness constraints]. | Store xref:values-and-types/vector.adoc[`VECTOR`] values as properties. | `VECTOR` values can be stored as properties if the database runs on link:{neo4j-docs-base-uri}/operations-manual/current/database-internals/store-formats/#store-format-overview[block format]. diff --git a/modules/ROOT/pages/introduction/cypher-overview.adoc b/modules/ROOT/pages/introduction/cypher-overview.adoc index b4363f067..abb001318 100644 --- a/modules/ROOT/pages/introduction/cypher-overview.adoc +++ b/modules/ROOT/pages/introduction/cypher-overview.adoc @@ -35,8 +35,8 @@ However, there are some important differences between the two: *Cypher is schema-flexible*:: -While it is both possible and advised to enforce partial schemas using xref:constraints/index.adoc[indexes and constraints], Cypher and Neo4j offers a greater degree of schema-flexibility than SQL and a relational database. -More specifically, nodes and relationships in a Neo4j database do not have to have a specific property set to them because other nodes or relationships in the same graph have that property (unless there is an xref:constraints/managing-constraints.adoc#create-property-existence-constraints[property existence constraint] created on that specific property). +While it is both possible and advised to enforce an xref:schema/index.adoc[open schema] with Neo4j using xref:schema/graph-types/index.adoc[graph types]/xref:schema/constraints/index.adoc[constraints] and xref:indexes/search-performance-indexes/index.adoc[indexes], Cypher and Neo4j offers a greater degree of schema-flexibility than SQL and a relational database. +More specifically, nodes and relationships in a Neo4j database do not have to have a specific property set to them because other nodes or relationships in the same graph have that property (unless there is an xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[property existence constraint] created on that specific property). This means that users are not required to use a fixed schema to represent data and that they can add new attributes and relationships as their graphs evolve. *Query order*:: diff --git a/modules/ROOT/pages/patterns/shortest-paths.adoc b/modules/ROOT/pages/patterns/shortest-paths.adoc index 9bab3cfd5..8a6eecf0d 100644 --- a/modules/ROOT/pages/patterns/shortest-paths.adoc +++ b/modules/ROOT/pages/patterns/shortest-paths.adoc @@ -670,7 +670,7 @@ ready to start consuming query after 4 ms, results consumed after another 106 ms [[single-source-target-pair-index]] === Enforcing a single source-target node pair with indexes and constraints -Another way to inform the planner of the uniqueness of the target node in a shortest path is to create an xref:indexes/search-performance-indexes/index.adoc[index] or xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness]/xref:constraints/managing-constraints.adoc#create-key-constraints[key constraint] (both of which are xref:constraints/managing-constraints.adoc#constraints-and-backing-indexes[index-backed]) on a property belonging to the matched nodes in the shortest path. +Another way to inform the planner of the uniqueness of the target node in a shortest path is to create an xref:indexes/search-performance-indexes/index.adoc[index] or xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness]/xref:schema/constraints/create-constraints.adoc#create-key-constraints[key constraint] (both of which are xref:schema/constraints/create-constraints.adoc#constraints-and-backing-indexes[index-backed]) on a property belonging to the matched nodes in the shortest path. This will accurately inform the planner of node cardinality and thereby enable more efficient query planning (assuming the graph contains uniquely identifying node properties). .Impact of indexes and constraints diff --git a/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc b/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc index b7593db64..8eb6a228a 100644 --- a/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc +++ b/modules/ROOT/pages/planning-and-tuning/operators/operators-detail.adoc @@ -798,7 +798,7 @@ Total database accesses: 3, total allocated memory: 312 The `NodeIndexSeek` operator finds nodes using an index seek. The node variable and the index used are shown in the arguments of the operator. -If the index is backs up a xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraint], the operator is instead called xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-node-unique-index-seek[NodeUniqueIndexSeek]. +If the index is backs up a xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraint], the operator is instead called xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-node-unique-index-seek[NodeUniqueIndexSeek]. .NodeIndexSeek @@ -890,7 +890,7 @@ CREATE CONSTRAINT team_name IF NOT EXISTS FOR (t:Team) REQUIRE (t.name) IS UNIQU ---- //// -The `NodeUniqueIndexSeek` operator finds nodes using an index seek within an index backing up a xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraint]. +The `NodeUniqueIndexSeek` operator finds nodes using an index seek within an index backing up a xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraint]. The node variable and the index used are shown in the arguments of the operator. If the index does not back up a property uniqueness constraint, the operator is instead called xref::planning-and-tuning/operators/operators-detail.adoc#query-plan-node-index-seek[NodeIndexSeek]. If the index seek is used to solve a xref::clauses/merge.adoc[MERGE] clause, it will also be marked with `(Locking)`. @@ -1001,7 +1001,7 @@ CREATE CONSTRAINT team_id IF NOT EXISTS FOR (t:Team) REQUIRE (t.id) IS UNIQUE ---- //// -The `AssertingMultiNodeIndexSeek` operator is used to ensure that no xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraints] are violated. +The `AssertingMultiNodeIndexSeek` operator is used to ensure that no xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness constraints] are violated. The example looks for the presence of a team with the supplied name and id, and if one does not exist, it will be created. Owing to the existence of two property uniqueness constraints on `:Team(name)` and `:Team(id)`, any node that would be found by the `UniqueIndexSeek` operator must be the very same node or the constraints would be violated. diff --git a/modules/ROOT/pages/queries/basic.adoc b/modules/ROOT/pages/queries/basic.adoc index 4660569f5..a592dd09d 100644 --- a/modules/ROOT/pages/queries/basic.adoc +++ b/modules/ROOT/pages/queries/basic.adoc @@ -902,5 +902,5 @@ DETACH DELETE n ---- [NOTE] -`DETACH DELETE` is not suitable for deleting large amounts of data, nor does it delete xref:indexes/search-performance-indexes/index.adoc[indexes] and xref:constraints/index.adoc[constraints]. +`DETACH DELETE` is not suitable for deleting large amounts of data, nor does it delete xref:indexes/search-performance-indexes/index.adoc[indexes] or the xref:schema/index.adoc[schema] of a graph. For more information, and alternatives to `DETACH DELETE`, see xref:clauses/delete.adoc#delete-all-nodes-and-relationships[`DELETE` -> Delete all nodes and relationships]. diff --git a/modules/ROOT/pages/constraints/managing-constraints.adoc b/modules/ROOT/pages/schema/constraints/create-constraints.adoc similarity index 57% rename from modules/ROOT/pages/constraints/managing-constraints.adoc rename to modules/ROOT/pages/schema/constraints/create-constraints.adoc index 802cfd831..1f98dbced 100644 --- a/modules/ROOT/pages/constraints/managing-constraints.adoc +++ b/modules/ROOT/pages/schema/constraints/create-constraints.adoc @@ -1,26 +1,11 @@ -:description: Information about creating, listing, and dropping Neo4j's constraints. -include::https://raw.githubusercontent.com/neo4j-graphacademy/courses/main/asciidoc/courses/cypher-indexes-constraints/ad.adoc[] -:page-aliases: constraints/examples.adoc -= Create, show, and drop constraints - -This page describes how to create, list, and drop constraints. -The following constraint types are available in Neo4j: - -* xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraints[Property uniqueness constraints] -* xref:constraints/managing-constraints.adoc#create-property-existence-constraints[Property existence constraints] label:enterprise-edition[] -* xref:constraints/managing-constraints.adoc#create-property-type-constraints[Property type constraints] label:enterprise-edition[] -* xref:constraints/managing-constraints.adoc#create-key-constraints[Key constraints] label:enterprise-edition[] - - -[[create-constraint]] -== CREATE CONSTRAINT +:description: Information about creating Neo4j's constraints. += Create constraints Constraints are created with the `CREATE CONSTRAINT` command. When creating a constraint, it is recommended to provide a constraint name. This name must be unique among both indexes and constraints. If a name is not explicitly given, a unique name will be auto-generated. - [NOTE] Creating a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT` privilege]. @@ -28,7 +13,7 @@ Creating a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/ Adding constraints is an atomic operation that can take a while -- all existing data has to be scanned before a Neo4j DBMS can use a constraint. [[create-property-uniqueness-constraints]] -=== Create property uniqueness constraints +== Create property uniqueness constraints Property uniqueness constraints ensure that the property values are unique for all nodes with a specific label or all relationships with a specific type. For composite property uniqueness constraints on multiple properties, it is the combination of property values that must be unique. @@ -38,12 +23,8 @@ Property uniqueness constraints do not require all nodes or relationships to hav Only nodes or relationships that contain all properties specified in the constraint are subject to the uniqueness rule. Nodes or relationships missing one or more of the specified properties are not subject to this rule. -* xref:constraints/managing-constraints.adoc#create-single-property-uniqueness-constraint[] -* xref:constraints/managing-constraints.adoc#create-composite-property-uniqueness-constraint[] -* xref:constraints/managing-constraints.adoc#create-property-uniqueness-constraint-compliant-data[] - [[create-single-property-uniqueness-constraint]] -==== Create a single property uniqueness constraint +=== Create a single property uniqueness constraint Single property uniqueness constraints are created with the following commands: @@ -51,17 +32,19 @@ Single property uniqueness constraints are created with the following commands: * Relationship property uniqueness constraints: `CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS UNIQUE`. -For the full command syntax to create a property uniqueness constraint, see xref:constraints/syntax.adoc#create-property-uniqueness-constraints[Syntax -> Create property uniqueness constraints]. +For the full command syntax to create a property uniqueness constraint, see xref:schema/syntax.adoc#create-property-uniqueness-constraints[Syntax -> Create property uniqueness constraints]. .Create a node property uniqueness constraint on a single property ====== .Create a constraint requiring `Book` nodes to have unique `isbn` properties +// tag::schema_constraints_property_uniqueness[] [source, cypher] ---- CREATE CONSTRAINT book_isbn FOR (book:Book) REQUIRE book.isbn IS UNIQUE ---- +// end::schema_constraints_property_uniqueness[] .Result [source, queryresult] @@ -92,7 +75,7 @@ Added 1 constraint. ====== [[create-composite-property-uniqueness-constraint]] -==== Create a composite property uniqueness constraint +=== Create a composite property uniqueness constraint Constraints created for multiple properties are called composite constraints. Note that the constrained properties must be parenthesized when creating composite property uniqueness constraints. @@ -100,7 +83,7 @@ Note that the constrained properties must be parenthesized when creating composi * Node property uniqueness constraints: `CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE (n.propertyName_1, ..., n.propertyName_n) IS UNIQUE`. * Relationship property uniqueness constraints: `CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE (r.propertyName_1, ..., r.propertyName_n) IS UNIQUE`. -For the full command syntax to create a property uniqueness constraint, see xref:constraints/syntax.adoc#create-property-uniqueness-constraints[Syntax -> Create property uniqueness constraints]. +For the full command syntax to create a property uniqueness constraint, see xref:schema/syntax.adoc#create-property-uniqueness-constraints[Syntax -> Create property uniqueness constraints]. .Create a composite node property uniqueness constraint on several properties ====== @@ -125,11 +108,13 @@ Added 1 constraint. ====== .Create a constraint requiring `PREQUEL_OF` relationships to have unique combinations of `order` and `author` properties +// tag::schema_constraints_composite_property_uniqueness[] [source, cypher] ---- CREATE CONSTRAINT prequels FOR ()-[prequel:PREQUEL_OF]-() REQUIRE (prequel.order, prequel.author) IS UNIQUE ---- +// end::schema_constraints_composite_property_uniqueness[] .Result [source, queryresult] @@ -140,7 +125,7 @@ Added 1 constraint. ====== [[create-property-uniqueness-constraint-compliant-data]] -==== Create data that complies with existing property uniqueness constraints +=== Create data that complies with existing property uniqueness constraints .Create a node that complies with existing property uniqueness constraints ====== @@ -179,25 +164,21 @@ Added 2 labels, created 2 nodes, set 4 properties, created 1 relationship. [role=label--enterprise-edition] [[create-property-existence-constraints]] -=== Create property existence constraints +== Create property existence constraints Property existence constraints ensure that a property exists either for all nodes with a specific label or for all relationships with a specific type. Queries that try to create new nodes of the specified label, or relationships of the specified type, without the constrained property will fail. The same is true for queries that try to remove the mandatory property. -* xref:constraints/managing-constraints.adoc#create-single-property-existence-constraint[] -* xref:constraints/managing-constraints.adoc#create-property-existence-constraint-compliant-data[] - - [[create-single-property-existence-constraint]] -==== Create a single property existence constraint +=== Create a single property existence constraint Property existence constraints on single properties are created with the following commands: * Node property existence constraint: `CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE n.property IS NOT NULL`. * Relationship property existence constraint: `CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS NOT NULL`. -For the full command syntax to create an existence constraint, see xref:constraints/syntax.adoc#create-property-existence-constraints[Syntax -> Create property existence constraints]. +For the full command syntax to create an existence constraint, see xref:schema/syntax.adoc#create-property-existence-constraints[Syntax -> Create property existence constraints]. [NOTE] It is not possible to create composite existence constraints on several properties. @@ -206,11 +187,13 @@ It is not possible to create composite existence constraints on several properti ====== .Create a constraint requiring `Author` nodes to have a `name` property +// tag::schema_constraints_property_existence[] [source, cypher] ---- CREATE CONSTRAINT author_name FOR (author:Author) REQUIRE author.name IS NOT NULL ---- +// end::schema_constraints_property_existence[] .Result [source, queryresult] @@ -240,7 +223,7 @@ Added 1 constraint. ====== [[create-property-existence-constraint-compliant-data]] -==== Create data that complies with existing property existence constraints +=== Create data that complies with existing property existence constraints .Create a node that complies with existing node property existence constraints ====== @@ -280,7 +263,7 @@ Added 2 labels, created 2 nodes, set 7 properties, created 1 relationship [role=label--enterprise-edition] [[create-property-type-constraints]] -=== Create property type constraints +== Create property type constraints Property type constraints ensure that a property has the required data type for all nodes with a specific label or for all relationships with a specific type. Queries that attempt to add this property with the wrong data type or modify this property in a way that changes its data type for nodes of the specified label or relationships of the specified type will fail. @@ -288,14 +271,8 @@ Queries that attempt to add this property with the wrong data type or modify thi Property type constraints do not require all nodes or relationships to have the property. Nodes or relationships without the constrained property are not subject to this rule. -* xref:constraints/managing-constraints.adoc#create-single-property-type-constraint[] -* xref:constraints/managing-constraints.adoc#create-property-type-constraint-union-type[] -* xref:constraints/managing-constraints.adoc#type-constraints-allowed-properties[] -* xref:constraints/managing-constraints.adoc#fail-to-create-property-type-constraint-invalid-type[] -* xref:constraints/managing-constraints.adoc#create-property-type-constraint-compliant-data[] - [[create-single-property-type-constraint]] -==== Create a single property type constraint +=== Create a single property type constraint Property type constraints are created with the following commands: @@ -303,8 +280,8 @@ Property type constraints are created with the following commands: * Relationship property type constraints: `CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS :: `. `` refers to a specific Cypher data type, such as `STRING` or `INTEGER`. -For the types that properties can be constrained by, see xref:constraints/managing-constraints.adoc#type-constraints-allowed-properties[], and for information about different data types in Cypher, see xref:values-and-types/index.adoc[]. -For the full command syntax to create a property type constraint, see xref:constraints/syntax.adoc#create-property-type-constraints[Syntax -> Create property type constraints]. +For the types that properties can be constrained by, see xref:schema/constraints/create-constraints.adoc#type-constraints-allowed-properties[], and for information about different data types in Cypher, see xref:values-and-types/index.adoc[]. +For the full command syntax to create a property type constraint, see xref:schema/syntax.adoc#create-property-type-constraints[Syntax -> Create property type constraints]. [NOTE] It is not possible to create composite property type constraints on several properties. @@ -330,11 +307,13 @@ Added 1 constraint. ====== .Create a constraint requiring `order` properties on `PART_OF` relationships to be of type `INTEGER` +// tag::schema_constraints_property_type[] [source, cypher] ---- CREATE CONSTRAINT part_of FOR ()-[part:PART_OF]-() REQUIRE part.order IS :: INTEGER ---- +// end::schema_constraints_property_type[] .Result [source, queryresult] @@ -380,7 +359,7 @@ Added 1 constraint. ====== [[create-property-type-constraint-union-type]] -==== Create property type constraints with a union type +=== Create property type constraints with a union type A closed dynamic union allows a node or relationship property to maintain some type flexibility whilst preventing unexpected values from being stored. @@ -388,11 +367,13 @@ A closed dynamic union allows a node or relationship property to maintain some t ====== .Create a constraint requiring `tagline` properties on `Movie` nodes to be either of type `STRING` or `LIST` +// tag::schema_constraints_property_type_dynamic_union[] [source, cypher] ---- CREATE CONSTRAINT movie_tagline FOR (movie:Movie) REQUIRE movie.tagline IS :: STRING | LIST ---- +// end::schema_constraints_property_type_dynamic_union[] .Result [source, queryresult] @@ -421,7 +402,7 @@ Added 1 constraint. ====== [[type-constraints-allowed-properties]] -==== Allowed types +=== Allowed types The allowed property types for property type constraints are: @@ -458,7 +439,7 @@ For more information, see xref:values-and-types/vector.adoc[Values and types -> For a complete reference describing all types available in Cypher, see the section on xref::values-and-types/property-structural-constructed.adoc#types-synonyms[types and their synonyms]. [[fail-to-create-property-type-constraint-invalid-type]] -==== Creating property type constraints on invalid types will fail +=== Creating property type constraints on invalid types will fail .Create a node property type constraint with an invalid type ====== @@ -478,7 +459,7 @@ Failed to create node property type constraint: Invalid property type `MAP`. ====== [[create-property-type-constraint-compliant-data]] -==== Create data that complies with existing property type constraints +=== Create data that complies with existing property type constraints .Create a node that complies with existing node property type constraint ====== @@ -519,7 +500,7 @@ Added 1 label, added 1 node, created 1 relationship, set 2 properties [role=label--enterprise-edition] [[create-key-constraints]] -=== Create key constraints +== Create key constraints Key constraints ensure that the property exist and the property value is unique for all nodes with a specific label or all relationships with a specific type. For composite key constraints on multiple properties, all properties must exists and the combination of property values must be unique. @@ -527,29 +508,27 @@ For composite key constraints on multiple properties, all properties must exists Queries that try to create new nodes of the specified label, or relationships of the specified type, without the constrained property will fail. The same is true for queries that try to remove the mandatory property or add duplicated property values. -* xref:constraints/managing-constraints.adoc#create-single-property-key-constraint[] -* xref:constraints/managing-constraints.adoc#create-composite-key-constraint[] -* xref:constraints/managing-constraints.adoc#create-key-constraint-compliant-data[] - [[create-single-property-key-constraint]] -==== Create a single property key constraint +=== Create a single property key constraint Single property key constraints are created with the following commands: * Node key constraints: `CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE n.property IS NODE KEY`. * Relationship key constraints: `CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS RELATIONSHIP KEY`. -For the full command syntax to create a key constraint, see xref:constraints/syntax.adoc#create-key-constraints[Syntax -> Create key constraints]. +For the full command syntax to create a key constraint, see xref:schema/syntax.adoc#create-key-constraints[Syntax -> Create key constraints]. .Create a node key constraint on a single property ====== .Create a constraint requiring `Director` nodes to have a unique `imdbId` property as a node key. +// tag::schema_constraints_key[] [source, cypher] ---- CREATE CONSTRAINT director_imdbId FOR (director:Director) REQUIRE (director.imdbId) IS NODE KEY ---- +// end::schema_constraints_key[] .Result [source, queryresult] @@ -579,7 +558,7 @@ Added 1 constraint. ====== [[create-composite-key-constraint]] -==== Create a composite key constraint +=== Create a composite key constraint Constraints created for multiple properties are called composite constraints. Note that the constrained properties must be parenthesized when creating composite key constraints. @@ -589,7 +568,7 @@ Composite key constraints are created with the following commands: * Node key constraints: `CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE (n.propertyName_1, ..., n.propertyName_n) IS NODE KEY`. * Relationship key constraints: `CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE (r.propertyName_1, ..., r.propertyName_n) IS RELATIONSHIP KEY`. -For the full command syntax to create a key constraint, see xref:constraints/syntax.adoc#create-key-constraints[Syntax -> Create key constraints]. +For the full command syntax to create a key constraint, see xref:schema/syntax.adoc#create-key-constraints[Syntax -> Create key constraints]. .Create a composite node key constraint on multiple properties ====== @@ -613,11 +592,13 @@ Added 1 constraint. ====== .Create a constraint requiring `KNOWS` relationships to have a unique combination of `since` and `how` properties as a relationship key +// tag::schema_constraints_composite_key[] [source, cypher] ---- CREATE CONSTRAINT knows_since_how FOR ()-[knows:KNOWS]-() REQUIRE (knows.since, knows.how) IS RELATIONSHIP KEY ---- +// end::schema_constraints_composite_key[] .Result [source, queryresult] @@ -628,7 +609,7 @@ Added 1 constraint. ====== [[create-key-constraint-compliant-data]] -==== Create data that complies with existing key constraints +=== Create data that complies with existing key constraints .Create a node that complies with existing node key constraints ====== @@ -667,7 +648,7 @@ Added 2 labels, created 2 nodes, set 7 properties, created 1 relationship. [[create-constraint-with-parameter]] -=== Create a constraint with a parameter +== Create a constraint with a parameter All constraint types can be created with a parameterized name. @@ -683,11 +664,13 @@ All constraint types can be created with a parameterized name. ---- .Create a node property uniqueness constraint with a parameterized name +// tag::schema_constraints_parameter[] [source, cypher] ---- CREATE CONSTRAINT $name FOR (book:Book) REQUIRE book.prop1 IS UNIQUE ---- +// end::schema_constraints_parameter[] .Result [source, queryresult] @@ -724,7 +707,7 @@ Added 1 constraint. ====== [[handling-multiple-constraints]] -=== Handling multiple constraints +== Handling multiple constraints Creating an already existing constraint will fail. This includes the following scenarios: @@ -745,11 +728,8 @@ However, some constraint types are allowed on the same label/relationship type a For example, it is possible to have a property uniqueness and a property existence constraint on the same label/relationship type and property combination, though this would be the equivalent of having a node or relationship key constraint. A more useful example would be to combine a property type and a property existence constraint to ensure that the property exists and has the given type. -* xref:constraints/managing-constraints.adoc#create-a-constraint-if-not-exist[] -* xref:constraints/managing-constraints.adoc#create-an-already-existing-constraint[] - [[create-a-constraint-if-not-exist]] -==== Handling existing constraints when creating a constraint +=== Handling existing constraints when creating a constraint To avoid failing on existing constraints, `IF NOT EXISTS` can be added to the `CREATE` command. This will ensure that no error is thrown and that no constraint is created if any other constraint with the given name, or another constraint on the same constraint type and schema, or both, already exists. @@ -838,7 +818,7 @@ Because a node property existence constraint named `author_name` already exists, ====== [[create-an-already-existing-constraint]] -==== Creating an already existing constraint will fail +=== Creating an already existing constraint will fail Creating a constraint with the same name or on the same node label or relationship type and properties that are already constrained by a constraint of the same type will fail. Property uniqueness and key constraints are also not allowed on the same schema. @@ -934,13 +914,10 @@ Constraint already exists: Constraint( id=7, name='book_title_year', type='NODE ====== [[constraints-and-indexes]] -=== Constraints and indexes - -* xref:constraints/managing-constraints.adoc#constraints-and-backing-indexes[] -* xref:constraints/managing-constraints.adoc#constraint-failures-and-indexes[] +== Constraints and indexes [[constraints-and-backing-indexes]] -==== Constraints and backing indexes +=== Constraints and backing indexes Property uniqueness constraints and key constraints are backed by xref:indexes/search-performance-indexes/managing-indexes.adoc#create-range-index[range indexes]. This means that creating a property uniqueness or key constraint will create a range index with the same name, node label/relationship type and property combination as its owning constraint. @@ -957,7 +934,7 @@ The index makes these checks much faster by enabling direct lookups instead of s Cypher will use the indexes with an owning constraint in the same way that it utilizes other search-performance indexes. For more information about how indexes impact query performance, see xref:indexes/search-performance-indexes/using-indexes.adoc[]. -These indexes are listed in the `owningConstraint` column returned by the xref:indexes/search-performance-indexes/managing-indexes.adoc#list-indexes[`SHOW INDEX`] command, and the `ownedIndex` column returned by the xref:constraints/managing-constraints.adoc#list-constraints[`SHOW CONSTRAINT`] command. +These indexes are listed in the `owningConstraint` column returned by the xref:indexes/search-performance-indexes/managing-indexes.adoc#list-indexes[`SHOW INDEX`] command, and the `ownedIndex` column returned by the xref:schema/constraints/list-constraints.adoc[`SHOW CONSTRAINT`] command. .List constraints with backing indexes ====== @@ -1021,7 +998,7 @@ SHOW INDEXES WHERE owningConstraint IS NOT NULL Property existence and property type constraints are not backed by indexes. [[constraint-failures-and-indexes]] -==== Constraint failures and indexes +=== Constraint failures and indexes Attempting to create any type of constraint with the same name as an existing index will fail. @@ -1076,15 +1053,10 @@ A constraint cannot be created until the index has been dropped. [[constraints-and-data-violation-scenarios]] -=== Constraints and data violation scenarios - -* xref:constraints/managing-constraints.adoc#create-data-that-violates-a-constraint[] -* xref:constraints/managing-constraints.adoc#removing-an-existing-constrained-property-will-fail[] -* xref:constraints/managing-constraints.adoc#modifying-property-constrained-property-will-fail[] -* xref:constraints/managing-constraints.adoc#fail-to-create-constraint-due-to-existing-data[] +== Constraints and data violation scenarios [[create-data-that-violates-a-constraint]] -==== Creating data that violates existing constraints will fail +=== Creating data that violates existing constraints will fail .Existing constraints preventing data creation [cols="4", options="header"] @@ -1189,7 +1161,7 @@ Node(0) with label `Actor` must have the properties (`firstname`, `surname`) ====== [[removing-an-existing-constrained-property-will-fail]] -==== Removing existence and key constrained properties will fail +=== Removing existence and key constrained properties will fail .Remove a node property existence constrained property ====== @@ -1229,7 +1201,7 @@ Node(0) with label `Actor` must have the properties (`firstname`, `surname`) ====== [[modifying-property-constrained-property-will-fail]] -==== Modifying type constrained properties will fail +=== Modifying type constrained properties will fail .Modify a type constrained property ====== @@ -1251,7 +1223,7 @@ Node(9) with label `Movie` required the property `title` to be of type `STRING`, [[fail-to-create-constraint-due-to-existing-data]] -==== Creating constraints when there exists conflicting data will fail +=== Creating constraints when there exists conflicting data will fail .Existing data preventing constraint creation [cols="4", options="header"] @@ -1448,348 +1420,3 @@ RETURN r AS relationship, 'non-existing' AS reason ---- |=== - -[[list-constraints]] -== SHOW CONSTRAINTS - -To list all constraints with the default output columns, use `SHOW CONSTRAINTS`. -If all columns are required, use `SHOW CONSTRAINTS YIELD *`. -For the full command syntax to list constraints, see xref:constraints/syntax.adoc#list-constraints[Syntax -> SHOW CONSTRAINTS]. - -One of the output columns from `SHOW CONSTRAINTS` is the name of the constraint. -This can be used to drop the constraint with the xref::constraints/managing-constraints.adoc#drop-constraint[`DROP CONSTRAINT` command]. - -[NOTE] -Listing constraints requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. - -.List all constraints with default output columns -====== - -.Query -[source, cypher, test-exclude-cols=id] ----- -SHOW CONSTRAINTS ----- - -.Result -[source, queryresult] ----- -+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| id | name | type | entityType | labelsOrTypes | properties | ownedIndex | propertyType | -+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| 23 | "actor_fullname" | "NODE_KEY" | "NODE" | ["Actor"] | ["firstname", "surname"] | "actor_fullname" | NULL | -| 12 | "author_name" | "NODE_PROPERTY_EXISTENCE" | "NODE" | ["Author"] | ["name"] | NULL | NULL | -| 5 | "book_isbn" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["isbn"] | "book_isbn" | NULL | -| 9 | "book_title_year" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["title", "publicationYear"] | "book_title_year" | NULL | -| 19 | "director_imdbId" | "NODE_KEY" | "NODE" | ["Director"] | ["imdbId"] | "director_imdbId" | NULL | -| 25 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | "knows_since_how" | NULL | -| 16 | "movie_tagline" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["tagline"] | NULL | "STRING | LIST" | -| 14 | "movie_title" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["title"] | NULL | "STRING" | -| 27 | "node_uniqueness_param" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["prop1"] | "node_uniqueness_param" | NULL | -| 2 | "node_vector_constraint" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["embedding"] | NULL | "VECTOR(42)" | -| 21 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | "ownershipId" | NULL | -| 15 | "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["order"] | NULL | "INTEGER" | -| 17 | "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["tags"] | NULL | "STRING | LIST" | -| 11 | "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"] | "prequels" | NULL | -| 28 | "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["published"] | NULL | NULL | -| 3 | "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["CONTAINS"] | ["embedding"] | NULL | "VECTOR(1536)" | -| 7 | "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"] | ["order"] | "sequels" | NULL | -| 13 | "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["year"] | NULL | NULL | -+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ----- - -====== - -.List all constraints with full details -====== - -To return the full details of the constraints on a database, use `SHOW CONSTRAINTS YIELD *` - -.List all constraints with `YIELD *` -[source, cypher, test-exclude-cols=id] ----- -SHOW CONSTRAINTS YIELD * ----- - -.Result -[source, queryresult] ----- -+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| id | name | type | entityType | labelsOrTypes | properties | ownedIndex | propertyType | options | createStatement | -+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| 23 | "actor_fullname" | "NODE_KEY" | "NODE" | ["Actor"] | ["firstname", "surname"] | "actor_fullname" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `actor_fullname` FOR (n:`Actor`) REQUIRE (n.`firstname`, n.`surname`) IS KEY" | -| 12 | "author_name" | "NODE_PROPERTY_EXISTENCE" | "NODE" | ["Author"] | ["name"] | NULL | NULL | NULL | "CREATE CONSTRAINT `author_name` FOR (n:`Author`) REQUIRE (n.`name`) IS NOT NULL" | -| 5 | "book_isbn" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["isbn"] | "book_isbn" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `book_isbn` FOR (n:`Book`) REQUIRE (n.`isbn`) IS UNIQUE" | -| 9 | "book_title_year" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["title", "publicationYear"] | "book_title_year" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `book_title_year` FOR (n:`Book`) REQUIRE (n.`title`, n.`publicationYear`) IS UNIQUE" | -| 19 | "director_imdbId" | "NODE_KEY" | "NODE" | ["Director"] | ["imdbId"] | "director_imdbId" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `director_imdbId` FOR (n:`Director`) REQUIRE (n.`imdbId`) IS KEY" | -| 25 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | "knows_since_how" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `knows_since_how` FOR ()-[r:`KNOWS`]-() REQUIRE (r.`since`, r.`how`) IS KEY" | -| 16 | "movie_tagline" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["tagline"] | NULL | "STRING | LIST" | NULL | "CREATE CONSTRAINT `movie_tagline` FOR (n:`Movie`) REQUIRE (n.`tagline`) IS :: STRING | LIST" | -| 14 | "movie_title" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["title"] | NULL | "STRING" | NULL | "CREATE CONSTRAINT `movie_title` FOR (n:`Movie`) REQUIRE (n.`title`) IS :: STRING" | -| 27 | "node_uniqueness_param" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["prop1"] | "node_uniqueness_param" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `node_uniqueness_param` FOR (n:`Book`) REQUIRE (n.`prop1`) IS UNIQUE" | -| 2 | "node_vector_constraint" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["embedding"] | NULL | "VECTOR(42)" | NULL | "CREATE CONSTRAINT `node_vector_constraint` FOR (n:`Movie`) REQUIRE (n.`embedding`) IS :: VECTOR(42)" | -| 21 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | "ownershipId" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `ownershipId` FOR ()-[r:`OWNS`]-() REQUIRE (r.`ownershipId`) IS KEY" | -| 15 | "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["order"] | NULL | "INTEGER" | NULL | "CREATE CONSTRAINT `part_of` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`order`) IS :: INTEGER" | -| 17 | "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["tags"] | NULL | "STRING | LIST" | NULL | "CREATE CONSTRAINT `part_of_tags` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`tags`) IS :: STRING | LIST" | -| 11 | "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"] | "prequels" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `prequels` FOR ()-[r:`PREQUEL_OF`]-() REQUIRE (r.`order`, r.`author`) IS UNIQUE" | -| 28 | "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["published"] | NULL | NULL | NULL | "CREATE CONSTRAINT `rel_exist_param` FOR ()-[r:`WROTE`]-() REQUIRE (r.`published`) IS NOT NULL" | -| 3 | "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["CONTAINS"] | ["embedding"] | NULL | "VECTOR(1536)" | NULL | "CREATE CONSTRAINT `rel_vector_constraint` FOR ()-[r:`CONTAINS`]-() REQUIRE (r.`embedding`) IS :: VECTOR(1536)" | -| 7 | "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"] | ["order"] | "sequels" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `sequels` FOR ()-[r:`SEQUEL_OF`]-() REQUIRE (r.`order`) IS UNIQUE" | -| 13 | "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["year"] | NULL | NULL | NULL | "CREATE CONSTRAINT `wrote_year` FOR ()-[r:`WROTE`]-() REQUIRE (r.`year`) IS NOT NULL" | -+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ----- -====== - -[[list-constraints-with-filtering]] -=== Listing constraints with filtering - -The `SHOW CONSTRAINTS` command can be filtered in various ways. -The filtering of rows can be done using constraint type keywords or a `WHERE` clause, while filtering of columns is achieved by specifying the desired columns in a `YIELD` clause. - -.List only specific constraint types -====== - -.List only key constraints -[source, cypher, test-exclude-cols=id] ----- -SHOW KEY CONSTRAINTS ----- - -.Result -[source, queryresult] ----- -+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| id | name | type | entityType | labelsOrTypes | properties | ownedIndex | propertyType | -+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| 21 | "actor_fullname" | "NODE_KEY" | "NODE" | ["Actor"] | ["firstname", "surname"] | "actor_fullname" | NULL | -| 17 | "director_imdbId" | "NODE_KEY" | "NODE" | ["Director"] | ["imdbId"] | "director_imdbId" | NULL | -| 23 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | "knows_since_how" | NULL | -| 19 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | "ownershipId" | NULL | -+--------------------------------------------------------------------------------------------------------------------------------------------------------------+ ----- - -For a full list of all the constraint types (and synonyms) available in this command see xref:constraints/syntax.adoc#list-constraints[Syntax -> SHOW CONSTRAINTS]. - -====== - - -.Filtering constraints using the `WHERE` clause -====== - -.List only constraints with a `RELATIONSHIP` `entityType` -[source, cypher, test-exclude-cols=id] ----- -SHOW CONSTRAINTS -WHERE entityType = 'RELATIONSHIP' ----- - -.Result -[source, queryresult] ----- -+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| id | name | type | entityType | labelsOrTypes | properties | ownedIndex | propertyType | -+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| 25 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | "knows_since_how" | NULL | -| 21 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | "ownershipId" | NULL | -| 15 | "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["order"] | NULL | "INTEGER" | -| 17 | "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["tags"] | NULL | "STRING | LIST" | -| 11 | "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"] | "prequels" | NULL | -| 28 | "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["published"] | NULL | NULL | -| 3 | "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["CONTAINS"] | ["embedding"] | NULL | "VECTOR(1536)" | -| 7 | "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"] | ["order"] | "sequels" | NULL | -| 13 | "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["year"] | NULL | NULL | -+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ----- - -====== - - -.Returning specific columns for all constraints -====== - -It is possible to return only specific columns of the available constraints using the `YIELD` clause: - -.List only the `name`, `type`, and `createStatement` columns -[source, cypher, test-exclude-cols=id] ----- -SHOW CONSTRAINTS -YIELD name, type, createStatement ----- - -.Result -[source, queryresult] ----- -+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| name | type | createStatement | -+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| "actor_fullname" | "NODE_KEY" | "CREATE CONSTRAINT `actor_fullname` FOR (n:`Actor`) REQUIRE (n.`firstname`, n.`surname`) IS KEY" | -| "author_name" | "NODE_PROPERTY_EXISTENCE" | "CREATE CONSTRAINT `author_name` FOR (n:`Author`) REQUIRE (n.`name`) IS NOT NULL" | -| "book_isbn" | "NODE_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `book_isbn` FOR (n:`Book`) REQUIRE (n.`isbn`) IS UNIQUE" | -| "book_title_year" | "NODE_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `book_title_year` FOR (n:`Book`) REQUIRE (n.`title`, n.`publicationYear`) IS UNIQUE" | -| "director_imdbId" | "NODE_KEY" | "CREATE CONSTRAINT `director_imdbId` FOR (n:`Director`) REQUIRE (n.`imdbId`) IS KEY" | -| "knows_since_how" | "RELATIONSHIP_KEY" | "CREATE CONSTRAINT `knows_since_how` FOR ()-[r:`KNOWS`]-() REQUIRE (r.`since`, r.`how`) IS KEY" | -| "movie_tagline" | "NODE_PROPERTY_TYPE" | "CREATE CONSTRAINT `movie_tagline` FOR (n:`Movie`) REQUIRE (n.`tagline`) IS :: STRING | LIST" | -| "movie_title" | "NODE_PROPERTY_TYPE" | "CREATE CONSTRAINT `movie_title` FOR (n:`Movie`) REQUIRE (n.`title`) IS :: STRING" | -| "node_uniqueness_param" | "NODE_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `node_uniqueness_param` FOR (n:`Book`) REQUIRE (n.`prop1`) IS UNIQUE" | -| "node_vector_constraint" | "NODE_PROPERTY_TYPE" | "CREATE CONSTRAINT `node_vector_constraint` FOR (n:`Movie`) REQUIRE (n.`embedding`) IS :: VECTOR(42)" | -| "ownershipId" | "RELATIONSHIP_KEY" | "CREATE CONSTRAINT `ownershipId` FOR ()-[r:`OWNS`]-() REQUIRE (r.`ownershipId`) IS KEY" | -| "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "CREATE CONSTRAINT `part_of` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`order`) IS :: INTEGER" | -| "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "CREATE CONSTRAINT `part_of_tags` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`tags`) IS :: STRING | LIST" | -| "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `prequels` FOR ()-[r:`PREQUEL_OF`]-() REQUIRE (r.`order`, r.`author`) IS UNIQUE" | -| "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "CREATE CONSTRAINT `rel_exist_param` FOR ()-[r:`WROTE`]-() REQUIRE (r.`published`) IS NOT NULL" | -| "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "CREATE CONSTRAINT `rel_vector_constraint` FOR ()-[r:`CONTAINS`]-() REQUIRE (r.`embedding`) IS :: VECTOR(1536)" | -| "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `sequels` FOR ()-[r:`SEQUEL_OF`]-() REQUIRE (r.`order`) IS UNIQUE" | -| "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "CREATE CONSTRAINT `wrote_year` FOR ()-[r:`WROTE`]-() REQUIRE (r.`year`) IS NOT NULL" | -+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ ----- - -====== - - -[[list-constraints-result-columns]] -=== Result columns for listing constraints - -.Listing constraints output -[options="header", width="100%", cols="4m,6a,2m"] -|=== -| Column | Description | Type - -| id -| The id of the constraint. label:default-output[] -| INTEGER - -| name -| Name of the constraint (explicitly set by the user or automatically assigned). label:default-output[] -| STRING - -| type -| The ConstraintType of this constraint (`NODE_PROPERTY_UNIQUENESS`, `RELATIONSHIP_PROPERTY_UNIQUENESS`, `NODE_PROPERTY_EXISTENCE`, `RELATIONSHIP_PROPERTY_EXISTENCE`, `NODE_PROPERTY_TYPE`, `RELATIONSHIP_PROPERTY_TYPE`, `NODE_KEY`, or `RELATIONSHIP_KEY`). label:default-output[] - -| STRING - -| entityType -| Type of entities this constraint represents (`NODE` or `RELATIONSHIP`). label:default-output[] -| STRING - -| labelsOrTypes -| The labels or relationship types of this constraint. -The list returned will only include a single value (the name of the constrained node label or relationship type). label:default-output[] -| LIST - -| properties -| The properties of this constraint. label:default-output[] -| LIST - -| ownedIndex -| The name of the index associated with the constraint or `null`, in case no index is associated with it. label:default-output[] -| STRING - -| propertyType -| The property type the property is restricted to for property type constraints, or `null` for the other constraints. -label:default-output[] -| STRING - -| options -| The options passed to `CREATE` command, for the index associated to the constraint, or `null` if no index is associated with the constraint. -| MAP - -| createStatement -| Statement used to create the constraint, or `null` if the constraint cannot be created through `CREATE CONSTRAINT` (for example in case of version incompatibilities). -| STRING - -|=== - -[[drop-constraint]] -== DROP CONSTRAINT - -Constraints are dropped using the `DROP CONSTRAINT` command. -It is possible to drop constraints created in a different Cypher version than the one in use. -For example, although `VECTOR` property type constraints were added in Cypher 25, such constraints can still be dropped using Cypher 5. - -For the full command syntax to drop constraints, see xref:constraints/syntax.adoc#drop-constraint[Syntax -> DROP CONSTRAINT]. - -[NOTE] -Dropping a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT` privilege]. - -[[drop-constraint-by-name]] -=== Drop a constraint by name - -A constraint can be dropped using the name with the `DROP CONSTRAINT constraint_name` command. -It is the same command for all constraint types. -The name of the constraint can be found using the xref:constraints/managing-constraints.adoc#list-constraints[`SHOW CONSTRAINTS` command], given in the output column `name`. - -.Drop a constraint by name -====== - -.Drop the constraint `book_isbn` -[source, cypher] ----- -DROP CONSTRAINT book_isbn ----- - -.Result -[source, queryresult] ----- -Removed 1 constraint. ----- - -====== - -[[drop-constraint-with-parameter]] -=== Drop a constraint with a parameter - -Constraints can be dropped with a parameterized name. - -.Drop a constraint using a parameter -====== - -.Parameters -[source, parameters] ----- -{ - "name": "actor_fullname" -} ----- - -.Drop a constraint with a parameterized name -[source, cypher] ----- -DROP CONSTRAINT $name ----- - -.Result -[source, queryresult] ----- -Removed 1 constraint. ----- - -====== - -[[drop-constraint-nonexisting-constraint]] -=== Drop a non-existing constraint - -If it is uncertain if any constraint with a given name exists and you want to drop it if it does but not get an error should it not, use `IF EXISTS`. -This will ensure that no error is thrown. -Instead, an informational notification is returned stating that the constraint does not exist. - -.Drop a non-existing constraint -====== - -.Drop the non-existing constraint `missing_constraint_name` -[source, cypher] ----- -DROP CONSTRAINT missing_constraint_name IF EXISTS ----- - -.Result -[source, queryresult] ----- -(no changes, no records) ----- - -.Notification -[source] ----- -`DROP CONSTRAINT missing_constraint_name IF EXISTS` has no effect. `missing_constraint_name` does not exist. ----- - -====== diff --git a/modules/ROOT/pages/schema/constraints/drop-constraints.adoc b/modules/ROOT/pages/schema/constraints/drop-constraints.adoc new file mode 100644 index 000000000..66782f60e --- /dev/null +++ b/modules/ROOT/pages/schema/constraints/drop-constraints.adoc @@ -0,0 +1,153 @@ +:description: Information about droppping Neo4j's constraints. += Drop constraints + +Constraints are dropped using the `DROP CONSTRAINT` command. +It is possible to drop constraints created in a different Cypher version than the one in use. +For example, although `VECTOR` property type constraints were added in Cypher 25, such constraints can still be dropped using Cypher 5. + +For the full command syntax to drop constraints, see xref:schema/syntax.adoc#drop-constraint[Syntax -> Drop constraints]. +The constraints dropped on this page are created on the page xref:schema/constraints/create-constraints.adoc[]. + +[NOTE] +Dropping a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT` privilege]. + +[[drop-constraint-by-name]] +== Drop a constraint by name + +A constraint can be dropped using the name with the `DROP CONSTRAINT constraint_name` command. +It is the same command for all constraint types. +The name of the constraint can be found using the xref:schema/constraints/list-constraints.adoc[`SHOW CONSTRAINTS` command], given in the output column `name`. + +//// +The below constraints are created on schema/constraints/create-constraints.adoc + +[source, cypher, role=test-setup] +---- +CREATE CONSTRAINT book_isbn +FOR (book:Book) REQUIRE book.isbn IS UNIQUE; +CREATE CONSTRAINT sequels +FOR ()-[sequel:SEQUEL_OF]-() REQUIRE sequel.order IS UNIQUE; +CREATE CONSTRAINT book_title_year +FOR (book:Book) REQUIRE (book.title, book.publicationYear) IS UNIQUE; +CREATE CONSTRAINT prequels +FOR ()-[prequel:PREQUEL_OF]-() REQUIRE (prequel.order, prequel.author) IS UNIQUE; +CREATE CONSTRAINT author_name +FOR (author:Author) REQUIRE author.name IS NOT NULL; +CREATE CONSTRAINT wrote_year +FOR ()-[wrote:WROTE]-() REQUIRE wrote.year IS NOT NULL; +CREATE CONSTRAINT movie_title +FOR (movie:Movie) REQUIRE movie.title IS :: STRING; +CREATE CONSTRAINT part_of +FOR ()-[part:PART_OF]-() REQUIRE part.order IS :: INTEGER; +CREATE CONSTRAINT movie_tagline +FOR (movie:Movie) REQUIRE movie.tagline IS :: STRING | LIST; +CREATE CONSTRAINT part_of_tags +FOR ()-[part:PART_OF]-() REQUIRE part.tags IS :: STRING | LIST; +CREATE CONSTRAINT director_imdbId +FOR (director:Director) REQUIRE (director.imdbId) IS NODE KEY; +CREATE CONSTRAINT ownershipId +FOR ()-[owns:OWNS]-() REQUIRE owns.ownershipId IS RELATIONSHIP KEY; +CREATE CONSTRAINT actor_fullname +FOR (actor:Actor) REQUIRE (actor.firstname, actor.surname) IS NODE KEY; +CREATE CONSTRAINT knows_since_how +FOR ()-[knows:KNOWS]-() REQUIRE (knows.since, knows.how) IS RELATIONSHIP KEY; +CREATE CONSTRAINT node_uniqueness_param +FOR (book:Book) REQUIRE book.prop1 IS UNIQUE; +CREATE CONSTRAINT rel_exist_param +FOR ()-[wrote:WROTE]-() REQUIRE wrote.published IS NOT NULL +---- +//// + +.Drop a constraint by name +====== + +.Drop the constraint `book_isbn` +// tag::schema_constraints_drop[] +[source, cypher] +---- +DROP CONSTRAINT book_isbn +---- +// end::schema_constraints_drop[] + +.Result +[source, queryresult] +---- +Removed 1 constraint. +---- + +====== + +[NOTE] +==== +Constraints that are created as part of xref:schema/graph-types/set-graph-types.adoc#node-element-types[node] or xref:schema/graph-types/set-graph-types.adoc#relationship-element-types[relationship element types] in a xref:schema/graph-types/index.adoc[graph type] cannot be dropped with the `DROP CONSTRAINT constraint_name` command. +This includes the following constraints: + +* Property existence and property type constraints on identifying node labels or relationship types +* Node label existence constraints +* Relationship source and target label constraints + +These constraints can only be dropped by dropping the full node or relationship element type. +For more information, see xref:schema/graph-types/drop-graph-type-elements.adoc#drop-element-types[Drop node and relationship element types]. +==== + +[[drop-constraint-with-parameter]] +== Drop a constraint with a parameter + +Constraints can be dropped with a parameterized name. + +.Drop a constraint using a parameter +====== + +.Parameters +[source, parameters] +---- +{ + "name": "actor_fullname" +} +---- + +.Drop a constraint with a parameterized name +// tag::schema_constraints_drop_parameter[] +[source, cypher] +---- +DROP CONSTRAINT $name +---- +// end::schema_constraints_drop_parameter[] + +.Result +[source, queryresult] +---- +Removed 1 constraint. +---- + +====== + +[[drop-constraint-nonexisting-constraint]] +== Drop a non-existing constraint + +If it is uncertain if any constraint with a given name exists and you want to drop it if it does but not get an error should it not, use `IF EXISTS`. +This will ensure that no error is thrown. +Instead, an informational notification is returned stating that the constraint does not exist. + +.Drop a non-existing constraint +====== + +.Drop the non-existing constraint `missing_constraint_name` +[source, cypher] +---- +DROP CONSTRAINT missing_constraint_name IF EXISTS +---- + +.Result +[source, queryresult] +---- +(no changes, no records) +---- + +.Notification +[source] +---- +`DROP CONSTRAINT missing_constraint_name IF EXISTS` has no effect. `missing_constraint_name` does not exist. +---- + +====== \ No newline at end of file diff --git a/modules/ROOT/pages/schema/constraints/index.adoc b/modules/ROOT/pages/schema/constraints/index.adoc new file mode 100644 index 000000000..c2fc75599 --- /dev/null +++ b/modules/ROOT/pages/schema/constraints/index.adoc @@ -0,0 +1,30 @@ +:description: Information about creating, listing, and dropping Neo4j's constraints. +include::https://raw.githubusercontent.com/neo4j-graphacademy/courses/main/asciidoc/courses/cypher-indexes-constraints/ad.adoc[] +:page-aliases: constraints/examples.adoc, constraints/index.adoc += Constraints + +Neo4j offers several constraints to ensure the quality and integrity of data in a graph. +The following constraints are available in Neo4j: + +* xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[Property uniqueness constraints]: ensure that the combined property values are unique for all nodes with a specific label or all relationships with a specific type. +* xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[Property existence constraints]: ensure that a property exists either for all nodes with a specific label or for all relationships with a specific type. label:enterprise-edition[] +* xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[Property type constraints]: ensure that a property has the required property type for all nodes with a specific label or for all relationships with a specific type. label:enterprise-edition[] +* xref:schema/constraints/create-constraints.adoc#create-key-constraints[Key constraints]: ensure that all properties exist and that the combined property values are unique for all nodes with a specific label or all relationships with a specific type.label:enterprise-edition[] + +For more information about index-backed constraints, constraint creation failures and data violation scenarios, as well as creating, listing and dropping constraints, see: + +* xref:schema/constraints/create-constraints.adoc[] +* xref:schema/constraints/list-constraints.adoc[] +* xref:schema/constraints/drop-constraints.adoc[] + +For reference material about the Cypher commands used to manage constraints, see xref:schema/syntax.adoc#constraints[Syntax -> Constraints]. + +[NOTE] +==== +All constraints created using the older xref:schema/constraints/create-constraints.adoc#create-constraint[`CREATE CONSTRAINT`] syntax will automatically be added to the graph type of a database. +Not all constraint types can be created using this syntax, however, and maintaining individual constraints can become complicated over time as their number increases. + +*It is, therefore, recommended to define a schema using a graph type, which offers both additional, more sophisticated constraint types and a more holistic and simplified approach for constraining and maintaining the shape of the data in a graph.* + +For more information, see xref:schema/graph-types/index.adoc[]. +==== \ No newline at end of file diff --git a/modules/ROOT/pages/schema/constraints/list-constraints.adoc b/modules/ROOT/pages/schema/constraints/list-constraints.adoc new file mode 100644 index 000000000..39461389d --- /dev/null +++ b/modules/ROOT/pages/schema/constraints/list-constraints.adoc @@ -0,0 +1,320 @@ +:description: Information about listing Neo4j's constraints. += Show constraints + +To list all constraints with the default output columns, use `SHOW CONSTRAINTS`. +If all columns are required, use `SHOW CONSTRAINTS YIELD *`. +For the full command syntax to list constraints, see xref:schema/syntax.adoc#list-constraints[Syntax -> Show constraints]. +The constraints listed on this page are created on the page xref:schema/constraints/create-constraints.adoc[]. + +[NOTE] +==== +All constraints created when xref:schema/graph-types/set-graph-types.adoc[setting a graph type] will be returned by the `SHOW CONSTRAINTS` command. +Similarly, all constraints created using the xref:schema/constraints/create-constraints.adoc[`CREATE CONSTRAINT`] syntax will be returned by the `SHOW CURRENT GRAPH TYPE` command. +For more information, see the following sections of the xref:schema/graph-types/list-graph-types[Show graph types] page: + +* xref:schema/graph-types/list-graph-types.adoc#constraints-in-show-current-graph-type[Show graph types -> Constraints in `SHOW CURRENT GRAPH TYPE`] +* xref:schema/graph-types/list-graph-types.adoc#graph-type-elements-in-show-constraints[Show graph types -> Graph type elements in `SHOW CONSTRAINTS`] +==== + +One of the output columns from `SHOW CONSTRAINTS` is the name of the constraint. +This can be used to drop the constraint with the xref::schema/constraints/drop-constraints.adoc[`DROP CONSTRAINT` command]. + +[NOTE] +Listing constraints requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. + +//// +The below constraints are created on schema/constraints/create-constraints.adoc + +[source, cypher, role=test-setup] +---- +CREATE CONSTRAINT book_isbn +FOR (book:Book) REQUIRE book.isbn IS UNIQUE; +CREATE CONSTRAINT sequels +FOR ()-[sequel:SEQUEL_OF]-() REQUIRE sequel.order IS UNIQUE; +CREATE CONSTRAINT book_title_year +FOR (book:Book) REQUIRE (book.title, book.publicationYear) IS UNIQUE; +CREATE CONSTRAINT prequels +FOR ()-[prequel:PREQUEL_OF]-() REQUIRE (prequel.order, prequel.author) IS UNIQUE; +CREATE CONSTRAINT author_name +FOR (author:Author) REQUIRE author.name IS NOT NULL; +CREATE CONSTRAINT wrote_year +FOR ()-[wrote:WROTE]-() REQUIRE wrote.year IS NOT NULL; +CREATE CONSTRAINT movie_title +FOR (movie:Movie) REQUIRE movie.title IS :: STRING; +CREATE CONSTRAINT part_of +FOR ()-[part:PART_OF]-() REQUIRE part.order IS :: INTEGER; +CREATE CONSTRAINT node_vector_constraint +FOR (n:Movie) REQUIRE n.embedding IS :: VECTOR(42); +CREATE CONSTRAINT rel_vector_constraint +FOR ()-[r:CONTAINS]->() REQUIRE r.embedding IS :: VECTOR(1536); +CREATE CONSTRAINT movie_tagline +FOR (movie:Movie) REQUIRE movie.tagline IS :: STRING | LIST; +CREATE CONSTRAINT part_of_tags +FOR ()-[part:PART_OF]-() REQUIRE part.tags IS :: STRING | LIST; +CREATE CONSTRAINT director_imdbId +FOR (director:Director) REQUIRE (director.imdbId) IS NODE KEY; +CREATE CONSTRAINT ownershipId +FOR ()-[owns:OWNS]-() REQUIRE owns.ownershipId IS RELATIONSHIP KEY; +CREATE CONSTRAINT actor_fullname +FOR (actor:Actor) REQUIRE (actor.firstname, actor.surname) IS NODE KEY; +CREATE CONSTRAINT knows_since_how +FOR ()-[knows:KNOWS]-() REQUIRE (knows.since, knows.how) IS RELATIONSHIP KEY; +CREATE CONSTRAINT node_uniqueness_param +FOR (book:Book) REQUIRE book.prop1 IS UNIQUE; +CREATE CONSTRAINT rel_exist_param +FOR ()-[wrote:WROTE]-() REQUIRE wrote.published IS NOT NULL +---- +//// + +.List all constraints with default output columns +====== + +.Query +// tag::schema_constraints_show[] +[source, cypher, test-exclude-cols=id] +---- +SHOW CONSTRAINTS +---- +// end::schema_constraints_show[] + +.Result +[source, queryresult] +---- ++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| id | name | type | entityType | labelsOrTypes | properties | enforcedLabel | ownedIndex | propertyType | ++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| 28 | "actor_fullname" | "NODE_KEY" | "NODE" | ["Actor"] | ["firstname", "surname"] | NULL | "actor_fullname" | NULL | +| 27 | "author_name" | "NODE_PROPERTY_EXISTENCE" | "NODE" | ["Author"] | ["name"] | NULL | NULL | NULL | +| 34 | "book_isbn" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["isbn"] | NULL | "book_isbn" | NULL | +| 23 | "book_title_year" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["title", "publicationYear"] | NULL | "book_title_year" | NULL | +| 36 | "director_imdbId" | "NODE_KEY" | "NODE" | ["Director"] | ["imdbId"] | NULL | "director_imdbId" | NULL | +| 26 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | NULL | "knows_since_how" | NULL | +| 12 | "movie_tagline" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["tagline"] | NULL | NULL | "STRING | LIST" | +| 33 | "movie_title" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["title"] | NULL | NULL | "STRING" | +| 17 | "node_uniqueness_param" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["prop1"] | NULL | "node_uniqueness_param" | NULL | +| 2 | "node_vector_constraint" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["embedding"] | NULL | NULL | "VECTOR(42)" | +| 38 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | NULL | "ownershipId" | NULL | +| 41 | "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["order"] | NULL | NULL | "INTEGER" | +| 39 | "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["tags"] | NULL | NULL | "STRING | LIST" | +| 24 | "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"] | NULL | "prequels" | NULL | +| 30 | "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["published"] | NULL | NULL | NULL | +| 3 | "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["CONTAINS"] | ["embedding"] | NULL | NULL | "VECTOR(1536)" | +| 19 | "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"] | ["order"] | NULL | "sequels" | NULL | +| 14 | "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["year"] | NULL | NULL | NULL | ++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- + +====== + +.List all constraints with full details +====== + +To return the full details of the constraints on a database, use `SHOW CONSTRAINTS YIELD *` + +.List all constraints with `YIELD *` +// tag::schema_constraints_show_full[] +[source, cypher, test-exclude-cols=id] +---- +SHOW CONSTRAINTS YIELD * +---- +// end::schema_constraints_show_full[] + +.Result +[source, queryresult] +---- ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| id | name | type | entityType | labelsOrTypes | properties | enforcedLabel | classification | ownedIndex | propertyType | options | createStatement | ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| 28 | "actor_fullname" | "NODE_KEY" | "NODE" | ["Actor"] | ["firstname", "surname"] | NULL | "undesignated" | "actor_fullname" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `actor_fullname` FOR (n:`Actor`) REQUIRE (n.`firstname`, n.`surname`) IS KEY" | +| 27 | "author_name" | "NODE_PROPERTY_EXISTENCE" | "NODE" | ["Author"] | ["name"] | NULL | "independent" | NULL | NULL | NULL | "CREATE CONSTRAINT `author_name` FOR (n:`Author`) REQUIRE (n.`name`) IS NOT NULL" | +| 34 | "book_isbn" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["isbn"] | NULL | "undesignated" | "book_isbn" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `book_isbn` FOR (n:`Book`) REQUIRE (n.`isbn`) IS UNIQUE" | +| 23 | "book_title_year" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["title", "publicationYear"] | NULL | "undesignated" | "book_title_year" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `book_title_year` FOR (n:`Book`) REQUIRE (n.`title`, n.`publicationYear`) IS UNIQUE" | +| 36 | "director_imdbId" | "NODE_KEY" | "NODE" | ["Director"] | ["imdbId"] | NULL | "undesignated" | "director_imdbId" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `director_imdbId` FOR (n:`Director`) REQUIRE (n.`imdbId`) IS KEY" | +| 26 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | NULL | "undesignated" | "knows_since_how" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `knows_since_how` FOR ()-[r:`KNOWS`]-() REQUIRE (r.`since`, r.`how`) IS KEY" | +| 12 | "movie_tagline" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["tagline"] | NULL | "independent" | NULL | "STRING | LIST" | NULL | "CREATE CONSTRAINT `movie_tagline` FOR (n:`Movie`) REQUIRE (n.`tagline`) IS :: STRING | LIST" | +| 33 | "movie_title" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["title"] | NULL | "independent" | NULL | "STRING" | NULL | "CREATE CONSTRAINT `movie_title` FOR (n:`Movie`) REQUIRE (n.`title`) IS :: STRING" | +| 17 | "node_uniqueness_param" | "NODE_PROPERTY_UNIQUENESS" | "NODE" | ["Book"] | ["prop1"] | NULL | "undesignated" | "node_uniqueness_param" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `node_uniqueness_param` FOR (n:`Book`) REQUIRE (n.`prop1`) IS UNIQUE" | +| 2 | "node_vector_constraint" | "NODE_PROPERTY_TYPE" | "NODE" | ["Movie"] | ["embedding"] | NULL | "independent" | NULL | "VECTOR(42)" | NULL | "CREATE CONSTRAINT `node_vector_constraint` FOR (n:`Movie`) REQUIRE (n.`embedding`) IS :: VECTOR(42)" | +| 38 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | NULL | "undesignated" | "ownershipId" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `ownershipId` FOR ()-[r:`OWNS`]-() REQUIRE (r.`ownershipId`) IS KEY" | +| 41 | "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["order"] | NULL | "independent" | NULL | "INTEGER" | NULL | "CREATE CONSTRAINT `part_of` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`order`) IS :: INTEGER" | +| 39 | "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["tags"] | NULL | "independent" | NULL | "STRING | LIST" | NULL | "CREATE CONSTRAINT `part_of_tags` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`tags`) IS :: STRING | LIST" | +| 24 | "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"] | NULL | "undesignated" | "prequels" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `prequels` FOR ()-[r:`PREQUEL_OF`]-() REQUIRE (r.`order`, r.`author`) IS UNIQUE" | +| 30 | "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["published"] | NULL | "independent" | NULL | NULL | NULL | "CREATE CONSTRAINT `rel_exist_param` FOR ()-[r:`WROTE`]-() REQUIRE (r.`published`) IS NOT NULL" | +| 3 | "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["CONTAINS"] | ["embedding"] | NULL | "independent" | NULL | "VECTOR(1536)" | NULL | "CREATE CONSTRAINT `rel_vector_constraint` FOR ()-[r:`CONTAINS`]-() REQUIRE (r.`embedding`) IS :: VECTOR(1536)" | +| 19 | "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"] | ["order"] | NULL | "undesignated" | "sequels" | NULL | {indexConfig: {}} | "CREATE CONSTRAINT `sequels` FOR ()-[r:`SEQUEL_OF`]-() REQUIRE (r.`order`) IS UNIQUE" | +| 14 | "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["year"] | NULL | "independent" | NULL | NULL | NULL | "CREATE CONSTRAINT `wrote_year` FOR ()-[r:`WROTE`]-() REQUIRE (r.`year`) IS NOT NULL" | ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- +====== + +[[list-constraints-with-filtering]] +== Listing constraints with filtering + +The `SHOW CONSTRAINTS` command can be filtered in various ways. +The filtering of rows can be done using constraint type keywords or a `WHERE` clause, while filtering of columns is achieved by specifying the desired columns in a `YIELD` clause. + +.List only specific constraint types +====== + +.List only key constraints +// tag::schema_constraints_show_type_filter[] +[source, cypher, test-exclude-cols=id] +---- +SHOW KEY CONSTRAINTS +---- +// end::schema_constraints_show_type_filter[] + +.Result +[source, queryresult] +---- ++------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| id | name | type | entityType | labelsOrTypes | properties | enforcedLabel | ownedIndex | propertyType | ++------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| 28 | "actor_fullname" | "NODE_KEY" | "NODE" | ["Actor"] | ["firstname", "surname"] | NULL | "actor_fullname" | NULL | +| 36 | "director_imdbId" | "NODE_KEY" | "NODE" | ["Director"] | ["imdbId"] | NULL | "director_imdbId" | NULL | +| 26 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | NULL | "knows_since_how" | NULL | +| 38 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | NULL | "ownershipId" | NULL | ++------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- + +For a full list of all the constraint types (and synonyms) available in this command see xref:schema/syntax.adoc#list-constraints[Syntax -> SHOW CONSTRAINTS]. + +====== + + +.Filtering constraints using the `WHERE` clause +====== + +.List only constraints with a `RELATIONSHIP` `entityType` +[source, cypher, test-exclude-cols=id] +---- +SHOW CONSTRAINTS +WHERE entityType = 'RELATIONSHIP' +---- + +.Result +[source, queryresult] +---- ++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| id | name | type | entityType | labelsOrTypes | properties | enforcedLabel | ownedIndex | propertyType | ++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| 26 | "knows_since_how" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["KNOWS"] | ["since", "how"] | NULL | "knows_since_how" | NULL | +| 38 | "ownershipId" | "RELATIONSHIP_KEY" | "RELATIONSHIP" | ["OWNS"] | ["ownershipId"] | NULL | "ownershipId" | NULL | +| 41 | "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["order"] | NULL | NULL | "INTEGER" | +| 39 | "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["PART_OF"] | ["tags"] | NULL | NULL | "STRING | LIST" | +| 24 | "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"] | NULL | "prequels" | NULL | +| 30 | "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["published"] | NULL | NULL | NULL | +| 3 | "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "RELATIONSHIP" | ["CONTAINS"] | ["embedding"] | NULL | NULL | "VECTOR(1536)" | +| 19 | "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"] | ["order"] | NULL | "sequels" | NULL | +| 14 | "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"] | ["year"] | NULL | NULL | NULL | ++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- + +====== + + +.Returning specific columns for all constraints +====== + +It is possible to return only specific columns of the available constraints using the `YIELD` clause: + +.List only the `name`, `type`, and `createStatement` columns +// tag::schema_constraints_show_specific_columns[] +[source, cypher, test-exclude-cols=id] +---- +SHOW CONSTRAINTS +YIELD name, type, createStatement +---- +// end::schema_constraints_show_specific_columns[] + +.Result +[source, queryresult] +---- ++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| name | type | createStatement | ++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| "actor_fullname" | "NODE_KEY" | "CREATE CONSTRAINT `actor_fullname` FOR (n:`Actor`) REQUIRE (n.`firstname`, n.`surname`) IS KEY" | +| "author_name" | "NODE_PROPERTY_EXISTENCE" | "CREATE CONSTRAINT `author_name` FOR (n:`Author`) REQUIRE (n.`name`) IS NOT NULL" | +| "book_isbn" | "NODE_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `book_isbn` FOR (n:`Book`) REQUIRE (n.`isbn`) IS UNIQUE" | +| "book_title_year" | "NODE_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `book_title_year` FOR (n:`Book`) REQUIRE (n.`title`, n.`publicationYear`) IS UNIQUE" | +| "director_imdbId" | "NODE_KEY" | "CREATE CONSTRAINT `director_imdbId` FOR (n:`Director`) REQUIRE (n.`imdbId`) IS KEY" | +| "knows_since_how" | "RELATIONSHIP_KEY" | "CREATE CONSTRAINT `knows_since_how` FOR ()-[r:`KNOWS`]-() REQUIRE (r.`since`, r.`how`) IS KEY" | +| "movie_tagline" | "NODE_PROPERTY_TYPE" | "CREATE CONSTRAINT `movie_tagline` FOR (n:`Movie`) REQUIRE (n.`tagline`) IS :: STRING | LIST" | +| "movie_title" | "NODE_PROPERTY_TYPE" | "CREATE CONSTRAINT `movie_title` FOR (n:`Movie`) REQUIRE (n.`title`) IS :: STRING" | +| "node_uniqueness_param" | "NODE_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `node_uniqueness_param` FOR (n:`Book`) REQUIRE (n.`prop1`) IS UNIQUE" | +| "node_vector_constraint" | "NODE_PROPERTY_TYPE" | "CREATE CONSTRAINT `node_vector_constraint` FOR (n:`Movie`) REQUIRE (n.`embedding`) IS :: VECTOR(42)" | +| "ownershipId" | "RELATIONSHIP_KEY" | "CREATE CONSTRAINT `ownershipId` FOR ()-[r:`OWNS`]-() REQUIRE (r.`ownershipId`) IS KEY" | +| "part_of" | "RELATIONSHIP_PROPERTY_TYPE" | "CREATE CONSTRAINT `part_of` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`order`) IS :: INTEGER" | +| "part_of_tags" | "RELATIONSHIP_PROPERTY_TYPE" | "CREATE CONSTRAINT `part_of_tags` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`tags`) IS :: STRING | LIST" | +| "prequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `prequels` FOR ()-[r:`PREQUEL_OF`]-() REQUIRE (r.`order`, r.`author`) IS UNIQUE" | +| "rel_exist_param" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "CREATE CONSTRAINT `rel_exist_param` FOR ()-[r:`WROTE`]-() REQUIRE (r.`published`) IS NOT NULL" | +| "rel_vector_constraint" | "RELATIONSHIP_PROPERTY_TYPE" | "CREATE CONSTRAINT `rel_vector_constraint` FOR ()-[r:`CONTAINS`]-() REQUIRE (r.`embedding`) IS :: VECTOR(1536)" | +| "sequels" | "RELATIONSHIP_PROPERTY_UNIQUENESS" | "CREATE CONSTRAINT `sequels` FOR ()-[r:`SEQUEL_OF`]-() REQUIRE (r.`order`) IS UNIQUE" | +| "wrote_year" | "RELATIONSHIP_PROPERTY_EXISTENCE" | "CREATE CONSTRAINT `wrote_year` FOR ()-[r:`WROTE`]-() REQUIRE (r.`year`) IS NOT NULL" | ++---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- + +====== + + +[[list-constraints-result-columns]] +== Result columns for listing constraints + +.Listing constraints output +[options="header", width="100%", cols="4m,6a,2m"] +|=== +| Column | Description | Type + +| id +| The id of the constraint. label:default-output[] +| INTEGER + +| name +| Name of the constraint (explicitly set by the user or automatically assigned). label:default-output[] +| STRING + +| type +| The ConstraintType of this constraint (`NODE_PROPERTY_UNIQUENESS`, `RELATIONSHIP_PROPERTY_UNIQUENESS`, `NODE_PROPERTY_EXISTENCE`, `RELATIONSHIP_PROPERTY_EXISTENCE`, `NODE_PROPERTY_TYPE`, `RELATIONSHIP_PROPERTY_TYPE`, `NODE_LABEL_EXISTENCE`, `RELATIONSHIP_SOURCE_LABEL`, `RELATIONSHIP_TARGET_LABEL`, `NODE_KEY`, or `RELATIONSHIP_KEY`). label:default-output[] + +| STRING + +| entityType +| Type of entities this constraint represents (`NODE` or `RELATIONSHIP`). label:default-output[] +| STRING + +| labelsOrTypes +| The labels or relationship types of this constraint. +The list returned will only include a single value (the name of the constrained node label or relationship type). label:default-output[] +| LIST + +| properties +| The properties of this constraint, or `null` for node label existence, relationship source label, and relationship target constraints which do not constrain properties. label:default-output[] +| LIST + +| enforcedLabel +| The implied labels required by a node label existence constraint or the source node and target node labels required by a relationship source or target label constraint, or `null` for other constraints which do not constrain labels. label:default-output[] label:cypher[Cypher 25 only] label:new[Introduced in Neo4j 2025.xx] +| STRING + +| ownedIndex +| The name of the index associated with the constraint or `null`, in case no index is associated with it. label:default-output[] +| STRING + +| propertyType +| The property type the property is restricted to for property type constraints, or `null` for the other constraints. +label:default-output[] +| STRING + +| classification +| The status of a constraint in a graph type (`dependent`, `undesignated`, or `independent`). label:cypher[Cypher 25 only] label:new[Introduced in Neo4j 2025.xx] +| STRING + +| options +| The options passed to `CREATE` command, for the index associated to the constraint, or `null` if no index is associated with the constraint. +| MAP + +| createStatement +| Statement used to create the constraint, or `null` if the constraint cannot be created through `CREATE CONSTRAINT` (for example in case of version incompatibilities or if for constraints with `dependent` classification). +| STRING + +|=== + diff --git a/modules/ROOT/pages/schema/graph-types/alter-element-types.adoc b/modules/ROOT/pages/schema/graph-types/alter-element-types.adoc new file mode 100644 index 000000000..f3b24035f --- /dev/null +++ b/modules/ROOT/pages/schema/graph-types/alter-element-types.adoc @@ -0,0 +1,150 @@ +:description: Information about altering element types in a graph type. +:page-role: cypher-25-only new-neo4j-2025.xx enterprise-edition += Alter element types + +The xref:schema/graph-types/set-graph-types.adoc#node-element-types[node] and xref:schema/graph-types/set-graph-types.adoc#relationship-element-types[relationship element types] in a graph type can be altered using the `ALTER CURRENT GRAPH TYPE ALTER` command. +When altering a graph type, only those node or relationship element types to be modified should be included. + +[NOTE] +==== +Altering element types in a graph type requires the following privileges: + +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-tokens[`NAME MANAGEMENT`] (if graph type includes node labels, relationship types, or properties not already in the graph) +==== + +.Set graph type +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:Robot => :Resident {application :: STRING NOT NULL}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), + (:Company => {name :: STRING, address :: STRING IS UNIQUE}), + (:Person)-[:WORKS_FOR => {role :: STRING}]->(:Company), + CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, + CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, + CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address :: STRING +} +---- + +[NOTE] +For details about the different elements a graph type can contain, see xref:schema/graph-types/set-graph-types.adoc[]. + +.Alter node and relationship element types in a graph type +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE ALTER { + (:Robot => :Resident&Machine {application :: STRING NOT NULL, id :: INTEGER NOT NULL}), // <1> + (:Resident)-[:LIVES_IN => {since :: ANY NOT NULL}]->(:City) // <2> +} +---- + +//// +Cheat sheet example (necessary to exclude <1> tag in the cheat sheet): + +// tag::schema_graph_types_alter[] +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE ALTER { + (:Robot => :Resident&Machine {application :: STRING NOT NULL, id :: INTEGER NOT NULL}), + (:Resident)-[:LIVES_IN => {since :: ANY NOT NULL}]->(:City) +} +---- +// end::schema_graph_types_alter[] + +//// + +<1> Nodes with a `Robot` label must now also have a `Machine` label. +`Robot` nodes are also required to have an `id` property of type `INTEGER`. +<2> `since` properties on `LIVES_IN` relationships can now be of `ANY` type (they were previously constrained to be of type `DATE`). + +.Updated data model, showing altered node element type and relationship element type in graph type +image::graph-types-alter-graph-type.svg[Updated data model showing altered node element type and relationship element type in graph type, width=700, role=popup] + +This alteration is implemented by the _creation_ of the following constraints: + +[cols="3*", options="header"] +|=== +| Identifying node label +| Constraint type +| Details + +| `(:Robot)` +| Node property type +| `id :: INTEGER` + +| `(:Robot)` +| Node property existence +| `id IS NOT NULL` + +| `(:Robot)` +| Node label existence +| Nodes with a `Robot` label must also have a `Machine` label. +|=== + +It is also implemented by the _removal_ of the following constraint: + +[cols="3*", options="header"] +|=== +| Identifying relationship type +| Constraint type +| Details + +| `()-[:LIVES_IN]\->()` +| Relationship property type +| `since :: DATE` +|=== + +So long as the identifying node labels or relationship types are the same as those defined in the current graph type, `ALTER CURRENT GRAPH TYPE ALTER` will alter the element types into whatever is included in the alteration. +*In other words, partially defining an element type will not leave the parts of the element type that are not included in the alteration unchanged.* +*Instead, it will redefine the element type based on the reduced definition specified.* +*Note, this does not apply to key and property uniqueness constraints defined on nodes with an identifying label or relationships with an identifying type; these cannot be modified by `ALTER` and will therefore remain unchanged.* + +For more information about how graph types are implemented, see xref:schema/graph-types/set-graph-types.adoc#graph-type-implementation[Set a graph type -> Graph type implementation: translation to constraints]. + +[[rules]] +== Rules + +The behavior of key and property uniqueness constraints on identifying node labels and relationship types, as well as constraints on non-identifying node labels and relationship types with regard to the `ALTER CURRENT GRAPH TYPE ALTER` command follows that of xref:schema/constraints/index.adoc[Neo4j constraints]; they can be created and dropped, but they cannot be altered through a single command (they must, in that case, be dropped and recreated to fit the desired alteration). + +It is not allowed to add key and property uniqueness constraints to node or relationship element types when altering a graph type. +Nor can they be converted into another one through alteration. + +.Not allowed -- alter a node or relationship element type to include a key constraint +[source, cypher, role=test-fail] +---- +ALTER CURRENT GRAPH TYPE ALTER { + (:City => {name :: STRING NOT NULL, population :: INTEGER IS KEY}) // <1> +} +---- + +<1> This alteration is invalid because it modifies the `City` node element type to include a node key constraint. + +.Not allowed -- alter a node or relationship element type by converting a key constraint to a property uniqueness constraint +[source, cypher, role=test-fail] +---- +ALTER CURRENT GRAPH TYPE ALTER { +(p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS UNIQUE // <1> +} +---- + +<1> This alteration is not allowed because it attempts to modify the `Person` node element type by converting a node key constraint into a property uniqueness constraint. + +Constraints cannot be altered using the `ALTER CURRENT GRAPH TYPE ALTER` command. + +.Not allowed -- alter a constraint on a non-identifying relationship type in a graph type +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE ALTER { + CONSTRAINT altered_animal_id FOR (a:Animal) REQUIRE a.id IS KEY // <1> +} +---- + +<1> This alteration is not allowed because it tries to convert a property uniqueness constraint to a key constraint on a non-identifying node label. +Also, the names of constraints cannot be altered. diff --git a/modules/ROOT/pages/schema/graph-types/drop-graph-type-elements.adoc b/modules/ROOT/pages/schema/graph-types/drop-graph-type-elements.adoc new file mode 100644 index 000000000..dd793854f --- /dev/null +++ b/modules/ROOT/pages/schema/graph-types/drop-graph-type-elements.adoc @@ -0,0 +1,164 @@ +:description: Information about dropping elements in a graph type. +:page-role: cypher-25-only new-neo4j-2025.xx enterprise-edition += Drop graph type elements + +The `ALTER CURRENT GRAPH TYPE DROP` command allows you to drop element types and constraints from a graph type. + +[NOTE] +Dropping element types and constraints from a graph type requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT` privilege]. + +.Set graph type +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:Robot => :Resident&Machine {application :: STRING NOT NULL, id :: INTEGER NOT NULL}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: ANY NOT NULL}]->(:City), + (:Company => {name :: STRING, address :: STRING IS UNIQUE}), + (:Person)-[:WORKS_FOR => {role :: STRING}]->(:Company), + CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, + CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, + CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address :: STRING +} +---- + +[[drop-element-types]] +== Drop node and relationship element types + +To fully drop a xref:schema/graph-types/set-graph-types.adoc#node-element-types[node] or xref:schema/graph-types/set-graph-types.adoc#relationship-element-types[relationship element type], it is only necessary to define its identifying node label/relationship type appended with `\=>`. + +.Drop node and relationship element types +// tag::schema_graph_types_drop_elements[] +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE DROP { + (:Pet => ), + ()-[:LIVES_IN => ]->() +} +---- +// end::schema_graph_types_drop_elements[] + +You can also define the full element type when dropping an element type. +Partial definitions, however, are not allowed. + +[cols="3*", options="header"] +|=== +| Allowed -- identifying node label/relationship type only +| Allowed -- full definition +| Not allowed -- partial definition + +a| +[source] +---- +ALTER CURRENT GRAPH TYPE DROP { + (:Pet => ) +} +---- + +a| +[source] +---- +ALTER CURRENT GRAPH TYPE DROP { + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}) +} +---- + +a| +[source] +---- +ALTER CURRENT GRAPH TYPE DROP { + (:Pet => :Resident&Animal) +} +---- + +|=== + +Dropping a node or relationship element type in this way can remove the following constraints: + +* Node label existence constraints +* Source and target node label constraints +* Property type and property existence constraints defined against a node or relationship element type. + +These constraints cannot be removed separately from the node or relationship element type they support. + +.Not allowed -- drop a dependent constraint from a node or relationship element type +[source, cypher, role=test-fail] +---- +ALTER CURRENT GRAPH TYPE DROP { + CONSTRAINT constraint_22a8753a // <1> +} +---- + +<1> `constraint_22a8753a` is a property existence constraint defined on the `City` node element type (constraint names are returned by the xref:schema/graph-types/list-graph-types.adoc#graph-type-elements-in-show-constraints[`SHOW CONSTRAINTS`] command). + +*Removing a node or relationship element type does not, however, remove any property uniqueness or key constraints defined against a node or relationship element type.* +*Rather, it leaves them as constraints on non-identifying node-labels and relationship types.* +*These must therefore be removed separately, using their constraint name.* +For more information, see xref:schema/graph-types/drop-graph-type-elements.adoc#drop-constraints-on-identifying-and-non-identifying-labels-and-types[Drop constraints on identifying and non-identifying node labels and relationship types] below. + +If the identifying label of a node element type is also constrained as a source/target node label in a relationship element type, then the node element type cannot be dropped without also dropping or first altering the relationship element type. + +.Not allowed -- drop a node element type whose identifying label is also the source/target node label in a relationship element type +[source, cypher, role=test-fail] +---- +ALTER CURRENT GRAPH TYPE DROP { + (:Person => ) +} +---- + +.Error message +[source, error] +---- +22NCE: data exception - node element type in use. The node element type identified by the label `Person` is referenced in the graph type element '()-[:`WORKS_FOR` =>]->()' and cannot be dropped. +---- + +[[drop-constraints-on-identifying-and-non-identifying-labels-and-types]] +== Drop constraints on identifying and non-identifying node labels and relationship types + +Key and property uniqueness constraints can only be dropped by using the `CONSTRAINT name` syntax in the `ALTER CURRENT GRAPH TYPE DROP` command, regardless if they were defined on an identifying or non-identifying label. +Property existence and property type constraints defined on non-identifying node labels and relationship types are also dropped in this way. +The names of constraints are returned by the xref:schema/constraints/list-constraints.adoc[`SHOW CONSTRAINTS`] command or as part of their definitions in xref:schema/graph-types/list-graph-types.adoc[`SHOW CURRENT GRAPH TYPE`]. + +.Drop explicitly named and generated name key and property uniqueness constraint +// tag::schema_graph_types_drop_constraints[] +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE DROP { + CONSTRAINT animal_id, + CONSTRAINT constraint_302a3693 +} +---- +// end::schema_graph_types_drop_constraints[] + +These constraints can also be dropped from the graph type using the xref:schema/constraints/drop-constraints.adoc[`DROP CONSTRAINT`] command. + +.Drop property type constraint on a non-identifying node label +[source, cypher] +---- +DROP CONSTRAINT resident_address +---- + +[[drop-full-graph-type]] +== Drop a full graph type + +To drop a full graph type, use the `ALTER CURRENT GRAPH TYPE SET` command. +This will replace the existing graph type with a new (possibly empty) graph type. + +.Drop full graph type and replace it with an empty graph type +// tag::schema_graph_types_drop_full[] +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { } +---- +// end::schema_graph_types_drop_full[] + +.Drop full graph type and replace with a new graph type +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (n:Label => :LabelTwo {property :: STRING}) +} +---- diff --git a/modules/ROOT/pages/schema/graph-types/extend-graph-types.adoc b/modules/ROOT/pages/schema/graph-types/extend-graph-types.adoc new file mode 100644 index 000000000..5413ed6f4 --- /dev/null +++ b/modules/ROOT/pages/schema/graph-types/extend-graph-types.adoc @@ -0,0 +1,139 @@ +:description: Information about extending a graph type. +:page-role: cypher-25-only new-neo4j-2025.xx enterprise-edition += Extend graph types + +A graph type can be extended with the command `ALTER CURRENT GRAPH TYPE ADD`. +This command cannot alter existing elements in a graph type but adds entirely new elements to an existing graph type. + +[NOTE] +==== +Extending a graph type requires the following privileges: + +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-tokens[`NAME MANAGEMENT`] (if graph type includes node labels, relationship types, or properties not already in the graph) +==== + +.Set graph type +// tag::schema_graph_types_set[] +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:Robot => :Resident {application :: STRING NOT NULL}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), + CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, + CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, + CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address :: STRING +} +---- +// end::schema_graph_types_set[] + +[NOTE] +For details about the different elements a graph type can contain, see xref:schema/graph-types/set-graph-types.adoc[]. + +.Extend a graph type by adding new element types +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE ADD { + (:Company => {name :: STRING, address :: STRING IS UNIQUE}), // <1> + (:Person)-[:WORKS_FOR => {role :: STRING}]->(:Company) +} +---- + +<1> This adds a node element type with an identifying label also used by an existing key constraint in the graph type (`company_name`). +This addition is possible for property uniqueness and key constraints originally not defined on an identifying label, but not for property existence and property type constraints. + +//// +Cheat sheet example (necessary to exclude <1> tag in the cheat sheet): + +// tag::schema_graph_types_add[] +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE ADD { + (:Company => {name :: STRING, address :: STRING IS UNIQUE}), + (:Person)-[:WORKS_FOR => {role :: STRING}]->(:Company) +} +---- +// end::schema_graph_types_add[] + +//// + +The extension adds one node element type and one relationship element type to the graph type. +It is implemented with the following constraints: + +[cols="3*", options="header"] +|=== +| Identifying node label/relationship type +| Constraint type +| Details + +| `(:Company)` +| Node property type +| `name :: STRING` + +| `(:Company)` +| Node property type +| `address :: STRING` + +| `(:Company)` +| Node property uniqueness +| `address IS UNIQUE` + +| `()-[:WORKS_FOR]\->()` +| Relationship property type +| `role :: STRING` + +| `()-[:WORKS_FOR]\->()` +| Relationship source label +| Source node must have the label `Person`. + +| `()-[:WORKS_FOR]\->()` +| Relationship target label +| Target node must have the label `Company`. +|=== + +For more information about how graph types are implemented, see xref:schema/graph-types/set-graph-types.adoc#graph-type-implementation[Set a graph type -> Graph type implementation: translation to constraints]. + +The graph type now includes the added node and relationship element type: + +.Current graph type -- with added node and relationship element types +[source] +---- +(p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, +(:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), +(:Robot => Resident {application :: STRING NOT NULL}), +(:City => {name :: STRING NOT NULL, population :: INTEGER}), +(:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), +CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, +CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, +CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address :: STRING, +(:Company => {name :: STRING, address :: STRING IS UNIQUE}), +(:Person)-[:WORKS_FOR => {role :: STRING}]->(:Company) +---- + +.Updated data model, showing added node element type and relationship element type in graph type +image::graph-types-extend-graph-type.svg[Updated data model showing added node element type and relationship element type, width=700, role=popup] + +.Invalid graph type extensions +[source, cypher, role=test-fail] +---- +ALTER CURRENT GRAPH TYPE ADD { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER, nationality :: STRING}) + REQUIRE (p.name, p.ssn) IS KEY, // <1> + CONSTRAINT pet_address FOR (pet:Pet) REQUIRE pet.address IS NOT NULL, // <2> + (:Animal => {type :: STRING NOT NULL}) // <3> +} +---- + +<1> This attempts to extend the existing `Person` node element type by adding a new property (`nationality`). +This is not valid. +<2> This attempts to add a property type constraint on an identifying label in the existing graph type(`Pet`). +This is not valid. +The reverse (adding a node or relationship element type with an identifying label/type already defined by a property type or property existence constraint) is also not possible. +<3> This attempts to add a node element type with an identifying label already used as an implied label in a node element type in the existing graph type (`Pet`). +This is not valid. +The reverse (adding a node element type with an implied label that is already used as an identifying label in an existing node element type) is also not possible. diff --git a/modules/ROOT/pages/schema/graph-types/index.adoc b/modules/ROOT/pages/schema/graph-types/index.adoc new file mode 100644 index 000000000..34d168142 --- /dev/null +++ b/modules/ROOT/pages/schema/graph-types/index.adoc @@ -0,0 +1,21 @@ +:description: Information about setting an open schema in Neo4j using graph types. +:page-role: cypher-25-only new-neo4j-2025.xx enterprise-edition += Graph types + +Graph types allow you to specify a graph schema for a database. + +When a database is created, it has an empty graph type, meaning it is free from any constraints on what can be stored in a database. +Setting a graph type, typically done following the creation of a database, enables users to impose a schema on the nodes, relationships, and properties included in the graph type, thereby ensuring the integrity and quality of the data in a graph. + +Cypher supports open graph types, meaning that a graph type only constrains the data included by the graph type. +It does not impose any constraints on nodes, relationships, and properties not included by the graph type. + +For more information about working with graph types, see: + +* xref:schema/graph-types/set-graph-types.adoc[] +* xref:schema/graph-types/extend-graph-types.adoc[] +* xref:schema/graph-types/alter-element-types.adoc[] +* xref:schema/graph-types/list-graph-types.adoc[] +* xref:schema/graph-types/drop-graph-type-elements.adoc[] + +For reference material about the Cypher commands used to manage graph types, see xref:schema/syntax.adoc#graph-types[Syntax -> Graph types]. diff --git a/modules/ROOT/pages/schema/graph-types/list-graph-types.adoc b/modules/ROOT/pages/schema/graph-types/list-graph-types.adoc new file mode 100644 index 000000000..28c64108b --- /dev/null +++ b/modules/ROOT/pages/schema/graph-types/list-graph-types.adoc @@ -0,0 +1,212 @@ +:description: Information about showing the graph type of a database. +:page-role: cypher-25-only new-neo4j-2025.xx enterprise-edition += Show graph types + +The `SHOW CURRENT GRAPH TYPE` command allows you to show the graph type specification for the current database. + +[NOTE] +Showing a graph type requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. + +.Set graph type +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:Robot => :Resident&Machine {application :: STRING NOT NULL, id :: INTEGER NOT NULL}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: ANY NOT NULL}]->(:City), + (:Company => {name :: STRING, address :: STRING IS UNIQUE}), + (:Person)-[:WORKS_FOR => {role :: STRING}]->(:Company), + CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, + CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, + CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address :: STRING +} +---- + +.Show the full graph type +// tag::schema_graph_types_show[] +[source, cypher] +---- +SHOW CURRENT GRAPH TYPE +---- +// end::schema_graph_types_show[] + +.Result +[source, "queryresult"] +---- ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| specification | ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| "{ | +| (:`City` => {`name` :: STRING NOT NULL, `population` :: INTEGER}), | +| (:`Company` => {`address` :: STRING, `name` :: STRING}), | +| (:`Person` => :`Resident` {`name` :: STRING, `ssn` :: INTEGER}), | +| (:`Pet` => :`Animal`&`Resident` {`healthCertificate` :: STRING, `insuranceNumber` :: INTEGER, `name` :: STRING}), | +| (:`Robot` => :`Machine`&`Resident` {`application` :: STRING NOT NULL, `id` :: INTEGER NOT NULL}), | +| (:`Resident`)-[:`LIVES_IN` => {`since` :: ANY NOT NULL}]->(:`City` =>), | +| (:`Person` =>)-[:`WORKS_FOR` => {`role` :: STRING}]->(:`Company` =>), | +| CONSTRAINT `constraint_d7524c38` FOR (`n`:`Company` =>) REQUIRE (`n`.`address`) IS UNIQUE, | +| CONSTRAINT `company_name` FOR (`n`:`Company` =>) REQUIRE (`n`.`name`) IS KEY, | +| CONSTRAINT `constraint_bb1018eb` FOR (`n`:`Person` =>) REQUIRE (`n`.`name`, `n`.`ssn`) IS KEY, | +| CONSTRAINT `constraint_302a3693` FOR (`n`:`Pet` =>) REQUIRE (`n`.`healthCertificate`) IS UNIQUE, | +| CONSTRAINT `constraint_aa881a72` FOR (`n`:`Pet` =>) REQUIRE (`n`.`insuranceNumber`) IS KEY, | +| CONSTRAINT `animal_id` FOR (`n`:`Animal`) REQUIRE (`n`.`id`) IS UNIQUE, | +| CONSTRAINT `resident_address` FOR (`n`:`Resident`) REQUIRE (`n`.`address`) IS :: STRING | +| }" | ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- + +[NOTE] +Regardless of which syntax was used to define a property uniqueness or key constraint, they are all shown in the `specification` returned by `SHOW CURRENT GRAPH TYPE` using the `CONSTRAINT … FOR … REQUIRE` syntax. + + +[[result-columns]] +== Result columns for `SHOW CURRENT GRAPH TYPE` + +There are two return columns for `SHOW CURRENT GRAPH TYPE`: `type` and `specification`. +Both are returned by default. + +.Listing graph types output +[cols="3*", options="header"] +|=== +| Column +| Description +| Type + +| `specification` +| The graph type of the current database using the canonical form. +This can be used in an `ALTER CURRENT GRAPH TYPE SET` command to recreate the same graph type. label:default-output[] +| `STRING` +|=== + +[[constraints-in-show-current-graph-type]] +== Constraints in `SHOW CURRENT GRAPH TYPE` + +Constraints created using the xref:schema/constraints/create-constraints.adoc[`CREATE CONSTRAINT`] command (i.e. not added with `ALTER CURRENT GRAPH TYPE SET`, `ADD`, or `ALTER`) are automatically added to the graph type. +They will therefore appear in the `SHOW CURRENT GRAPH TYPE` result. + +.Create a node property uniqueness constraint with `CREATE CONSTRAINT` command +[source, cypher] +---- +CREATE CONSTRAINT car_constraint FOR (c:Car) REQUIRE c.licensePlate IS UNIQUE +---- + +.Show `specification` of the full graph type +[source, cypher] +---- +SHOW CURRENT GRAPH TYPE YIELD specification +---- + +.Result +[source, "queryresult"] +---- ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| specification | ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +| "{ | +| (:`City` => {`name` :: STRING NOT NULL, `population` :: INTEGER}), | +| (:`Company` => {`address` :: STRING, `name` :: STRING}), | +| (:`Person` => :`Resident` {`name` :: STRING, `ssn` :: INTEGER}), | +| (:`Pet` => :`Animal`&`Resident` {`healthCertificate` :: STRING, `insuranceNumber` :: INTEGER, `name` :: STRING}), | +| (:`Robot` => :`Machine`&`Resident` {`application` :: STRING NOT NULL, `id` :: INTEGER NOT NULL}), | +| (:`Resident`)-[:`LIVES_IN` => {`since` :: ANY NOT NULL}]->(:`City` =>), | +| (:`Person` =>)-[:`WORKS_FOR` => {`role` :: STRING}]->(:`Company` =>), | +| CONSTRAINT `constraint_d7524c38` FOR (`n`:`Company` =>) REQUIRE (`n`.`address`) IS UNIQUE, | +| CONSTRAINT `company_name` FOR (`n`:`Company` =>) REQUIRE (`n`.`name`) IS KEY, | +| CONSTRAINT `constraint_bb1018eb` FOR (`n`:`Person` =>) REQUIRE (`n`.`name`, `n`.`ssn`) IS KEY, | +| CONSTRAINT `constraint_302a3693` FOR (`n`:`Pet` =>) REQUIRE (`n`.`healthCertificate`) IS UNIQUE, | +| CONSTRAINT `constraint_aa881a72` FOR (`n`:`Pet` =>) REQUIRE (`n`.`insuranceNumber`) IS KEY, | +| CONSTRAINT `animal_id` FOR (`n`:`Animal`) REQUIRE (`n`.`id`) IS UNIQUE, | +| CONSTRAINT `car_constraint` FOR (`n`:`Car`) REQUIRE (`n`.`licensePlate`) IS UNIQUE, | +| CONSTRAINT `resident_address` FOR (`n`:`Resident`) REQUIRE (`n`.`address`) IS :: STRING | +| }" | ++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ +---- + +[[graph-type-elements-in-show-constraints]] +== Graph type elements in `SHOW CONSTRAINTS` + +Each element in a graph type is implemented with constraints. +Whatever is added in a graph type is accordingly returned by the `SHOW CONSTRAINTS` command. +For full information about this command, including its return columns, see xref:schema/constraints/list-constraints.adoc[]. + +[NOTE] +Showing constraints requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. + +Of particular interest are the `enforcedLabel` and `classification` columns returned by `SHOW CONSTRAINTS`. +`enforcedLabel` returns the implied node labels belonging to a node element type and the source and target node labels belonging to a relationship element type. +The `classification` describes the status of a constraint in a graph type, with three possible return values: + +.Values returned by the `classification` column +[cols="2*", options="header"] +|=== +| `classification` +| Applies to + +| `dependent` +| Property existence and property type constraints defined on an identifying node label/relationship type in a xref:schema/graph-types/set-graph-types.adoc#node-element-types[node] or xref:schema/graph-types/set-graph-types.adoc#relationship-element-types[relationship element type], or the node label existence constraints, relationship target label constraints, or relationship source label constraints belonging to node or relationship element types. + +| `undesignated` +| Key and property uniqueness constraints, regardless of whether defined on an xref:schema/graph-types/set-graph-types.adoc#constraints-on-identifying-labels-and-types[identifying] or xref:schema/graph-types/set-graph-types.adoc#constraints-on-non-identifying-labels-and-types[non-identifying] node label or relationship type. + +| `independent` +| xref:schema/graph-types/set-graph-types.adoc#constraints-on-non-identifying-labels-and-types[Property existence and property type constraints on non-identifying node labels or relationship types]. +|=== + +For more information, see xref:schema/constraints/list-constraints.adoc#list-constraints-result-columns[Result columns for listing constraints]. + +.Show constraints +[source, cypher] +---- +SHOW CONSTRAINTS YIELD name, type, labelsOrTypes, enforcedLabel, classification +ORDER BY labelsOrTypes +---- + +.Results +[source, "queryresult"] +---- ++------------------------------------------------------------------------------------------------------------+ +| name | type | labelsOrTypes | enforcedLabel | classification | ++------------------------------------------------------------------------------------------------------------+ +| "animal_id" | "NODE_PROPERTY_UNIQUENESS" | ["Animal"] | NULL | "undesignated" | +| "car_constraint" | "NODE_PROPERTY_UNIQUENESS" | ["Car"] | NULL | "undesignated" | +| "constraint_22a8753a" | "NODE_PROPERTY_EXISTENCE" | ["City"] | NULL | "dependent" | +| "constraint_83085900" | "NODE_PROPERTY_TYPE" | ["City"] | NULL | "dependent" | +| "constraint_ff70b222" | "NODE_PROPERTY_TYPE" | ["City"] | NULL | "dependent" | +| "company_name" | "NODE_KEY" | ["Company"] | NULL | "undesignated" | +| "constraint_437f8bc9" | "NODE_PROPERTY_TYPE" | ["Company"] | NULL | "dependent" | +| "constraint_56444b08" | "NODE_PROPERTY_TYPE" | ["Company"] | NULL | "dependent" | +| "constraint_d7524c38" | "NODE_PROPERTY_UNIQUENESS" | ["Company"] | NULL | "undesignated" | +| "constraint_2fd51eaf" | "RELATIONSHIP_TARGET_LABEL" | ["LIVES_IN"] | "City" | "dependent" | +| "constraint_9dfe66aa" | "RELATIONSHIP_SOURCE_LABEL" | ["LIVES_IN"] | "Resident" | "dependent" | +| "constraint_f26c0c3d" | "RELATIONSHIP_PROPERTY_EXISTENCE" | ["LIVES_IN"] | NULL | "dependent" | +| "constraint_77504979" | "NODE_PROPERTY_TYPE" | ["Person"] | NULL | "dependent" | +| "constraint_82630a6c" | "NODE_LABEL_EXISTENCE" | ["Person"] | "Resident" | "dependent" | +| "constraint_96f964fb" | "NODE_PROPERTY_TYPE" | ["Person"] | NULL | "dependent" | +| "constraint_bb1018eb" | "NODE_KEY" | ["Person"] | NULL | "undesignated" | +| "constraint_302a3693" | "NODE_PROPERTY_UNIQUENESS" | ["Pet"] | NULL | "undesignated" | +| "constraint_aa881a72" | "NODE_KEY" | ["Pet"] | NULL | "undesignated" | +| "constraint_afe0a8de" | "NODE_LABEL_EXISTENCE" | ["Pet"] | "Resident" | "dependent" | +| "constraint_c2c72e5b" | "NODE_LABEL_EXISTENCE" | ["Pet"] | "Animal" | "dependent" | +| "constraint_c79712fe" | "NODE_PROPERTY_TYPE" | ["Pet"] | NULL | "dependent" | +| "constraint_e6253a9f" | "NODE_PROPERTY_TYPE" | ["Pet"] | NULL | "dependent" | +| "constraint_f44978e8" | "NODE_PROPERTY_TYPE" | ["Pet"] | NULL | "dependent" | +| "resident_address" | "NODE_PROPERTY_TYPE" | ["Resident"] | NULL | "independent" | +| "constraint_12d19793" | "NODE_LABEL_EXISTENCE" | ["Robot"] | "Machine" | "dependent" | +| "constraint_5d3b927" | "NODE_PROPERTY_TYPE" | ["Robot"] | NULL | "dependent" | +| "constraint_6e2d3d78" | "NODE_LABEL_EXISTENCE" | ["Robot"] | "Resident" | "dependent" | +| "constraint_8993edce" | "NODE_PROPERTY_TYPE" | ["Robot"] | NULL | "dependent" | +| "constraint_94c37fdc" | "NODE_PROPERTY_EXISTENCE" | ["Robot"] | NULL | "dependent" | +| "constraint_e5820d7e" | "NODE_PROPERTY_EXISTENCE" | ["Robot"] | NULL | "dependent" | +| "constraint_57239b68" | "RELATIONSHIP_SOURCE_LABEL" | ["WORKS_FOR"] | "Person" | "dependent" | +| "constraint_d7a3733b" | "RELATIONSHIP_TARGET_LABEL" | ["WORKS_FOR"] | "Company" | "dependent" | +| "constraint_df70c64c" | "RELATIONSHIP_PROPERTY_TYPE" | ["WORKS_FOR"] | NULL | "dependent" | ++------------------------------------------------------------------------------------------------------------+ +---- + +[NOTE] +All dependent node label existence, relationship source/target label, property existence, and property types constraints have a generated name. +This is because they cannot be named when defined in their respective node and relationship element types. +The `createStatement` column will also return `null` for these constraints, because they cannot be created through a `CREATE CONSTRAINT` command. diff --git a/modules/ROOT/pages/schema/graph-types/set-graph-types.adoc b/modules/ROOT/pages/schema/graph-types/set-graph-types.adoc new file mode 100644 index 000000000..3e7c7e47b --- /dev/null +++ b/modules/ROOT/pages/schema/graph-types/set-graph-types.adoc @@ -0,0 +1,718 @@ +:description: Information about setting an open schema in Neo4j using graph types. +:page-role: cypher-25-only new-neo4j-2025.xx enterprise-edition += Set graph types + +A graph type defines the schema of a database and is set with the command `ALTER CURRENT GRAPH TYPE SET`. +*Note that any previously defined graph types or xref:schema/constraints/index.adoc[constraints] are overwritten and replaced when a graph type is set.* + +Graph types can include: + +* xref:schema/graph-types/set-graph-types.adoc#node-element-types[Node element types] +* xref:schema/graph-types/set-graph-types.adoc#relationship-element-types[Relationship element types] +* xref:schema/graph-types/set-graph-types.adoc#constraints-on-identifying-labels-and-types[Property uniqueness and key constraints defined on identifying node labels or relationship types] +* xref:schema/graph-types/set-graph-types.adoc#constraints-on-non-identifying-labels-and-types[Property existence, property type, property uniqueness, and key constraints defined on non-identifying node labels or relationship types] + +The three first categories are discussed in the section xref:schema/graph-types/set-graph-types.adoc#set-graph-type-empty-database[Set a graph type on an empty database]. +The last category is discussed in the section xref:schema/graph-types/set-graph-types.adoc#set-graph-type-populated-database[Set a graph type on a populated database]. + +[NOTE] +==== +Setting a graph type requires the following privileges: + +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-tokens[`NAME MANAGEMENT`] (if graph type includes node labels, relationship types, or properties not already in the graph) +==== + +[[select-data-model]] +== Selecting a data model + +Before setting a graph type, it is crucial to develop a data model for the graph, as the graph type serves to enforce a schema derived from that data model. + +Modeling data in Neo4j is essential for representing complex, interconnected relationships using nodes, relationships, and properties. +Unlike traditional databases, its graph structure mirrors real-world connections, making it easier to traverse and query (for more information about data modeling, see the link:{neo4j-docs-base-uri}/getting-started/data-modeling/tutorial-data-modeling/[Getting Started Guide -> Data modeling]). + +The examples on this page have as their starting point a data model that identifies persons, pets, and the cities they reside in. +Key entities and their attributes are defined, including the names of people, pets, and cities. +Persons and pets are both classified as residents, and the data model captures how long both have lived in a particular city. + +image::graph-types-data-model.svg[Data model showing persons and pets and the city they live in, width=700,role=popup] + +[[set-graph-type-empty-database]] +== Set a graph type on an empty database + +All databases are created with an empty graph type. +Since setting a graph type can be a more involved process if a database already has pre-existing data, it is recommended to set the desired graph type before populating a graph with data. + +.Set a graph type to ensure the integrity of the data model in a database +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (:Person => :Resident {name :: STRING NOT NULL}), + (:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) +} +---- + +[[node-element-types]] +=== Node element types + +.Node element type example +image::graph-types-node-element-type.svg[Image of an example node element type, width=600,role=popup] + +Node element types are defined by an *identifying label*. +Node element types ensure that one or more of the following is true for all nodes with an identifying label: + +* Certain additional labels must exist . +The accompanying labels are referred to as *implied labels*. +* Certain properties must exist. +* Certain properties must be of a specific property type. +For a list of accepted property types, see xref:values-and-types/property-structural-constructed.adoc#property-types[Values and types -> Property types]. + +.Node element types in graph type +[source] +---- +(:Person => :Resident {name :: STRING NOT NULL}), // <1> +(:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}), // <2> +(:City => {name :: STRING NOT NULL, population :: INTEGER}) // <3> +---- + +<1> Node element type ensuring that nodes with a `Person` label must also have a `Resident` label and that `Person` nodes must have a `name` property of type `STRING`. +The `Person` label is the identifying label of this node element type, and `Resident` is the implied label. +<2> Node element type ensuring that nodes with a `Pet` label must also have a `Resident` and an `Animal` label. +The node element type also ensures that any `healthCertificate` and `name` properties on `Pet` nodes must be of type `STRING`. +The `Pet` label is the identifying label of this node element type while `Resident` and `Animal` are implied labels. +<3> Node element type ensuring nodes with a `City` label must have a `name` property of type `STRING`, and that any `population` properties are of type `INTEGER`. +`City` is the identifying label of this node element type, and there are no implied labels. + +[NOTE] +A shorthand syntax equivalent for `NOT NULL` is to use an exclamation mark `!`. +For example, `(:Person \=> :Resident {name :: STRING!})`, is the syntactical equivalent of `(:Person \=> :Resident {name :: STRING NOT NULL})`. + +.Node element type syntax +[source, syntax] +---- +(:IdentifyingLabel => [:ImpliedLabel1[&...]] [“{“ {property1 :: [NOT NULL]}[, ...]”}”]) +---- + +If `ANY` is specified as the ``, the node element type will allow all valid property types to be assigned to the given property (`ANY` is only allowed if the property’s existence is enforced, that is if it is appended with `NOT NULL`). + +[[relationship-element-types]] +=== Relationship element types + +.Relationship element type example +image::graph-types-relationship-element-type.svg[Image of an example relationship element type, width=600,role=popup] + +Relationship element types are defined by an *identifying type*. +Relationship element types ensure that one or more of the following is true for relationships with an identifying type: + +* The source node must have a specific label. +* The target node must have a specific label. +* Certain properties must exist. +* Certain properties must be of a specific property type. +For a list of accepted property types, see xref:values-and-types/property-structural-constructed.adoc#property-types[Values and types -> Property types]. + +.Relationship element type in graph type +[source] +---- +(:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) // <1> +---- + +<1> Relationship element type ensuring that all relationships with the identifying type `LIVES_IN` connect a `Resident` node to a `City` node, and have a `since` property of type `DATE`. +`Resident` is the source node element type, and `City` is the target node element type. + +.Relationship element type syntax +[source, syntax] +---- +([:SourceNodeLabel])-"[":IDENTIFYING_REL_TYPE => [ "{" {property1 :: [NOT NULL]}[, ...]"}" ] "]"->([:TargetNodeLabel]) +---- + +[NOTE] +==== +Relationship element types do not require both end nodes to be defined. +Specifically: + +* If the relationship element type defines either a source or a target node, the other is not required (e.g., `(:Resident)-[:LIVES_IN \=>]\->()` is acceptable). +* If the relationship element type includes properties, both the source and target nodes are optional (e.g., `()-[:LIVES_IN \=> {since :: DATE NOT NULL}]\->()` is acceptable). +==== + +[[identifying-node-labels-and-relationship-types]] +=== Identifying node labels and relationship types + +Node element types have identifying node labels and relationship element types have identifying relationship types. +These identifying node labels and relationship types are used to uniquely identify a node or relationship element type in a graph type. +For example, in a node element type definition like `(:Person \=> :Resident {\...})`, the `Person` label is the identifying label, indicating that the node element type represents a node with a `Person` label. + +*You cannot have different element types with the same identifying node label or relationship type.* + +.Allowed +[source] +---- +(:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}), +(:Person)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), +(:Person)-[:BORN_IN => {dob :: DATE NOT NULL})]->(:City) +---- + +.Not allowed -- identifying relationship types among relationship element types must be unique +[source] +---- +(:Person)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), +(:Pet)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) +---- + +.Not allowed -- identifying node labels among node element types must be unique +[source] +---- +(:Person => :Resident {name :: STRING}), +(:Person => :Citizen {name :: STRING}) +---- + +[[implied-node-labels-in-relationship-element-types]] +=== Implied node labels and their use in relationship element types + +Node element types can also have one or more implied labels (relationship element types cannot have implied relationship types because relationships in Neo4j can only have one type). +These labels further describe or refine the node element type, adding more information. +For example, in a node element type definition like `(:Person \=> :Resident {\...})`, `Resident` is the implied label, meaning that the node represents a `Person` who is also a `Resident`, but `Person` remains the main identifier. + +Implied node labels, when shared by multiple element node types, can be useful to define relationship element types with multiple source or target element node types. +For example, if `Resident` is an implied label in both the `Person` and `Pet` node element types, it can also be used as the source node for the relationship element type `LIVES_IN`. + +.Allowed +[source] +---- +(:Person => :Resident {name :: STRING NOT NULL}), +(:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}), +(:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) +---- + +.Not allowed -- using a node label as both identifying and implied +[source] +---- +(:Person => :Resident {name :: STRING NOT NULL}), +(:Resident => :Citizen {nationality :: STRING}) +---- + +.Not allowed -- identifying relationship types among relationship element types must be unique +[source] +---- +(:Person => :Resident {name :: STRING NOT NULL}), +(:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}), +(:Person)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), +(:Pet)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) +---- + +[[constraints-on-identifying-labels-and-types]] +=== Property uniqueness and key constraints on identifying node labels and relationship types + +The examples so far have included node and relationship element types constraining the following: + +* The types of specific properties on nodes with an identifying label and relationships with an identifying type. +* The existence of specific properties on nodes with an identifying label and relationships with an identifying type. +* The existence of implied labels on nodes with an identifying label. +* The source and target nodes of relationships with an identifying type. + +However, node and relationship element types can also be defined to include xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[property uniqueness] and xref:schema/constraints/create-constraints.adoc#create-key-constraints[key] constraints on their identifying node label or relationship type. + +.Set a graph type that includes key constraints on identifying node labels +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, // <1> + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), // <2> + (c:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(c) +} +---- + +<1> Node element type ensuring that nodes with a `Person` label must also have a `Resident` label and that any `name` and `ssn` (social security number) properties on `Person` nodes are of type `STRING` and `INTEGER` respectively. +The `Person` node element type defines a node key constraint ensuring that `Person` nodes must have both a `name` and an `ssn` property and that their combined value must be unique. +<2> Node element type ensuring that nodes with a `Pet` label must also have a `Resident` and an `Animal` label. +The node element type defines a node key constraint requiring `Pet` nodes to have a unique `insuranceNumber` property of type `INTEGER`. +The node element type also ensures that any `healthCertificate` properties on `Pet` nodes must be unique and of type `STRING` and that any `name` properties are of type `STRING`. + +[NOTE] +The example above sets a new graph type, *thus replacing the previously set graph type*. +It also uses variables to bind node element types. +Variables provide a concise way to reference elements specified in a graph type and are necessary when using the xref:schema/graph-types/set-graph-types.adoc#require-keyword-composite-property-uniqueness-key-constraints[`REQUIRE` keyword]. + +.Updated data model, showing addition of key constraints on identifying node labels in graph type +image::graph-types-element-type-constraints.svg[Image of updated data model, showing addition of key constraints on identifying node labels in graph type, width=700,role=popup] + +[[require-keyword-composite-property-uniqueness-key-constraints]] +=== The `REQUIRE` keyword and composite property uniqueness and key constraints + +Single property uniqueness and key constraints can be defined in a node or relationship element type with or without the `REQUIRE` keyword. + +.Syntax for defining single property uniqueness or key constraints with and without the `REQUIRE` keyword +[source, syntax] +---- +(n:Label => “{“property :: IS {UNIQUE | KEY} “}”), +(n:Label => “{“property :: ”}”) + REQUIRE n.property IS { UNIQUE | KEY } + +()-”[“r:REL_TYPE => “{“property:: IS {UNIQUE | KEY} ”}”]->(), +()-”[“r:REL_TYPE => “{“property:: ”}” “]”->() + REQUIRE r.property IS { UNIQUE | KEY } +---- + +To define composite uniqueness and key constraints on more than one property in node and relationship element types it is necessary to use the `REQUIRE` keyword and the constrained properties must be parenthesized. + +.Syntax for defining composite property uniqueness or key constraints +[source, syntax] +---- +(n:Label => “{“property1 :: , property2 :: [, ...]”}”) + REQUIRE (n.property1, n.property2[, ...]) IS {UNIQUE | KEY} + +()-”[“r:REL_TYPE => “{“property1:: , property2 :: [, ...] “}” “]”->() + REQUIRE (r.property1, r.property2[, ...]) IS {UNIQUE | KEY} +---- + +[NOTE] +Properties specified in a `REQUIRE` clause are not required to exist on the node or relationship element types to which the constraint applies. +For example, the following is a valid element type key constraint defined against a node element type: `(n:Label \=> {property1 :: STRING, property2 :: INTEGER}) REQUIRE (n.property3, n.property4) IS KEY`. + +The `REQUIRE` keyword can also be used as an alternative syntax to define several property uniqueness and key constraints within the same node or relationship element type. + +.Syntax for defining multiple property uniqueness or key constraints using the `REQUIRE` keyword +---- +(n:Label => “{“property1 :: , property2 :: ”}”) + REQUIRE n.property1 IS {UNIQUE | KEY} + REQUIRE n.property2 IS {UNIQUE | KEY} + +()-”[“r:REL_TYPE => “{“r.property1 :: , r.property2 :: “}” “]”->() + REQUIRE r.property1 IS {UNIQUE | KEY} + REQUIRE r.property2 IS {UNIQUE | KEY} +---- + +[[naming-property-uniqueness-and-key-constraints]] +=== Naming property uniqueness and key constraints + +Property uniqueness and key constraints can also be created using the `CONSTRAINT … FOR … REQUIRE` syntax. +If so, they can be given a name, which must be unique across both indexes and constraints (if a name is not explicitly given, one will be assigned automatically). +The constraint name can be used in the `ALTER CURRENT GRAPH TYPE DROP` or `DROP CONSTRAINT` commands. +For more information, see xref:schema/graph-types/drop-graph-type-elements.adoc#drop-constraints-on-identifying-and-non-identifying-labels-and-types[Drop constraints on identifying and non-identifying node labels and relationship types]. + +The following two examples define the same key constraint on an identifying node label. +However, only in the latter, which uses the `CONSTRAINT … FOR … REQUIRE` syntax, is it explicitly named. + +.Define a key constraint without explicitly giving a name +[source] +---- +(p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY +---- + +.Define an explicitly named key constraint +[source] +---- +(:Person => :Resident {name :: STRING, ssn :: INTEGER}), +CONSTRAINT name_ssn_constraint FOR (p:Person) REQUIRE (p.name, p.ssn) IS KEY +---- + +.Define a single property uniqueness or key constraint using the using the `CONSTRAINT … FOR … REQUIRE` syntax +[source, syntax] +---- +(:Label => “{“property :: ”}”), +CONSTRAINT [name] FOR (n:Label) REQUIRE n.property IS {UNIQUE | KEY} + +()-”[“:REL_TYPE => “{“property:: ”}” “]”->(), +CONSTRAINT [name] FOR ()-”[“r:REL_TYPE”]”->() REQUIRE r.property IS {UNIQUE | KEY} +---- + +.Define a composite property uniqueness or key constraint using the `CONSTRAINT … FOR … REQUIRE` syntax +[source, syntax] +---- +(:Label => “{“property1 :: , property2 :: ”[, ...]}”), +CONSTRAINT [name] FOR (n:Label) REQUIRE (n.property1, n.property2[, ...]) IS {UNIQUE | KEY} + +()-”[“:REL_TYPE => “{“property1 :: , property2 :: [, ...]”}” “]”->(), +CONSTRAINT [name] FOR ()-”[“r:REL_TYPE”]”->() REQUIRE (r.property1,r.property2[, ...]) IS {UNIQUE | KEY} +---- + +To define a constraint on node labels and relationship types that do not serve as identifying node labels or relationship types in a graph type it is necessary to use the `CONSTRAINT … FOR … REQUIRE` syntax. +For more information, see xref:schema/syntax.adoc#non-identifying-labels-and-types[Constraints on non-identifying node labels and relationship types] below. + +[[create-data-after-setting-graph-type]] +== Create data after setting a graph type + +The purpose of a graph type is to impose a schema on the nodes, relationships, and properties included within it. +The data created in a graph must accordingly abide by the schema defined in the graph type. + +.Current graph type +[source] +---- +(p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, +(:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), +(c:City => {name :: STRING NOT NULL, population :: INTEGER}), +(:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City) +---- + +.Create data complying with the graph type +[source, cypher] +---- +CREATE (alice:Person:Resident {name: 'Alice Carlyle', ssn: 987654321}), + (ben:Person:Resident {name: 'Benjamin Davis', ssn: 456789123}), + (ozzy:Pet:Resident:Animal {insuranceNumber: 876543210, healthCertificate: 'HC789123', name: 'Ozzy'}), + (zoey:Pet:Resident:Animal {insuranceNumber: 564738291, name: 'Zoey'}), + (nyc:City {name: 'New York City', population: 8097282}), + (la:City {name: 'Los Angeles'}), + (alice)-[:LIVES_IN {since: date('2018-06-15')}]->(nyc), + (ozzy)-[:LIVES_IN {since: date('2022-08-09')}]->(nyc), + (ben)-[:LIVES_IN {since: date('1999-10-17')}]->(la), + (zoey)-[:LIVES_IN {since: date('2015-08-11')}]->(la) +---- + +Note the absence of a `healthCertificate` property on the `Pet` node `'Zoey'`, and a `population` property on the `'Los Angeles'` `City` node. +These omissions are allowed by the graph type, as neither node element type requires the existence of these properties -— only that if they are present, they conform to the specified property type. + +.Create data violating a node element type +[source, cypher, role=test-fail] +---- +CREATE (:Person:Resident {name: 'Alice Carlyle', ssn: 987654321}) // <1> +CREATE (:Person {name: 'Alice Carlyle', ssn: 123456789}) // <2> +CREATE (:Person:Resident {name: 'Alice Carlyle'}) // <3> +CREATE (:Person:Resident {name: 'Alice Carlyle', ssn: 'HNB48182'}) // <4> +---- + +<1> This will fail because it would create a node with properties identical to an existing one, thereby violating the key constraint defined in the `Person` node element type. +<2> This will fail because the `Person` node element type requires nodes with a `Person` label to also have a `Resident` label. +<3> This will fail because not all properties constrained in the graph type key constraint (`name`, `ssn`) defined in the `Person` node element type are present. +<4> This will fail because a type-constrained property (`ssn`) is of a different type (`STRING`) than the one defined for the property in the `Person` node element type (`INTEGER`). + +.Create data violating a relationship element type +[source, cypher, role=test-fail] +---- +CREATE (:Human {name: 'Carl Ericsson' ssn: 765498321})-[:LIVES_IN {since: date('1999-10-17')}]->(:City {name: 'Toronto'}) // <1> +MATCH (alice:Person:Resident {name: 'Alice Carlyle'}) +CREATE (alice)-[:LIVES_IN {since: date('1999-10-17')}]->(:Country {name: 'Canada'}) // <2> +CREATE (alice)-[:LIVES_IN]->(:City {name: 'Toronto'}) // <3> +CREATE (alice)-[:LIVES_IN {since: '1999-10-17'}]->(:City {name: 'Toronto'}) <4> +---- + +<1> This will fail because the source node defined in the `LIVES_IN` relationship element type must have a `Resident` label. +<2> This will fail because the target node defined in the `LIVES_IN` relationship element type must have a `City` label. +<3> This will fail because an existence-constrained property (`since`) defined in the `LIVES_IN` relationship element type is missing. +<4> This will fail because a type-constrained property (`since`) is of a different type (`STRING`) than the one defined for the property in the `LIVES_IN` relationship element type (`DATE`). + +[[open-graph-type-capabilities]] +== Open graph type capabilities + +The great benefit of working with open graph types is that they allow you to constrain specific data while remaining flexible to add or modify data not constrained by the graph type. + +.Create nodes and relationships with labels/types defined as identifying in the graph type, but with properties not defined in their respective node or relationship element types +[source, cypher] +---- +CREATE (carl:Person:Resident {name: 'Carl Ericson', ssn: 162734679, born: date('1998-08-08')}), // <1> + (molly:Pet:Resident:Animal {name: 'Molly', insuranceNumber: 672829172, healthCertificate: 'HT654987', breed: 'Alsatian'}), // <2> + (atlanta:City {name: 'Atlanta', population: 2794356, country: 'USA'}), // <3> + (carl)-[:LIVES_IN {since: date('2020-09-15'), address: '101, Jasper Avenue'}]->(atlanta)<-[:LIVES_IN {since: date('2022-10-22')}]-(molly) // <4> +---- + +<1> There is no `born` property defined in the `Person` node element type. +<2> There is no `breed` property defined in the `Pet` node element type. +<3> There is no `country` property defined in the `City` node element type. +<4> There is no `address` property defined in the `LIVES_IN` relationship element type. + +.Create nodes with implied labels but no identifying labels +[source, cypher] +---- +CREATE (:StrayAnimal:Animal:Resident {id: '24.09-172898'}), + (:Robot:Resident {name: 'Gary', application: 'Veterinary medicine'}) +---- + +.Create nodes with node labels and relationship types not included in the graph type +[source, cypher] +---- +MATCH (ben:Person {name: 'Benjamin Davis'}), (zoey:Pet {name: 'Zoey'}), (gary:Robot {name: 'Gary'}) +CREATE (ben)-[:OWNER_OF {ownershipId: 'GTHD-985'}]->(zoey), + (ben)-[:WORKS_FOR {role: 'Product Manager'}]->(healthyPets:Company {name: 'Healthy Pets Inc.', address: '4567 Wellness Drive, Los Angeles, CA 90001'}), + (gary)-[:INSTALLED_AT]->(healthyPets) +---- + +[[set-graph-type-populated-database]] +== Set a graph type on a populated database + +If a database contains data conflicting with the requirements of a graph type, it will only be possible to set the desired graph type once any conflicting data has been modified to abide by its schema. +Setting a graph type on a populated database will, therefore, involve checks on the existing data. +Note that any previously defined graph types are overwritten and replaced when a graph type is set. + +.Data in the database +image::graph-types-data-in-database.svg[Image showing the data in the database,width=600,role=popup] + +The following graph type could not be set in a database containing the data created in the previous section: + +.Not allowed -- setting a graph type conflicting with existing data +[source, cypher, role=test-fail] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Robot => :Resident {name :: STRING, id :: INTEGER IS KEY}), // <1> + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), + (:Person)-[r:OWNER_OF => {ownershipId :: INTEGER IS UNIQUE})->(:Pet) // <2> +} +---- + +<1> This node element type cannot be validated because it requires every `Robot` node to have a unique `id` property of type `INTEGER` (the previously created `Robot` node has no `id` property). +<2> This relationship element type is invalid because it requires that any `ownershipId` properties on `OWNER_OF` relationships must be of type `INTEGER` (the previously created `OWNER_OF` relationship has an `ownershipId` property of type `STRING`). + +When situations like the example above arise, users should migrate the existing data to the new desired model and then apply the new graph type that will keep the data consistent from then on. + +[[constraints-on-non-identifying-labels-and-types]] +=== Constraints on non-identifying node labels and relationship types + +The examples thus far have included node and relationship element types, as well as property uniqueness and key constraints defined on identifying node labels and relationship types. + +It is also possible to include constraints in a graph type on implied node labels, or on node labels and relationship types which are independent of a node or relationship element type, using the `CONSTRAINT … FOR … REQUIRE` syntax outlined xref:schema/graph-types/set-graph-types.adoc#naming-property-uniqueness-and-key-constraints[above]. +This can be a useful tool if the data model requires certain attributes for nodes or relationships with non-identifying labels or types. + +[NOTE] +Constraints on non-identifying node labels and relationship types can be explicitly named when defined. +This can be useful when xref:schema/graph-types/drop-graph-type-elements.adoc#drop-constraints-on-identifying-and-non-identifying-labels-and-types[dropping constraints on identifying and non-identifying node labels and relationship types] (if a name is not explicitly given, a name will be assigned). +The given name must be unique among both indexes and constraints. + +Property uniqueness and key constraints can be defined against any node label or relationship type in the graph, regardless of whether they serve as identifying node labels or relationship types (an example of a key constraint defined against the identifying node label of a node element type can be found xref:schema/graph-types/set-graph-types.adoc#naming-property-uniqueness-and-key-constraints[above]). + +.Set a graph type with key and property uniqueness constraints on non-identifying node labels +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), + CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, // <1> + CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE // <2> +} +---- + +<1> Node key constraint defined against a node label (`:Company`) which is not part of any element type (either as identifying or implied) in the graph type. +<2> Property uniqueness constraint defined against a node label (`:Animal`) which serves as an implied label in the `Pet` node element type. + +[NOTE] +The example above sets a new graph type, *thus replacing the previously set graph type*. + +xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[Property existence] and xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[property type constraints] can also be defined on non-identifying labels and relationship types. +*Unlike property uniqueness and key constraints, however, they cannot constrain identifying node labels or relationship types if they are defined outside of the node or relationship element type.* +This is because node and relationship element types can directly express the effects of property existence and property type constraints on the identifying node labels or relationship types. + +.Allowed -- define property existence constraint in a node element type +[source] +---- +(:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING, address :: ANY NOT NULL}) +---- + +.Not allowed -- add property existence constraint on an identifying node label outside of a node element type +[source] +---- +(:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), +CONSTRAINT pet_address FOR (pet:Pet) REQUIRE pet.address IS NOT NULL +---- + +[NOTE] +Property existence and type constraints cannot be given a name if expressed in a node or relationship element type (they will always be assigned a generated name). +For more information, see xref:schema/graph-types/list-graph-types.adoc#graph-type-elements-in-show-constraints[Show graph types -> Graph type elements in `SHOW CONSTRAINTS`]. + +Most use cases can thus be served by the node and relationship element types in a graph type. +However, adding property existence and type constraints on non-identifying node labels or relationship types can be useful for defining more specialized constraints, especially in an already populated database. + +.Set a graph type including property type constraint on non-identifying node label +[source, cypher] +---- +ALTER CURRENT GRAPH TYPE SET { + (p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, + (:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), + (:Robot => :Resident {application :: STRING NOT NULL}), + (:City => {name :: STRING NOT NULL, population :: INTEGER}), + (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), + CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, + CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, + CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address IS :: STRING // <1> +} +---- + +<1> Property type constraint ensuring that any address properties on `RESIDENT` nodes are of type `STRING`. +This constraint is valid because `Resident` is not an identifying label in any of the above node element types. + +[NOTE] +The example above sets a new graph type, *thus replacing the previously set graph type*. + +.Updated data model, showing new `Robot` node element type and addition of constraints on non-identifying node labels in graph type +image::graph-types-set-graph-type-populated-database.svg[Graph type showing addition of constraints on non-identifying node labels, width=600, role=popup] + +[[graph-type-implementation]] +== Graph type implementation: translation to constraints + +Once a graph type is defined, it is translated into a set of constraints. +These constraints ensure that the creation and development of a graph conforms to the open schema specified by the graph type. + +The constraints that enforce a graph type are returned by the `SHOW CONSTRAINTS` command. +For more information, see xref:schema/graph-types/list-graph-types.adoc#graph-type-elements-in-show-constraints[Show graph types -> Graph type elements in `SHOW CONSTRAINTS`]. + +.Current graph type +[source] +---- +(p:Person => :Resident {name :: STRING, ssn :: INTEGER}) + REQUIRE (p.name, p.ssn) IS KEY, +(:Pet => :Resident&Animal {insuranceNumber :: INTEGER IS KEY, healthCertificate :: STRING IS UNIQUE, name :: STRING}), +(:Robot => :Resident {application :: STRING NOT NULL}), +(:City => {name :: STRING NOT NULL, population :: INTEGER}), +(:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City), +CONSTRAINT company_name FOR (c:Company) REQUIRE c.name IS KEY, +CONSTRAINT animal_id FOR (a:Animal) REQUIRE a.id IS UNIQUE, +CONSTRAINT resident_address FOR (resident:Resident) REQUIRE resident.address :: STRING +---- + +.Node and relationship element types +[cols="3*", options="header"] +|=== +| Identifying node label/relationship type +| Constraint type +| Details + +| `(:Person)` +| Node property type +| `name :: STRING` + +| `(:Person)` +| Node property type +| `ssn :: INTEGER` + +| `(:Person)` +| Node label existence +| Nodes with a `Person` label must also have a `Resident` label. + +| `(:Pet)` +| Node property type +| `insuranceNumber :: INTEGER` + +| `(:Pet)` +| Node property type +| `healthCertificate :: STRING` + +| `(:Pet)` +| Node property type +| `name :: STRING` + +| `(:Pet)` +| Node label existence +| Nodes with a `Pet` label must also have a `Resident` label. + +| `(:Pet)` +| Node label existence +| Nodes with a `Pet` label must also have an `Animal` label. + +| `(:Robot)` +| Node property type +| `application :: STRING` + +| `(:Robot)` +| Node property existence +| `application IS NOT NULL` + +| `(:Robot)` +| Node label existence +| Nodes with a `Robot` label must also have a `Resident` label. + +| `(:City)` +| Node property type +| `name :: STRING` + +| `(:City)` +| Node property existence +| `name IS NOT NULL` + +| `(:City)` +| Node property type +| `population :: INTEGER` + +| `()-[:LIVES_IN]\->()` +| Relationship property type +| `since :: DATE` + +| `()-[:LIVES_IN]\->()` +| Relationship property existence +| `since IS NOT NULL` + +| `()-[:LIVES_IN]\->()` +| Relationship source label +| Source node must have the label `Resident`. + +| `()-[:LIVES_IN]\->()` +| Relationship target label +| Target node must have the label `City`. +|=== + +.Key and property uniqueness constraints on node identifying node labels and relationship types +[cols="3*", options="header"] +|=== +| Identifying node label/relationship type +| Constraint type +| Details + +| `(:Person)` +| Node key +| `(name, ssn) IS KEY` + +| `(:Pet)` +| Node key +| `insuranceNumber IS KEY` + +| `(:Pet)` +| Node property uniqueness +| `healthCertificate IS UNIQUE` +|=== + +.Constraints on non-identifying node labels +[cols="4*", options="header"] +|=== +| Name +| Node label/Relationship type +| Constraint type +| Details + +| `company_name` +| `(:Company)` +| Node key +| `name IS KEY` + +| `animal_id` +| `(:Animal)` +| Node property uniqueness +| `id IS UNIQUE` + +| `resident_address` +| `(:Resident)` +| Node property type +| `name :: STRING` +|=== + +[[constraint-types-explained]] +=== Constraint types explained + +*Node label existence constraints* ensure that a particular label exists on a node. +This constraint will only be created if a node element type specifies implied labels, and *it cannot be created the `CREATE CONSTRAINT` command.* + +*Relationship source and target label constraints* ensure that specific relationship types have target and source nodes with specific labels. +A relationship source label constraint will only be created if a relationship element type specifies a source node. +A relationship target label constraint will only be created if a relationship type specifies a target node. +*Neither of these constraints can be created using the `CREATE CONSTRAINT` command.* + +*Property type constraints* ensure a property has the required property type for all nodes with a specific label or all relationships with a specific type. +To learn more about property type constraints and how to create them using the `CREATE CONSTRAINT` syntax, see xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[Constraints -> Create property type constraints]. + +*Property existence constraints* ensure a property exists on all nodes with a specific label or all relationships with a specific type. +To learn more about property existence constraints and how to create them using the `CREATE CONSTRAINT` command, see xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[Constraints -> Create property existence constraints]. + +*Property uniqueness constraints* ensure that the combined property values are unique for all nodes with a specific label or all relationships with a specific type. +To learn more about property uniqueness constraints, and how to create them using the `CREATE CONSTRAINT` command, see xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[Constraints -> Create property uniqueness constraints]. + +*Key constraints* ensure that all properties exist and that the combined property values are unique for all nodes with a specific label or all relationships with a specific type. +To learn more about key constraints, and how to create them using the `CREATE CONSTRAINT` command, see xref:schema/constraints/create-constraints.adoc#create-key-constraints[Constraints -> Create key constraints]. diff --git a/modules/ROOT/pages/schema/index.adoc b/modules/ROOT/pages/schema/index.adoc new file mode 100644 index 000000000..ba3fa8222 --- /dev/null +++ b/modules/ROOT/pages/schema/index.adoc @@ -0,0 +1,25 @@ +:description: Information about using a schema in Neo4j for ensuring data integrity. += Schema + +Neo4j is a natively schema-free database. +This allows for the rapid development of graphs that can continue to evolve and expand by incorporating new sources of data. + +You can, however, impose an open schema in Neo4j. +An open schema applies constraints only to the data explicitly included in the schema. +This approach maintains a flexible framework that makes it easy to adapt and grow your data model as new requirements emerge, while also allowing for enforcing the shape of the most stable and established part of the data model. + +There are two methods of imposing an open schema in Neo4j: + +* xref:schema/graph-types/index.adoc[]: enforces holistically an open schema, providing a defined structure for an entire graph. label:cypher[Cypher 25 only] label:new[Introduced in Neo4j 2025.xx] label:enterprise-edition[] +* xref:schema/constraints/index.adoc[]: enforces specific constraints on node or relationship properties. + +[NOTE] +==== +All constraints created using the older xref:schema/constraints/create-constraints.adoc#create-constraint[`CREATE CONSTRAINT`] syntax will automatically be added to the graph type of a database. +Not all constraint types can be created using this syntax, however, and maintaining individual constraints can become complicated over time as their number increases. + +*It is, therefore, recommended to define a schema using a graph type, which offers both additional, more sophisticated constraint types and a more holistic and simplified approach for constraining and maintaining the shape of the data in a graph.* +==== + + + diff --git a/modules/ROOT/pages/schema/syntax.adoc b/modules/ROOT/pages/schema/syntax.adoc new file mode 100644 index 000000000..7d6accce5 --- /dev/null +++ b/modules/ROOT/pages/schema/syntax.adoc @@ -0,0 +1,643 @@ +:description: Syntax for how to manage graph types and constraints in Neo4j. +:table-caption!: +:page-aliases: constraints/syntax.adoc += Syntax + +This page contains the syntax for the graph types and constraints commands. +More details about the syntax can be found in the link:{neo4j-docs-base-uri}/operations-manual/current/database-administration/syntax/#administration-syntax-reading[Operations Manual -> Cypher syntax for administration commands]. + +[role=label--cypher-25-only label--enterprise-edition label--new-Neo4j-2025.xx] +[[graph-types]] +== Graph types + +[[element-types]] +=== Node and relationship element types + +.Syntax for node element types, +[source, syntax] +---- +([alias] {IS | :} IdentifyingLabelName {=> | IMPLIES} [{IS | :} ImpliedLabelName[&...]] [“{“ {propertyName [[IS] :: | IS TYPED] [IS [NODE] {KEY | UNIQUE}]}[, ...] “}”]) +[REQUIRE {alias.propertyName | (alias.propertyName[, ...])} IS [NODE] {KEY | UNIQUE}][...] +---- + +[NOTE] +A node element type requires either one or more implied labels or a non-empty property map. + +For more information, see xref:schema/graph-types/set-graph-types.adoc#node-element-types[Set graph types -> Node element types]. + +.Syntax for relationship element types, +[source, syntax] +----- +([nodeAlias | [nodeAlias] {IS | :} LabelName [=> | IMPLIES]])-”[“ [alias] {IS | :} IDENTIFYING_RELATIONSHIP_TYPE {=> | IMPLIES} [“{“ {propertyName [[IS] :: | IS TYPED] [IS [REL[ATIONSHIP]] {KEY | UNIQUE}]}[, ...] “}”] “]”->([nodeAlias | [nodeAlias] {IS | :} LabelName [=> | IMPLIES]]) +[REQUIRE {alias.propertyName | (alias.propertyName[, ...])} IS [REL[ATIONSHIP]] {KEY | UNIQUE}][...] +----- + +[NOTE] +==== +A relationship element type requires either: + +* A non-empty source or a target node. +* A non-empty property map. +==== + +For more information, see xref:schema/graph-types/set-graph-types.adoc#relationship-element-types[Set graph types -> Relationship element types]. + +`` can be one of the property types listed in xref:schema/syntax.adoc#constraints-definitions[constraint definitions in graph types], the `NOT NULL` versions of those types, or `ANY NOT NULL`. +Allowed syntax variations of these types are listed in xref:values-and-types/property-structural-constructed.adoc#types-synonyms[Values and types -> Types and their synonyms]. + +The three variations of the property type expression, `IS ::`, `::`, and `IS TYPED` are syntactic synonyms for the same expression. +The preferred syntax when defining node and relationship element types in a graph type is the `::` variant. + +[[constraints-definitions]] +=== Constraint definitions in graph types + +.Syntax for property uniqueness and key constraints on identifying node labels and relationship types, +[cols="1a, 3a", options="noheader"] +|=== +| Property uniqueness and key constraints on labels identifying node element types +a| +[source, syntax] +---- +CONSTRAINT [constraint_name] +FOR (alias [{IS \| :} IdentifyingLabelName [=> \| IMPLIES]]) +REQUIRE {alias.propertyName \| (alias.propertyName[, ...])} IS [NODE] {KEY \| UNIQUE} +---- + +| Property uniqueness and key constraints on relationship types identifying relationship element types +a| +[source, syntax] +---- +CONSTRAINT [constraint_name] +FOR ()-”[“alias [{IS \| :} IDENTIFYING_RELATIONSHIP_TYPE [=> \| IMPLIES]] “]”->() +REQUIRE {alias.propertyName \| (alias.propertyName[, ...])} IS [REL[ATIONSHIP]] {KEY \| UNIQUE} +---- +|=== + +For more information, see xref:schema/graph-types/set-graph-types.adoc#constraints-on-identifying-labels-and-types[Set graph types -> Property uniqueness and key constraints on identifying node labels and relationship types]. + +.Syntax for property uniqueness, property existence, property type, and key constraints on non-identifying node labels and relationship types, +[cols="1a, 3a", options="noheader"] +|=== +| Node key and property uniqueness constraint +a| +[source, syntax] +---- +CONSTRAINT [constraint_name] +FOR (alias {IS \| :} NonIdentifyingLabelName) +REQUIRE {alias.propertyName \| (alias.propertyName[, ...])} IS [NODE] {KEY \| UNIQUE} +---- + +| Node property existence and property type constraint +a| +[source, syntax] +---- +CONSTRAINT [constraint_name] +FOR (alias {IS \| :} NonIdentifyingLabelName) +REQUIRE {alias.propertyName \| (alias.propertyName)} { IS NOT NULL \| {[IS] :: \| IS TYPED} } +---- + +| Relationship key and property uniqueness constraint +a| +[source, syntax] +---- +CONSTRAINT [constraint_name] +FOR ()-”[“alias {IS \| :} NON_IDENTIFYING_RELATIONSHIP_TYPE “]”->() +REQUIRE {alias.propertyName \| (alias.propertyName[, ...])} IS [REL[ATIONSHIP]] {KEY \| UNIQUE} +---- + +| Relationship property existence and property type constraint +a| +[source, syntax] +---- +CONSTRAINT [constraint_name] +FOR ()-”[“alias {IS \| :} NON_IDENTIFYING_RELATIONSHIP_TYPE “]”->() +REQUIRE {alias.propertyName \| (alias.propertyName)} { IS NOT NULL \| {[IS] :: \| IS TYPED} } +---- +|=== + +For more information, see see xref:schema/graph-types/set-graph-types.adoc#constraints-on-non-identifying-labels-and-types[Set graph types -> Constraints on non-identifying labels and types]. + +The three variations of the property type expression, `IS ::`, `::`, and `IS TYPED` are syntactic synonyms for the same expression. +The preferred syntax when defining constraints in a graph type is the `IS ::` variant. + +`` can be one of the following property types: + +* `BOOLEAN` +* `STRING` +* `INTEGER` +* `FLOAT` +* `DATE` +* `LOCAL TIME` +* `ZONED TIME` +* `LOCAL DATETIME` +* `ZONED DATETIME` +* `DURATION` +* `POINT` +* `VECTOR(DIMENSION)` label:cypher[Cypher 25 only] label:new[Introduced in Neo4j 2025.10] +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* Any closed dynamic union of the above types, e.g. `INTEGER | FLOAT | STRING`. + +[NOTE] +Because storing lists of xref:values-and-types/vector.adoc[`VECTOR`] values is not supported, property type constraints cannot be created for `LIST(DIMENSION) NOT NULL>`. +Additionally, `VECTOR` property type constraints must be created with a specific dimension and coordinate value, where the dimension must be greater than `0` and less than or equal to `4096`. +For more information, see xref:values-and-types/vector.adoc[Values and types -> Vectors]. + +Allowed syntax variations of these types are listed in xref:values-and-types/property-structural-constructed.adoc#types-synonyms[Values and types -> Types and their synonyms]. + +[[set-graph-types]] +=== Set graph types + +[NOTE] +==== +Setting a graph type requires the following privileges: + +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-tokens[`NAME MANAGEMENT`] (if graph type includes node labels, relationship types, or properties not already in the graph) +==== + +.Syntax for `ALTER CURRENT GRAPH TYPE SET` +[source, syntax] +---- +ALTER CURRENT GRAPH TYPE SET “{“ + [{ | | | }[, ...]] +“}” +---- + +For more information, see xref:schema/graph-types/set-graph-types.adoc[]. + +[[extend-graph-types]] +=== Extend graph types + +[NOTE] +==== +Extending a graph type requires the following privileges: + +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-tokens[`NAME MANAGEMENT`] (if graph type includes node labels, relationship types, or properties not already in the graph) +==== + +.Syntax for `ALTER CURRENT GRAPH TYPE ADD` +[source, syntax] +---- +ALTER CURRENT GRAPH TYPE ADD “{“ + [{ | | | }[, ...]] +“}” +---- + +[NOTE] +Any added element types and constraints must, together with the existing ones, form a valid graph type. +This means, for example, that `ADD` cannot modify existing element types but only add new ones. +Independent constraints cannot be added to node labels/relationship types that serve as the identifying labels/types of element types. +Nor can element types be added if their identifying labels/types already have independent constraints defined on them. + +For more information, see xref:schema/graph-types/extend-graph-types.adoc[]. + +[[alter-element-types]] +=== Alter element types + +[NOTE] +==== +Altering element types in a graph type requires the following privileges: + +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT`] +* link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-tokens[`NAME MANAGEMENT`] (if graph type includes node labels, relationship types, or properties not already in the graph) +==== + +.Syntax for `ALTER CURRENT GRAPH TYPE ALTER` +[source, syntax] +---- +ALTER CURRENT GRAPH TYPE ALTER “{“ + [{ | }[, ...]] +“}” +---- + +[NOTE] +==== +Note the following: + +* Key or property uniqueness constraints cannot be included when altering an element type. +* `ALTER` cannot introduce new element types to the graph type, only modify existing ones. +And it replaces the previous definition of that element type with the new definition. +==== + +For more information, see xref:schema/graph-types/alter-element-types.adoc[]. + +[[list-graph-types]] +=== Show graph types + +[NOTE] +Showing a graph type requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. + +.Syntax to list the current graph type with default return columns +[source, syntax] +---- +SHOW CURRENT GRAPH TYPE + [WHERE expression] +---- + +.Syntax to list the current graph type with full return columns +[source, syntax] +---- +SHOW CURRENT GRAPH TYPE +YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n] + [WHERE expression] + [RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]] +---- + +For more information, see xref:schema/graph-types/list-graph-types.adoc[]. +For full details of the columns returned by the `SHOW CURRENT GRAPH TYPE` command, see xref:schema/graph-types/list-graph-types.adoc#result-columns[Show graph types -> Result columns for `SHOW CURRENT GRAPH TYPE`]. + +[[drop-graph-type-elements]] +=== Drop graph type elements + +[NOTE] +Dropping element types and constraints from a graph type requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT` privilege]. + +.Syntax for dropping node element type, +[cols="1a, 3a", options="noheader"] +|=== +| Full definition +a| +[source, syntax] +---- +([alias] {IS \| :} IdentifyingLabelName {=> \| IMPLIES} [{IS \| :} ImpliedLabelName[&...]] [“{“ {propertyName [[IS] :: \| IS TYPED] }[, ...] “}”]) +---- + +| Identifying label only +a| +[source, syntax] +---- +([alias] {IS \| :} IdentifyingLabelName {=> \| IMPLIES}) +---- +|=== + +.Syntax for dropping relationship element type, +[cols="1a, 3a", options="noheader"] +|=== +| Full definition +a| +[source, syntax] +---- +([nodeAlias \| [nodeAlias] {IS \| :} LabelName [=> \| IMPLIES]])-”[“ [alias] {IS \| :} IDENTIFYING_RELATIONSHIP_TYPE {=> \| IMPLIES} [“{“ {propertyName [[IS] :: \| IS TYPED] }[, ...] “}”] “]”->([nodeAlias \| [nodeAlias] {IS \| :} LabelName [=> \| IMPLIES]]) +---- + +| Identifying type only +a| +[source, syntax] +---- +()-”[“ [alias] {IS \| :} IDENTIFYING_RELATIONSHIP_TYPE {=> \| IMPLIES} “]”->() +---- +|=== + +`` can be the same property types as for xref:schema/syntax.adoc#element-types[node and relationship element types]. + +[NOTE] +If the full definition is provided, then it needs to match exactly the node or relationship element type being dropped. + +.Syntax for dropping constraints on identifying or non-identifying labels/types, +[source, syntax] +---- +CONSTRAINT constraint_name +---- + +.Syntax for `ALTER CURRENT GRAPH TYPE DROP` +[source, syntax] +---- +ALTER CURRENT GRAPH TYPE DROP “{“ + [{ | | }[, ...]] +“}” +---- + +For more information, see xref:schema/graph-types/drop-graph-type-elements.adoc[]. + +[[constraints]] +== Constraints + +[[create-constraint]] +=== Create constraints + +Constraints are created with the `CREATE CONSTRAINT` command. +When creating a constraint, it is recommended to provide a constraint name. +This name must be unique among both indexes and constraints. +If a name is not explicitly given, a unique name will be auto-generated. + +[NOTE] +Creating a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`CREATE CONSTRAINT` privilege]. + +The `CREATE CONSTRAINT` command is optionally idempotent. +This means its default behavior is to throw an error if an attempt is made to create the same constraint twice. +With the `IF NOT EXISTS` flag, no error is thrown and nothing happens should a constraint with the same name or same schema and constraint type already exist. +It may still throw an error if conflicting data, indexes, or constraints exist. +Examples of this are nodes with missing properties, indexes with the same name, or constraints with same schema but a different conflicting constraint type. +An informational notification is returned in case nothing happens showing the existing constraint which blocks the creation. + +[[create-property-uniqueness-constraints]] +==== Create property uniqueness constraints + +.Syntax for creating a node property uniqueness constraint on a single property +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR (n:LabelName) +REQUIRE n.propertyName IS [NODE] UNIQUE +---- + +.Syntax for creating a composite node property uniqueness constraint on multiple properties +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR (n:LabelName) +REQUIRE (n.propertyName_1, ..., n.propertyName_n) IS [NODE] UNIQUE +---- + +.Syntax for creating a relationship property uniqueness constraint on a single property +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR ()-"["r:RELATIONSHIP_TYPE"]"-() +REQUIRE r.propertyName IS [REL[ATIONSHIP]] UNIQUE +---- + +.Syntax for creating a composite relationship property uniqueness constraint on multiple properties +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR ()-"["r:RELATIONSHIP_TYPE"]"-() +REQUIRE (r.propertyName_1, ..., r.propertyName_n) IS [REL[ATIONSHIP]] UNIQUE +---- + +For examples on how to create property uniqueness constraints, see xref:schema/constraints/create-constraints.adoc#create-property-uniqueness-constraints[Create constraints -> Create property uniqueness constraint]. +Property uniqueness constraints are xref:schema/constraints/create-constraints.adoc#constraints-and-indexes[index-backed]. + +[role=label--enterprise-edition] +[[create-property-existence-constraints]] +==== Create property existence constraints + +.Syntax for creating a node property existence constraint +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR (n:LabelName) +REQUIRE n.propertyName IS NOT NULL +---- + +.Syntax for creating a relationship property existence constraint +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR ()-"["r:RELATIONSHIP_TYPE"]"-() +REQUIRE r.propertyName IS NOT NULL +---- + +For examples on how to create property existence constraints, see xref:schema/constraints/create-constraints.adoc#create-property-existence-constraints[Create constraints -> Create property existence constraints]. + +[role=label--enterprise-edition] +[[create-property-type-constraints]] +==== Create property type constraints + +.Syntax for creating a node property type constraint +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR (n:LabelName) +REQUIRE n.propertyName {[IS] :: | IS TYPED} +---- + +.Syntax for creating a relationship property type constraint +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR ()-"["r:RELATIONSHIP_TYPE"]"-() +REQUIRE r.propertyName {[IS] :: | IS TYPED} +---- + +The three variations of the expression, `IS ::`, `::`, and `IS TYPED` are syntactic synonyms for the same expression. +The preferred syntax is the `IS ::` variant. + +Where `` is one of the following property types: + +* `BOOLEAN` +* `STRING` +* `INTEGER` +* `FLOAT` +* `DATE` +* `LOCAL TIME` +* `ZONED TIME` +* `LOCAL DATETIME` +* `ZONED DATETIME` +* `DURATION` +* `POINT` +* `VECTOR(DIMENSION)` label:cypher[Cypher 25 only] label:new[Introduced in Neo4j 2025.10] +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* `LIST` +* Any closed dynamic union of the above types, e.g. `INTEGER | FLOAT | STRING`. + +[NOTE] +Because storing lists of xref:values-and-types/vector.adoc[`VECTOR`] values is not supported, property type constraints cannot be created for `LIST(DIMENSION) NOT NULL>`. +Additionally, `VECTOR` property type constraints must be created with a specific dimension and coordinate value, where the dimension must be greater than `0` and less than or equal to `4096`. +For more information, see xref:values-and-types/vector.adoc[Values and types -> Vectors]. + +Allowed syntax variations of these types are listed in xref::values-and-types/property-structural-constructed.adoc#types-synonyms[Types and their synonyms]. + +For examples on how to create property type constraints, see xref:schema/constraints/create-constraints.adoc#create-property-type-constraints[Create constraints -> Create property type constraints]. + + +[role=label--enterprise-edition] +[[create-key-constraints]] +==== Create key constraints + +.Syntax for creating a node key constraint on a single property +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR (n:LabelName) +REQUIRE n.propertyName IS [NODE] KEY +---- + +.Syntax for creating a composite node key constraint on multiple properties +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR (n:LabelName) +REQUIRE (n.propertyName_1, ..., n.propertyName_n) IS [NODE] KEY +---- + +.Syntax for creating a relationship key constraint on a single property +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR ()-"["r:RELATIONSHIP_TYPE"]"-() +REQUIRE r.propertyName IS [REL[ATIONSHIP]] KEY +---- + +.Syntax for creating a composite relationship key constraint on multiple properties +[source, syntax] +---- +CREATE CONSTRAINT [constraint_name] [IF NOT EXISTS] +FOR ()-"["r:RELATIONSHIP_TYPE"]"-() +REQUIRE (r.propertyName_1, ..., r.propertyName_n) IS [REL[ATIONSHIP]] KEY +---- + +For examples on how to create key constraints, see xref:schema/constraints/create-constraints.adoc#create-key-constraints[Create constraints -> Create key constraints]. +Key constraints are xref:schema/constraints/create-constraints.adoc#constraints-and-indexes[index-backed]. + + +[[list-constraints]] +=== Show constraints + +To list all constraints with the default output columns, use `SHOW CONSTRAINTS`. +If all columns are required, use `SHOW CONSTRAINTS YIELD *`. +If only specific columns are required, use `SHOW CONSTRAINTS YIELD field[, ...]`. +The `SHOW CONSTRAINTS` clause can also be filtered using the xref:clauses/where.adoc[`WHERE`] clause. + +[NOTE] +Listing constraints requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`SHOW CONSTRAINTS` privilege]. + +.Syntax to list constraints with default return columns +[source, syntax] +---- +SHOW [ + ALL + |NODE [PROPERTY] UNIQUE[NESS] + |REL[ATIONSHIP] [PROPERTY] UNIQUE[NESS] + |[PROPERTY] UNIQUE[NESS] + |NODE [PROPERTY] EXIST[ENCE] + |REL[ATIONSHIP] [PROPERTY] EXIST[ENCE] + |[PROPERTY] EXIST[ENCE] + |NODE PROPERTY TYPE + |REL[ATIONSHIP] PROPERTY TYPE + |PROPERTY TYPE + |NODE KEY + |REL[ATIONSHIP] KEY + |KEY +] CONSTRAINT[S] + [WHERE expression] +---- + +.Syntax for listing constraints with full return columns +[source, syntax] +---- +SHOW [ + ALL + |NODE [PROPERTY] UNIQUE[NESS] + |REL[ATIONSHIP] [PROPERTY] UNIQUE[NESS] + |[PROPERTY] UNIQUE[NESS] + |NODE [PROPERTY] EXIST[ENCE] + |REL[ATIONSHIP] [PROPERTY] EXIST[ENCE] + |[PROPERTY] EXIST[ENCE] + |NODE PROPERTY TYPE + |REL[ATIONSHIP] PROPERTY TYPE + |PROPERTY TYPE + |NODE KEY + |REL[ATIONSHIP] KEY + |KEY +] CONSTRAINT[S] +YIELD { * | field[, ...] } [ORDER BY field[, ...]] [SKIP n] [LIMIT n] + [WHERE expression] + [RETURN field[, ...] [ORDER BY field[, ...]] [SKIP n] [LIMIT n]] +---- + +The type filtering keywords filters the returned constraints on constraint type: + +[[constraints-syntax-list-type-filter]] +.Type filters +[options="header", width="100%", cols="4m,6a"] +|=== +| Filter | Description + +| ALL +| Returns all constraints, no filtering on constraint type. +This is the default if none is given. + +| NODE [PROPERTY] UNIQUE[NESS] +| Returns node property uniqueness constraints. + +| REL[ATIONSHIP] [PROPERTY] UNIQUE[NESS] +| Returns relationship property uniqueness constraints. + +| [PROPERTY] UNIQUE[NESS] +| Returns property uniqueness constraints, for both nodes and relationships. + +| NODE PROPERTY EXIST[ENCE] +| Returns node property existence constraints. + +| REL[ATIONSHIP] PROPERTY EXIST[ENCE] +| Returns relationship property existence constraints. + +| PROPERTY EXIST[ENCE] +| Returns property existence constraints, for both nodes and relationships. + +| NODE EXIST[ENCE] +| Returns node existence constraints. + +| REL[ATIONSHIP] EXIST[ENCE] +| Returns relationship existence constraints. + +| EXIST[ENCE] +| Returns existence constraints, for both nodes and relationships. + +| NODE PROPERTY TYPE +| Returns node property type constraints. + +| REL[ATIONSHIP] PROPERTY TYPE +| Returns relationship property type constraints. + +| PROPERTY TYPE +| Returns property type constraints, for both nodes and relationships. + +| NODE KEY +| Returns node key constraints. + +| REL[ATIONSHIP] KEY +| Returns relationship key constraints. + +| KEY +| Returns key constraints, for both nodes and relationships. + +|=== + +For examples on how to list constraints, see xref:schema/constraints/list-constraints.adoc[Show constraints]. +For full details of the result columns for the `SHOW CONSTRAINTS` command, see xref:schema/constraints/list-constraints.adoc#list-constraints-result-columns[Show constraints -> Result columns for listing constraints]. + +[[drop-constraint]] +=== Drop constraints + +Constraints are dropped using the `DROP` CONSTRAINT` command. +Dropping a constraint is done by specifying the name of the constraint. + +[NOTE] +Dropping a constraint requires the link:{neo4j-docs-base-uri}/operations-manual/current/authentication-authorization/database-administration/#access-control-database-administration-constraints[`DROP CONSTRAINT` privilege]. + +.Syntax for dropping a constraint by name +[source, syntax] +---- +DROP CONSTRAINT constraint_name [IF EXISTS] +---- + +This command is optionally idempotent. +This means its default behavior is to throw an error if an attempt is made to drop the same constraint twice. +With the `IF EXISTS` flag, no error is thrown and nothing happens should the constraint not exist. +Instead, an informational notification is returned detailing that the constraint does not exist. + +For examples on how to drop constraints, see xref:schema/constraints/drop-constraints.adoc[Drop constraints]. \ No newline at end of file diff --git a/modules/ROOT/pages/values-and-types/property-structural-constructed.adoc b/modules/ROOT/pages/values-and-types/property-structural-constructed.adoc index 6e00a69b5..ebd1e9ec7 100644 --- a/modules/ROOT/pages/values-and-types/property-structural-constructed.adoc +++ b/modules/ROOT/pages/values-and-types/property-structural-constructed.adoc @@ -74,7 +74,7 @@ For more details, see xref::values-and-types/working-with-null.adoc[working with The table below shows the types and their syntactic synonyms. -These types (and their synonyms) can be used in xref::expressions/predicates/type-predicate-expressions.adoc[type predicate expressions] and in xref::constraints/managing-constraints.adoc#create-property-type-constraints[property type constraints]. +These types (and their synonyms) can be used in xref::expressions/predicates/type-predicate-expressions.adoc[type predicate expressions] and in xref::schema/constraints/create-constraints.adoc#create-property-type-constraints[property type constraints]. They are also returned as a `STRING` value when using the xref::functions/scalar.adoc#functions-valueType[valueType()] function. However, not all types can be used in all places. @@ -122,7 +122,7 @@ The type `PROPERTY VALUE` is expanded to a closed dynamic union of all valid pro For example, given the closed dynamic type `BOOL | LIST | BOOLEAN | LIST`, the normalized type would be: `BOOLEAN | LIST`. -This normalization is run on types used in xref::expressions/predicates/type-predicate-expressions.adoc[type predicate expressions], and in xref::constraints/managing-constraints.adoc#create-property-type-constraints[property type constraints]. +This normalization is run on types used in xref::expressions/predicates/type-predicate-expressions.adoc[type predicate expressions], and in xref::schema/constraints/create-constraints.adoc#create-property-type-constraints[property type constraints]. Type normalization is also used to ensure the consistency of the output for the xref::functions/scalar.adoc#functions-valueType[valueType()] function. [[vector-type-normalization]]