创建、显示和删除约束

本页描述如何创建、列出和删除约束。Neo4j 中提供以下约束类型

CREATE CONSTRAINT

约束使用 CREATE CONSTRAINT 命令创建。创建约束时，建议提供一个约束名称。此名称在索引和约束中都必须是唯一的。如果未明确指定名称，将自动生成一个唯一名称。

创建约束需要 CREATE CONSTRAINT 权限。
添加约束是一个原子操作，可能需要一段时间——所有现有数据都必须在 Neo4j DBMS 使用约束之前进行扫描。

创建属性唯一性约束

属性唯一性约束确保具有特定标签的所有节点或具有特定类型的所有关系的属性值都是唯一的。对于多个属性的复合属性唯一性约束，必须是属性值的组合唯一。尝试添加重复属性值的查询将失败。

属性唯一性约束不要求所有节点或关系都具有约束中列出的属性的值。只有包含约束中指定的所有属性的节点或关系才受唯一性规则约束。缺少一个或多个指定属性的节点或关系不受此规则约束。

创建单个属性唯一性约束

单个属性唯一性约束通过以下命令创建

  • 节点属性唯一性约束：CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE n.property IS UNIQUE。

  • 关系属性唯一性约束：CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS UNIQUE。 5.7 版本引入

有关创建属性唯一性约束的完整命令语法，请参阅 语法 → 创建属性唯一性约束。

示例 1. 在单个属性上创建节点属性唯一性约束
创建要求 Book 节点具有唯一 isbn 属性的约束
CREATE CONSTRAINT book_isbn
FOR (book:Book) REQUIRE book.isbn IS UNIQUE
结果
Added 1 constraint.
详细统计信息视图当前显示 Unique constraints added: 1。在未来的 Neo4j 版本中，它将更新为 Node property uniqueness constraints added: 1。
示例 2. 在单个属性上创建关系属性唯一性约束 5.7 版本引入
创建要求 SEQUEL_OF 关系具有唯一 order 属性的约束
CREATE CONSTRAINT sequels
FOR ()-[sequel:SEQUEL_OF]-() REQUIRE sequel.order IS UNIQUE
结果
Added 1 constraint.
详细统计信息视图当前显示 Relationship uniqueness constraints added: 1。在未来的 Neo4j 版本中，它将更新为 Relationship property uniqueness constraints added: 1。

创建复合属性唯一性约束

为多个属性创建的约束称为复合约束。请注意，在创建复合属性唯一性约束时，受约束的属性必须用括号括起来。

  • 节点属性唯一性约束：CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE (n.propertyName_1, …​, n.propertyName_n) IS UNIQUE。

  • 关系属性唯一性约束：CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE (r.propertyName_1, …​, r.propertyName_n) IS UNIQUE。 5.7 版本引入

有关创建属性唯一性约束的完整命令语法，请参阅 语法 → 创建属性唯一性约束。

示例 3. 在多个属性上创建复合节点属性唯一性约束
创建要求 Book 节点具有 title 和 publicationYear 属性唯一组合的约束
CREATE CONSTRAINT book_title_year
FOR (book:Book) REQUIRE (book.title, book.publicationYear) IS UNIQUE
结果
Added 1 constraint.
示例 4. 在多个属性上创建复合关系属性唯一性约束 5.7 版本引入
创建要求 PREQUEL_OF 关系具有 order 和 author 属性唯一组合的约束
CREATE CONSTRAINT prequels
FOR ()-[prequel:PREQUEL_OF]-() REQUIRE (prequel.order, prequel.author) IS UNIQUE
结果
Added 1 constraint.

创建符合现有属性唯一性约束的数据

示例 5. 创建符合现有属性唯一性约束的节点
创建具有唯一 isbn 属性的 Book 节点
CREATE (book:Book {isbn: '1449356265', title: 'Graph Databases'})
结果
Added 1 label, created 1 node, set 2 properties
示例 6. 创建符合现有属性唯一性约束的关系
创建具有唯一 order 属性的 SEQUEL_OF 关系
CREATE (:Book {title: 'Spirit Walker'})-[:SEQUEL_OF {order: 1, seriesTitle: 'Chronicles of Ancient Darkness'}]->(:Book {title: 'Wolf Brother'})
结果
Added 2 labels, created 2 nodes, set 4 properties, created 1 relationship.

创建属性存在性约束

属性存在性约束确保属性存在于具有特定标签的所有节点或具有特定类型的所有关系中。尝试创建指定标签的新节点或指定类型的新关系但缺少受约束属性的查询将失败。尝试删除强制属性的查询也同样会失败。

创建单个属性存在性约束

单属性存在性约束通过以下命令创建

  • 节点属性存在性约束：CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE n.property IS NOT NULL。

  • 关系属性存在性约束：CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS NOT NULL。

有关创建存在性约束的完整命令语法，请参阅 语法 → 创建属性存在性约束。

无法在多个属性上创建复合存在性约束。
示例 7. 创建节点属性存在性约束
创建要求 Author 节点具有 name 属性的约束
CREATE CONSTRAINT author_name
FOR (author:Author) REQUIRE author.name IS NOT NULL
结果
Added 1 constraint.
示例 8. 创建关系属性存在性约束
创建要求 WROTE 关系具有 year 属性的约束
CREATE CONSTRAINT wrote_year
FOR ()-[wrote:WROTE]-() REQUIRE wrote.year IS NOT NULL
结果
Added 1 constraint.

创建符合现有属性存在性约束的数据

示例 9. 创建符合现有节点属性存在性约束的节点
创建具有 name 属性的 Author 节点
CREATE (author:Author {name:'Virginia Woolf', surname: 'Woolf'})
结果
Added 1 label, created 1 node, set 2 properties
示例 10. 创建符合现有关系属性存在性约束的关系
创建具有 year 属性的 WROTE 关系
CREATE (author:Author {name: 'Emily Brontë', surname: 'Brontë'})-[wrote:WROTE {year: 1847, location: 'Haworth, United Kingdom', published: true}]->(book:Book {title:'Wuthering Heights', isbn: 9789186579296})
结果
Added 2 labels, created 2 nodes, set 7 properties, created 1 relationship

创建属性类型约束

属性类型约束确保属性对于具有特定标签的所有节点或具有特定类型的所有关系都具有所需的数据类型。尝试使用错误数据类型添加此属性，或以改变其数据类型的方式修改此属性（对于指定标签的节点或指定类型的关系）的查询将失败。

属性类型约束不要求所有节点或关系都具有该属性。没有受约束属性的节点或关系不受此规则约束。

创建单个属性类型约束

属性类型约束通过以下命令创建

  • 节点属性类型约束：CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE n.property IS :: <TYPE>。

  • 关系属性类型约束：CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS :: <TYPE>。

<TYPE> 指的是特定的 Cypher® 数据类型，例如 STRING 或 INTEGER。有关可用于约束属性的类型，请参阅 允许的类型，有关 Cypher 中不同数据类型的信息，请参阅 值和类型。有关创建属性类型约束的完整命令语法，请参阅 语法 → 创建属性类型约束。

无法在多个属性上创建复合属性类型约束。
示例 11. 创建节点属性类型约束
创建要求 Movie 节点上的 title 属性为 STRING 类型的约束
CREATE CONSTRAINT movie_title
FOR (movie:Movie) REQUIRE movie.title IS :: STRING
结果
Added 1 constraint.
示例 12. 创建关系属性类型约束
创建要求 PART_OF 关系上的 order 属性为 INTEGER 类型的约束
CREATE CONSTRAINT part_of
FOR ()-[part:PART_OF]-() REQUIRE part.order IS :: INTEGER
结果
Added 1 constraint.

创建具有联合类型的属性类型约束

封闭动态联合允许节点或关系属性在保持一定类型灵活性的同时，防止存储意外值。

示例 13. 创建具有联合类型的节点属性类型约束
创建要求 Movie 节点上的 tagline 属性为 STRING 类型或 LIST<STRING NOT NULL> 类型的约束
CREATE CONSTRAINT movie_tagline
FOR (movie:Movie) REQUIRE movie.tagline IS :: STRING | LIST<STRING NOT NULL>
结果
Added 1 constraint.
示例 14. 创建具有联合类型的关系属性类型约束
创建要求 PART_OF 关系上的 tags 属性为 STRING 类型或 LIST<STRING NOT NULL> 类型的约束
CREATE CONSTRAINT part_of_tags
FOR ()-[part:PART_OF]-() REQUIRE part.tags IS :: STRING | LIST<STRING NOT NULL>
结果
Added 1 constraint.

允许的类型

属性类型约束允许的属性类型有

  • BOOLEAN

  • STRING

  • INTEGER

  • FLOAT

  • DATE

  • LOCAL TIME

  • ZONED TIME

  • LOCAL DATETIME

  • ZONED DATETIME

  • DURATION

  • POINT

  • LIST<BOOLEAN NOT NULL> 5.10 版本引入

  • LIST<STRING NOT NULL> 5.10 版本引入

  • LIST<INTEGER NOT NULL> 5.10 版本引入

  • LIST<FLOAT NOT NULL> 5.10 版本引入

  • LIST<DATE NOT NULL> 5.10 版本引入

  • LIST<LOCAL TIME NOT NULL> 5.10 版本引入

  • LIST<ZONED TIME NOT NULL> 5.10 版本引入

  • LIST<LOCAL DATETIME NOT NULL> 5.10 版本引入

  • LIST<ZONED DATETIME NOT NULL> 5.10 版本引入

  • LIST<DURATION NOT NULL> 5.10 版本引入

  • LIST<POINT NOT NULL> 5.10 版本引入

  • 上述类型的任何封闭动态联合，例如 INTEGER | FLOAT | STRING。 5.11 版本引入

有关 Cypher 中所有可用类型的完整参考，请参阅 类型及其同义词 部分。

在无效类型上创建属性类型约束将失败

示例 15. 创建带有无效类型的节点属性类型约束
创建要求 Movie 节点上的 imdbScore 属性为 MAP 类型的约束
CREATE CONSTRAINT score FOR (movie:Movie) REQUIRE movie.imdbScore IS :: MAP
错误消息
Failed to create node property type constraint: Invalid property type `MAP`.

创建符合现有属性类型约束的数据

示例 16. 创建符合现有节点属性类型约束的节点
创建具有 STRING 类型 title 属性的 Movie 节点
CREATE (movie:Movie {title:'Iron Man'})
结果
Added 1 label, created 1 node, set 1 properties
示例 17. 创建符合现有关系属性类型约束的关系
创建具有 INTEGER 类型 order 属性的 PART_OF 关系
MATCH (movie:Movie {title:'Iron Man'})
CREATE (movie)-[part:PART_OF {order: 3}]->(franchise:Franchise {name:'MCU'})
结果
Added 1 label, added 1 node, created 1 relationship, set 2 properties

创建键约束

键约束确保属性存在，并且属性值对于具有特定标签的所有节点或具有特定类型的所有关系都是唯一的。对于多个属性的复合键约束，所有属性都必须存在，并且属性值的组合必须是唯一的。

尝试创建指定标签的新节点或指定类型的新关系但缺少受约束属性的查询将失败。尝试删除强制属性或添加重复属性值的查询也同样会失败。

创建单个属性键约束

单个属性键约束通过以下命令创建

  • 节点键约束：CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE n.property IS NODE KEY。

  • 关系键约束：CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE r.property IS RELATIONSHIP KEY。 5.7 版本引入

有关创建键约束的完整命令语法，请参阅 语法 → 创建键约束。

示例 18. 在单个属性上创建节点键约束
创建要求 Director 节点具有唯一 imdbId 属性作为节点键的约束。
CREATE CONSTRAINT director_imdbId
FOR (director:Director) REQUIRE (director.imdbId) IS NODE KEY
结果
Added 1 constraint.
示例 19. 在单个属性上创建关系键约束 5.7 版本引入
创建要求 OWNS 关系具有唯一 ownershipId 属性作为关系键的约束
CREATE CONSTRAINT ownershipId
FOR ()-[owns:OWNS]-() REQUIRE owns.ownershipId IS RELATIONSHIP KEY
结果
Added 1 constraint.

创建复合键约束

为多个属性创建的约束称为复合约束。请注意，在创建复合键约束时，受约束的属性必须用括号括起来。

复合键约束通过以下命令创建

  • 节点键约束：CREATE CONSTRAINT constraint_name FOR (n:Label) REQUIRE (n.propertyName_1, …​, n.propertyName_n) IS NODE KEY。

  • 关系键约束：CREATE CONSTRAINT constraint_name FOR ()-[r:REL_TYPE]-() REQUIRE (r.propertyName_1, …​, r.propertyName_n) IS RELATIONSHIP KEY。 5.7 版本引入

有关创建键约束的完整命令语法，请参阅 语法 → 创建键约束。

示例 20. 在多个属性上创建复合节点键约束
创建要求 Actor 节点具有 firstname 和 surname 属性唯一组合作为节点键的约束
CREATE CONSTRAINT actor_fullname
FOR (actor:Actor) REQUIRE (actor.firstname, actor.surname) IS NODE KEY
结果
Added 1 constraint.
示例 21. 在多个属性上创建复合关系键约束标签 5.7 版本引入
创建要求 KNOWS 关系具有 since 和 how 属性唯一组合作为关系键的约束
CREATE CONSTRAINT knows_since_how
FOR ()-[knows:KNOWS]-() REQUIRE (knows.since, knows.how) IS RELATIONSHIP KEY
结果
Added 1 constraint.

创建符合现有键约束的数据

示例 22. 创建符合现有节点键约束的节点
创建具有唯一 firstname 和 surname 属性的 Actor 节点
CREATE (actor:Actor {firstname: 'Keanu', surname: 'Reeves'})
结果
Added 1 label, created 1 node, set 2 properties.
示例 23. 创建符合现有关系键约束的关系
创建具有唯一 since 和 how 属性的 KNOWS 关系
CREATE (:Actor {firstname: 'Jensen', surname: 'Ackles'})-[:KNOWS {since: 2008, how: 'coworkers', friend: true}]->(:Actor {firstname: 'Misha', surname: 'Collins'})
结果
Added 2 labels, created 2 nodes, set 7 properties, created 1 relationship.

使用参数创建约束

所有约束类型都可以使用参数化名称创建。

示例 24. 使用参数创建节点属性唯一性约束
参数
{
  "name": "node_uniqueness_param"
}
创建具有参数化名称的节点属性唯一性约束
CREATE CONSTRAINT $name
FOR (book:Book) REQUIRE book.prop1 IS UNIQUE
结果
Added 1 constraint.
示例 25. 使用参数创建关系属性存在性约束
参数
{
  "name": "rel_exist_param"
}
创建具有参数化名称的关系属性存在性约束
CREATE CONSTRAINT $name
FOR ()-[wrote:WROTE]-() REQUIRE wrote.published IS NOT NULL
结果
Added 1 constraint.

处理多个约束

创建已存在的约束将失败。这包括以下情况

  • 创建与已存在约束相同的约束。

  • 创建具有不同名称但与已存在约束具有相同约束类型、相同标签/关系类型和属性组合的约束。对于属性类型约束，属性类型也需要相同。

  • 创建与已存在约束同名的约束，无论该约束是什么类型。

此外，某些约束不能共存，尝试一起创建它们也将失败。这包括

  • 在相同标签/关系类型和属性上但具有不同属性类型的属性类型约束。

  • 在相同标签/关系类型和属性组合上的属性唯一性约束和键约束。

然而，某些约束类型允许在相同标签/关系类型和属性组合上共存。例如，可以在相同标签/关系类型和属性组合上同时拥有属性唯一性约束和属性存在性约束，尽管这等同于拥有节点或关系键约束。一个更有用的例子是将属性类型约束和属性存在性约束结合起来，以确保属性存在并具有给定类型。

创建约束时处理现有约束

为避免因现有约束而失败，可以在 CREATE 命令中添加 IF NOT EXISTS。这将确保如果具有给定名称的任何其他约束，或相同约束类型和模式上的另一个约束，或两者都已存在，则不会抛出错误，也不会创建任何约束。对于属性类型约束，属性类型也需要相同。从 Neo4j 5.17 开始，将返回一条信息性通知，显示阻止创建的现有约束。

示例 26. 创建与现有约束相同的约束
创建要求所有 SEQUEL_OF 关系具有唯一 order 属性的约束
CREATE CONSTRAINT sequels IF NOT EXISTS
FOR ()-[sequel:SEQUEL_OF]-() REQUIRE sequel.order IS UNIQUE

由于已存在相同的约束，因此不会发生任何事情

结果
(no changes, no records)
通知
`CREATE CONSTRAINT sequels IF NOT EXISTS FOR ()-[e:SEQUEL_OF]-() REQUIRE (e.order) IS UNIQUE` has no effect.
`CONSTRAINT sequels FOR ()-[e:SEQUEL_OF]-() REQUIRE (e.order) IS UNIQUE` already exists.
示例 27. 当已存在具有不同名称的相同约束时，创建关系属性唯一性约束
创建要求所有 SEQUEL_OF 关系具有唯一 order 属性的约束
CREATE CONSTRAINT new_sequels IF NOT EXISTS
FOR ()-[sequel:SEQUEL_OF]-() REQUIRE sequel.order IS UNIQUE

由于在相同模式上已存在具有不同名称 (sequels) 的约束，因此不会发生任何事情

结果
(no changes, no records)
通知
`CREATE CONSTRAINT new_sequels IF NOT EXISTS FOR ()-[e:SEQUEL_OF]-() REQUIRE (e.order) IS UNIQUE` has no effect.
`CONSTRAINT sequels FOR ()-[e:SEQUEL_OF]-() REQUIRE (e.order) IS UNIQUE` already exists.
示例 28. 创建与不同类型的现有约束同名的关系属性唯一性约束
创建要求所有 AUTHORED 关系具有唯一 name 属性的约束
CREATE CONSTRAINT author_name IF NOT EXISTS
FOR ()-[a:AUTHORED]-() REQUIRE a.name IS UNIQUE

由于已存在名为 author_name 的节点属性存在性约束，因此不会发生任何事情

结果
(no changes, no records)
通知
`CREATE CONSTRAINT author_name IF NOT EXISTS FOR ()-[e:AUTHORED]-() REQUIRE (e.name) IS UNIQUE` has no effect.
`CONSTRAINT author_name FOR (e:Author) REQUIRE (e.name) IS NOT NULL` already exists.

创建已存在的约束将失败

创建与现有约束同名，或在相同节点标签或关系类型和属性上（这些属性已被同类型约束限制）的约束将失败。属性唯一性约束和键约束也不允许在相同模式上共存。

示例 29. 创建与现有约束相同的约束
创建要求所有 SEQUEL_OF 关系具有唯一 order 属性的约束，前提是已存在相同的约束
CREATE CONSTRAINT sequels
FOR ()-[sequel:SEQUEL_OF]-() REQUIRE sequel.order IS UNIQUE
错误消息
An equivalent constraint already exists, 'Constraint( id=5, name='sequels', type='RELATIONSHIP UNIQUENESS', schema=()-[:SEQUEL_OF {order}]-(), ownedIndex=4 )'.
在未来的 Neo4j 版本中，约束类型将更新为 RELATIONSHIP PROPERTY UNIQUENESS。
示例 30. 创建具有不同名称但在相同模式上与现有约束相同的约束
创建要求所有 Book 节点具有唯一 isbn 属性的约束，前提是该模式上已存在一个约束
CREATE CONSTRAINT new_book_isbn
FOR (book:Book) REQUIRE book.isbn IS UNIQUE
错误消息
Constraint already exists: Constraint( id=3, name='book_isbn', type='UNIQUENESS', schema=(:Book {isbn}), ownedIndex=2 )
在未来的 Neo4j 版本中，约束类型将更新为 NODE PROPERTY UNIQUENESS。
示例 31. 创建具有相同名称但与现有约束模式不同的约束
创建要求所有 AUTHORED 关系具有唯一 name 属性的约束，前提是已存在具有相同名称但模式不同的约束
CREATE CONSTRAINT author_name
FOR ()-[a:AUTHORED]-() REQUIRE a.name IS UNIQUE
错误消息
There already exists a constraint called 'author_name'.
示例 32. 当已存在将属性约束为不同类型的属性类型约束时，在属性上创建属性类型约束
创建要求 PART_OF 关系上的 order 属性为 FLOAT 类型的约束，前提是已存在要求相同属性为 INTEGER 类型的约束
CREATE CONSTRAINT new_part_of
FOR ()-[part:PART_OF]-() REQUIRE part.order IS :: FLOAT
错误消息
Conflicting constraint already exists: Constraint( id=21, name='part_of', type='RELATIONSHIP PROPERTY TYPE', schema=()-[:PART_OF {order}]-(), propertyType=INTEGER )
示例 33. 在与现有属性唯一性约束相同的模式上创建节点键约束
当已在相同标签和属性组合上存在属性唯一性约束时，在 Book 标签节点的 title 和 publicationYear 属性上创建节点键约束
CREATE CONSTRAINT book_titles FOR (book:Book) REQUIRE (book.title, book.publicationYear) IS NODE KEY
错误消息
Constraint already exists: Constraint( id=7, name='book_title_year', type='UNIQUENESS', schema=(:Book {title, publicationYear}), ownedIndex=6 )

约束和索引

约束和支持索引

属性唯一性约束和键约束由 范围索引 支持。这意味着创建属性唯一性或键约束将创建一个与其所属约束具有相同名称、节点标签/关系类型和属性组合的范围索引。单个属性约束将创建单个属性索引，多个属性复合约束将创建 复合索引。

相同索引类型、标签/关系类型和属性组合的索引不能单独添加。然而，删除属性唯一性或键约束也将删除其支持索引。如果仍然需要支持索引，则需要明确重新创建索引。

属性唯一性约束和键约束需要索引，因为它允许系统快速检查是否已存在具有相同标签和属性值的节点或具有相同类型和属性值的关系。如果没有索引，系统将需要扫描所有具有相同标签的节点，这将非常缓慢且低效，尤其随着图的增长。索引通过启用直接查找而不是扫描整个图来使这些检查快得多。Cypher 将以与利用其他搜索性能索引相同的方式使用具有所属约束的索引。有关索引如何影响查询性能的更多信息，请参阅 索引对查询性能的影响。

这些索引列在 SHOW INDEX 命令返回的 owningConstraint 列中，以及 SHOW CONSTRAINT 命令返回的 ownedIndex 列中。

示例 34. 列出具有支持索引的约束
查询
SHOW CONSTRAINTS WHERE ownedIndex IS NOT NULL
结果
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| id | name                    | type                      | entityType     | labelsOrTypes  | properties                   | ownedIndex              | propertyType |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 21 | "actor_fullname"        | "NODE_KEY"                | "NODE"         | ["Actor"]      | ["firstname", "surname"]     | "actor_fullname"        | NULL         |
| 3  | "book_isbn"             | "UNIQUENESS"              | "NODE"         | ["Book"]       | ["isbn"]                     | "book_isbn"             | NULL         |
| 7  | "book_title_year"       | "UNIQUENESS"              | "NODE"         | ["Book"]       | ["title", "publicationYear"] | "book_title_year"       | 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         |
| 25 | "node_uniqueness_param" | "UNIQUENESS"              | "NODE"         | ["Book"]       | ["prop1"]                    | "node_uniqueness_param" | NULL         |
| 19 | "ownershipId"           | "RELATIONSHIP_KEY"        | "RELATIONSHIP" | ["OWNS"]       | ["ownershipId"]              | "ownershipId"           | NULL         |
| 9  | "prequels"              | "RELATIONSHIP_UNIQUENESS" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"]          | "prequels"              | NULL         |
| 5  | "sequels"               | "RELATIONSHIP_UNIQUENESS" | "RELATIONSHIP" | ["SEQUEL_OF"]  | ["order"]                    | "sequels"               | NULL         |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
示例 35. 列出具有所属约束的索引
查询
SHOW INDEXES WHERE owningConstraint IS NOT NULL
结果
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| id | name                    | state    | populationPercent | type    | entityType     | labelsOrTypes  | properties                   | indexProvider | owningConstraint        | lastRead                 | readCount |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 20 | "actor_fullname"        | "ONLINE" | 100.0             | "RANGE" | "NODE"         | ["Actor"]      | ["firstname", "surname"]     | "range-1.0"   | "actor_fullname"        | 2024-10-07T12:12:51.893Z | 3         |
| 2  | "book_isbn"             | "ONLINE" | 100.0             | "RANGE" | "NODE"         | ["Book"]       | ["isbn"]                     | "range-1.0"   | "book_isbn"             | 2024-10-07T11:58:09.252Z | 2         |
| 6  | "book_title_year"       | "ONLINE" | 100.0             | "RANGE" | "NODE"         | ["Book"]       | ["title", "publicationYear"] | "range-1.0"   | "book_title_year"       | NULL                     | 0         |
| 16 | "director_imdbId"       | "ONLINE" | 100.0             | "RANGE" | "NODE"         | ["Director"]   | ["imdbId"]                   | "range-1.0"   | "director_imdbId"       | NULL                     | 0         |
| 22 | "knows_since_how"       | "ONLINE" | 100.0             | "RANGE" | "RELATIONSHIP" | ["KNOWS"]      | ["since", "how"]             | "range-1.0"   | "knows_since_how"       | 2024-10-07T12:12:51.894Z | 1         |
| 24 | "node_uniqueness_param" | "ONLINE" | 100.0             | "RANGE" | "NODE"         | ["Book"]       | ["prop1"]                    | "range-1.0"   | "node_uniqueness_param" | NULL                     | 0         |
| 18 | "ownershipId"           | "ONLINE" | 100.0             | "RANGE" | "RELATIONSHIP" | ["OWNS"]       | ["ownershipId"]              | "range-1.0"   | "ownershipId"           | NULL                     | 0         |
| 8  | "prequels"              | "ONLINE" | 100.0             | "RANGE" | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"]          | "range-1.0"   | "prequels"              | NULL                     | 0         |
| 4  | "sequels"               | "ONLINE" | 100.0             | "RANGE" | "RELATIONSHIP" | ["SEQUEL_OF"]  | ["order"]                    | "range-1.0"   | "sequels"               | 2024-10-07T11:57:12.999Z | 1         |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
属性存在性约束和属性类型约束不受索引支持。

约束失败和索引

尝试创建与现有索引同名的任何类型约束将失败。

示例 36. 创建与现有索引同名的节点属性类型约束
创建名为 directors 的索引
CREATE INDEX directors FOR (director:Director) ON (director.name)
创建名为 directors 的节点属性类型约束
CREATE CONSTRAINT directors FOR (movie:Movie) REQUIRE movie.director IS :: STRING
错误消息
There already exists an index called 'directors'.

在与现有索引相同的模式上创建键或属性唯一性约束将失败。

示例 37. 在与现有索引相同的模式上创建节点属性唯一性约束
为 Book 节点上的 wordCount 属性创建索引
CREATE INDEX book_word_count FOR (book:Book) ON (book.wordCount)
创建要求所有 Book 节点具有唯一 wordCount 属性的约束
CREATE CONSTRAINT word_count FOR (book:Book) REQUIRE book.wordCount IS UNIQUE
错误消息
There already exists an index (:Book {wordCount}).
A constraint cannot be created until the index has been dropped.

约束和数据违规场景

创建违反现有约束的数据将失败

表 1. 阻止数据创建的现有约束
约束类型 创建缺少存在性约束属性的节点和关系 创建具有非唯一属性/属性组合的节点和关系 创建具有错误属性类型的节点和关系

属性唯一性约束

❌

属性存在性约束

❌

属性类型约束

❌

键约束

❌

❌
示例 38. 创建违反节点属性唯一性约束的节点
创建具有已存在 isbn 属性的 Book 节点
CREATE (book:Book {isbn: '1449356265', title: 'Graph Databases'})
错误消息
Node(0) already exists with label `Book` and property `isbn` = '1449356265'
示例 39. 创建违反现有节点属性存在性约束的节点
创建缺少 name 属性的 Author 节点，前提是存在 :Author(name) 的属性存在性约束
CREATE (author:Author {surname: 'Austen'})
错误消息
Node(0) with label `Author` must have the property `name`
示例 40. 创建违反现有关系属性类型约束的关系
创建具有 STRING 类型 order 属性的 PART_OF 关系，前提是在关系类型 PART_OF 上存在将 order 属性限制为 INTEGER 值的属性类型约束
MATCH (movie:Movie {title:'Iron Man'}), (franchise:Franchise {name:'MCU'})
CREATE (movie)-[part:PART_OF {order: '1'}]->(franchise)
错误消息
Relationship(0) with type `PART_OF` has property `order` of wrong type `String`. Allowed types: INTEGER
示例 41. 创建违反现有节点键约束的节点
创建缺少 firstname 属性的 Actor 节点，前提是存在 :Actor(firstname, surname) 的节点键约束
CREATE (actor:Actor {surname: 'Wood'})
错误消息
Node(0) with label `Actor` must have the properties (`firstname`, `surname`)

删除存在性和键约束的属性将失败

示例 42. 删除节点属性存在性约束的属性
从现有 Author 节点中删除 name 属性，前提是存在 :Author(name) 的属性存在性约束
MATCH (author:Author {name: 'Virginia Woolf'})
REMOVE author.name
错误消息
Node(0) with label `Author` must have the property `name`
示例 43. 删除节点键约束的属性
从现有 Actor 节点中删除 firstname 属性，前提是存在 :Actor(firstname, surname) 的节点键约束
MATCH (actor:Actor {firstname: 'Keanu', surname: 'Reeves'})
REMOVE actor.firstname
错误消息
Node(0) with label `Actor` must have the properties (`firstname`, `surname`)

修改类型约束的属性将失败

示例 44. 修改类型约束的属性
将电影“钢铁侠”的 title 修改为 INTEGER 值，前提是存在要求 title 属性为 STRING 类型的约束
MATCH (m:Movie {title: 'Iron Man'})
SET m.title = 13
错误消息
Node(9) with label `Movie` required the property `title` to be of type `STRING`, but was of type `INTEGER`.

当存在冲突数据时创建约束将失败

表 2. 阻止创建约束的现有数据
约束类型 不存在的属性 非唯一的属性/属性组合 类型错误的属性

属性唯一性约束

❌

属性存在性约束

❌

属性类型约束

❌

键约束

❌

❌
示例 45. 当存在冲突节点时创建节点属性唯一性约束
创建两个具有相同 name 属性值的 Book 节点
CREATE (:Book {isbn: '9780393972832', title: 'Moby Dick'}),
       (:Book {isbn: '9780763630188', title: 'Moby Dick'})
创建要求 Book 节点具有唯一 title 属性的约束，前提是已存在两个具有相同 title 的 Book 节点
CREATE CONSTRAINT book_title FOR (book:Book) REQUIRE book.title IS UNIQUE

在这种情况下，无法创建约束，因为它与现有图冲突。可以改用 索引，或者删除/更正冲突节点，然后重新应用约束。

错误消息
Unable to create Constraint( name='book_title', type='UNIQUENESS', schema=(:Book {title}) ):
Both Node(0) and Node(1) have the label `Book` and property `title` = 'Moby Dick'

约束创建会在找到第一个冲突节点时失败。这不保证图中没有其他冲突节点。因此，在重新尝试创建约束之前，应检查并清理所有数据。

查找上述约束中所有具有非唯一属性值的冲突节点
MATCH (book1:Book), (book2:Book)
WHERE book1.title = book2.title AND NOT book1 = book2
RETURN book1, book2
示例 46. 当存在冲突关系时创建关系属性存在性约束
创建要求所有 WROTE 关系具有 language 属性的约束，前提是已存在一个缺少 language 属性的 WROTE 关系
CREATE CONSTRAINT wrote_language FOR ()-[wrote:WROTE]-() REQUIRE wrote.language IS NOT NULL

在这种情况下，无法创建约束，因为它与现有图冲突。删除或更正冲突关系，然后重新应用约束。

错误消息
Unable to create Constraint( type='RELATIONSHIP PROPERTY EXISTENCE', schema=()-[:WROTE {language}]-() ):
Relationship(0) with type `WROTE` must have the property `language`. Note that only the first found violation is shown.

约束创建会在找到第一个冲突关系时失败。这不保证图中没有其他冲突关系。因此，在重新尝试创建约束之前，应检查并清理所有数据。

查找上述约束中所有缺少该属性的冲突关系
MATCH ()-[wrote:WROTE]-()
WHERE wrote.language IS NULL
RETURN wrote
表 3. 用于查找阻止创建特定约束的属性的通用 MATCH 查询
约束 查询

节点属性唯一性约束

 
MATCH (n1:Label), (n2:Label)
WHERE n1.prop = n2.prop AND NOT n1 = n2
RETURN n1, n2

关系属性唯一性约束

 
MATCH ()-[r1:REL_TYPE]->(), ()-[r2:REL_TYPE]->()
WHERE r1.prop = r2.prop AND NOT r1 = r2
RETURN r1, r2

节点属性存在性约束

 
MATCH (n:Label)
WHERE n.prop IS NULL
RETURN n

关系属性存在性约束

 
MATCH ()-[r:REL_TYPE]->()
WHERE r.prop IS NULL
RETURN r

节点属性类型约束

 
MATCH (n:Label)
WHERE n.prop IS NOT :: <TYPE>
RETURN n

关系属性类型约束

 
MATCH ()-[r:REL_TYPE]->()
WHERE r.prop IS NOT :: <TYPE>
RETURN r

节点键约束

 
MATCH (n1:Label), (n2:Label)
WHERE n1.prop = n2.prop AND NOT n1 = n2
UNWIND [n1, n2] AS node
RETURN node, 'non-unique' AS reason
UNION
MATCH (n:Label)
WHERE n.prop IS NULL
RETURN n AS node, 'non-existing' AS reason

关系键约束

 
MATCH ()-[r1:REL_TYPE]->(), ()-[r2:REL_TYPE]->()
WHERE r1.prop = r2.prop AND NOT r1 = r2
UNWIND [r1, r2] AS relationship
RETURN relationship, 'non-unique' AS reason
UNION
MATCH ()-[r:REL_TYPE]->()
WHERE r.prop IS NULL
RETURN r AS relationship, 'non-existing' AS reason

SHOW CONSTRAINTS

要列出所有约束及其默认输出列，请使用 SHOW CONSTRAINTS。如果需要所有列，请使用 SHOW CONSTRAINTS YIELD *。有关列出约束的完整命令语法，请参阅 语法 → SHOW CONSTRAINTS。

SHOW CONSTRAINTS 的输出列之一是约束的名称。这可用于使用 DROP CONSTRAINT 命令 删除约束。

列出约束需要 SHOW CONSTRAINTS 权限。
示例 47. 列出所有约束及其默认输出列
查询
SHOW CONSTRAINTS
结果
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| id | name                          | type                              | entityType     | labelsOrTypes  | properties                         | ownedIndex                    | propertyType                     |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 21 | "actor_fullname"              | "NODE_KEY"                        | "NODE"         | ["Actor"]      | ["firstname", "surname"]           | "actor_fullname"              | NULL                             |
| 10 | "author_name"                 | "NODE_PROPERTY_EXISTENCE"         | "NODE"         | ["Author"]     | ["name"]                           | NULL                          | NULL                             |
| 3  | "book_isbn"                   | "UNIQUENESS"                      | "NODE"         | ["Book"]       | ["isbn"]                           | "book_isbn"                   | NULL                             |
| 7  | "book_title_year"             | "UNIQUENESS"                      | "NODE"         | ["Book"]       | ["title", "publicationYear"]       | "book_title_year"             | 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                             |
| 14 | "movie_tagline"               | "NODE_PROPERTY_TYPE"              | "NODE"         | ["Movie"]      | ["tagline"]                        | NULL                          | "STRING | LIST<STRING NOT NULL>" |
| 12 | "movie_title"                 | "NODE_PROPERTY_TYPE"              | "NODE"         | ["Movie"]      | ["title"]                          | NULL                          | "STRING"                         |
| 25 | "node_uniqueness_param"       | "UNIQUENESS"                      | "NODE"         | ["Book"]       | ["prop1"]                          | "node_uniqueness_param"       | NULL                             |
| 19 | "ownershipId"                 | "RELATIONSHIP_KEY"                | "RELATIONSHIP" | ["OWNS"]       | ["ownershipId"]                    | "ownershipId"                 | NULL                             |
| 13 | "part_of"                     | "RELATIONSHIP_PROPERTY_TYPE"      | "RELATIONSHIP" | ["PART_OF"]    | ["order"]                          | NULL                          | "INTEGER"                        |
| 15 | "part_of_tags"                | "RELATIONSHIP_PROPERTY_TYPE"      | "RELATIONSHIP" | ["PART_OF"]    | ["tags"]                           | NULL                          | "STRING | LIST<STRING NOT NULL>" |
| 9  | "prequels"                    | "RELATIONSHIP_UNIQUENESS"         | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"]                | "prequels"                    | NULL                             |
| 26 | "rel_exist_param"             | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"]      | ["published"]                      | NULL                          | NULL                             |
| 5  | "sequels"                     | "RELATIONSHIP_UNIQUENESS"         | "RELATIONSHIP" | ["SEQUEL_OF"]  | ["order"]                          | "sequels"                     | NULL                             |
| 11 | "wrote_year"                  | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"]      | ["year"]                           | NULL                          | NULL                             |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
示例 48. 列出所有约束的完整详细信息

要返回数据库上约束的完整详细信息，请使用 SHOW CONSTRAINTS YIELD *

使用 YIELD * 列出所有约束
SHOW CONSTRAINTS YIELD *
结果
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| id | name                          | type                              | entityType     | labelsOrTypes  | properties                         | ownedIndex                    | propertyType                     | options                                       | createStatement                                                                                                                        |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 21 | "actor_fullname"              | "NODE_KEY"                        | "NODE"         | ["Actor"]      | ["firstname", "surname"]           | "actor_fullname"              | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `actor_fullname` FOR (n:`Actor`) REQUIRE (n.`firstname`, n.`surname`) IS NODE KEY"                                  |
| 10 | "author_name"                 | "NODE_PROPERTY_EXISTENCE"         | "NODE"         | ["Author"]     | ["name"]                           | NULL                          | NULL                             | NULL                                          | "CREATE CONSTRAINT `author_name` FOR (n:`Author`) REQUIRE (n.`name`) IS NOT NULL"                                                      |
| 3  | "book_isbn"                   | "UNIQUENESS"                      | "NODE"         | ["Book"]       | ["isbn"]                           | "book_isbn"                   | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `book_isbn` FOR (n:`Book`) REQUIRE (n.`isbn`) IS UNIQUE"                                                            |
| 7  | "book_title_year"             | "UNIQUENESS"                      | "NODE"         | ["Book"]       | ["title", "publicationYear"]       | "book_title_year"             | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `book_title_year` FOR (n:`Book`) REQUIRE (n.`title`, n.`publicationYear`) IS UNIQUE"                                |
| 17 | "director_imdbId"             | "NODE_KEY"                        | "NODE"         | ["Director"]   | ["imdbId"]                         | "director_imdbId"             | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `director_imdbId` FOR (n:`Director`) REQUIRE (n.`imdbId`) IS NODE KEY"                                              |
| 23 | "knows_since_how"             | "RELATIONSHIP_KEY"                | "RELATIONSHIP" | ["KNOWS"]      | ["since", "how"]                   | "knows_since_how"             | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `knows_since_how` FOR ()-[r:`KNOWS`]-() REQUIRE (r.`since`, r.`how`) IS RELATIONSHIP KEY"                           |
| 14 | "movie_tagline"               | "NODE_PROPERTY_TYPE"              | "NODE"         | ["Movie"]      | ["tagline"]                        | NULL                          | "STRING | LIST<STRING NOT NULL>" | NULL                                          | "CREATE CONSTRAINT `movie_tagline` FOR (n:`Movie`) REQUIRE (n.`tagline`) IS :: STRING | LIST<STRING NOT NULL>"                         |
| 12 | "movie_title"                 | "NODE_PROPERTY_TYPE"              | "NODE"         | ["Movie"]      | ["title"]                          | NULL                          | "STRING"                         | NULL                                          | "CREATE CONSTRAINT `movie_title` FOR (n:`Movie`) REQUIRE (n.`title`) IS :: STRING"                                                     |
| 25 | "node_uniqueness_param"       | "UNIQUENESS"                      | "NODE"         | ["Book"]       | ["prop1"]                          | "node_uniqueness_param"       | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `node_uniqueness_param` FOR (n:`Book`) REQUIRE (n.`prop1`) IS UNIQUE"                                               |
| 19 | "ownershipId"                 | "RELATIONSHIP_KEY"                | "RELATIONSHIP" | ["OWNS"]       | ["ownershipId"]                    | "ownershipId"                 | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `ownershipId` FOR ()-[r:`OWNS`]-() REQUIRE (r.`ownershipId`) IS RELATIONSHIP KEY"                                   |
| 13 | "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"                                                |
| 15 | "part_of_tags"                | "RELATIONSHIP_PROPERTY_TYPE"      | "RELATIONSHIP" | ["PART_OF"]    | ["tags"]                           | NULL                          | "STRING | LIST<STRING NOT NULL>" | NULL                                          | "CREATE CONSTRAINT `part_of_tags` FOR ()-[r:`PART_OF`]-() REQUIRE (r.`tags`) IS :: STRING | LIST<STRING NOT NULL>"                     |
| 9  | "prequels"                    | "RELATIONSHIP_UNIQUENESS"         | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"]                | "prequels"                    | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `prequels` FOR ()-[r:`PREQUEL_OF`]-() REQUIRE (r.`order`, r.`author`) IS UNIQUE"                                    |
| 26 | "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"                                        |
| 5  | "sequels"                     | "RELATIONSHIP_UNIQUENESS"         | "RELATIONSHIP" | ["SEQUEL_OF"]  | ["order"]                          | "sequels"                     | NULL                             | {indexConfig: {}, indexProvider: "range-1.0"} | "CREATE CONSTRAINT `sequels` FOR ()-[r:`SEQUEL_OF`]-() REQUIRE (r.`order`) IS UNIQUE"                                                  |
| 11 | "wrote_year"                  | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"]      | ["year"]                           | NULL                          | NULL                             | NULL                                          | "CREATE CONSTRAINT `wrote_year` FOR ()-[r:`WROTE`]-() REQUIRE (r.`year`) IS NOT NULL"                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
type 列为节点属性唯一性约束返回 UNIQUENESS，为关系属性唯一性约束返回 RELATIONSHIP_UNIQUENESS。这将在 Neo4j 的未来版本中更新。节点属性唯一性约束将更新为 NODE_PROPERTY_UNIQUENESS，关系属性唯一性约束将更新为 RELATIONSHIP_PROPERTY_UNIQUENESS。

过滤约束

SHOW CONSTRAINTS 命令可以通过多种方式进行过滤。行的过滤可以使用约束类型关键字或 WHERE 子句完成，而列的过滤则通过在 YIELD 子句中指定所需列来实现。

示例 49. 仅列出特定约束类型
仅列出键约束
SHOW KEY CONSTRAINTS
结果
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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         |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------+

有关此命令中所有可用约束类型（和同义词）的完整列表，请参阅 语法 → SHOW CONSTRAINTS。

示例 50. 使用 WHERE 子句过滤约束
仅列出 entityType 为 RELATIONSHIP 的约束
SHOW CONSTRAINTS
WHERE entityType = 'RELATIONSHIP'
结果
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| id | name                          | type                              | entityType     | labelsOrTypes  | properties                         | ownedIndex                    | propertyType                     |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 23 | "knows_since_how"             | "RELATIONSHIP_KEY"                | "RELATIONSHIP" | ["KNOWS"]      | ["since", "how"]                   | "knows_since_how"             | NULL                             |
| 19 | "ownershipId"                 | "RELATIONSHIP_KEY"                | "RELATIONSHIP" | ["OWNS"]       | ["ownershipId"]                    | "ownershipId"                 | NULL                             |
| 13 | "part_of"                     | "RELATIONSHIP_PROPERTY_TYPE"      | "RELATIONSHIP" | ["PART_OF"]    | ["order"]                          | NULL                          | "INTEGER"                        |
| 15 | "part_of_tags"                | "RELATIONSHIP_PROPERTY_TYPE"      | "RELATIONSHIP" | ["PART_OF"]    | ["tags"]                           | NULL                          | "STRING | LIST<STRING NOT NULL>" |
| 9  | "prequels"                    | "RELATIONSHIP_UNIQUENESS"         | "RELATIONSHIP" | ["PREQUEL_OF"] | ["order", "author"]                | "prequels"                    | NULL                             |
| 26 | "rel_exist_param"             | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"]      | ["published"]                      | NULL                          | NULL                             |
| 5  | "sequels"                     | "RELATIONSHIP_UNIQUENESS"         | "RELATIONSHIP" | ["SEQUEL_OF"]  | ["order"]                          | "sequels"                     | NULL                             |
| 11 | "wrote_year"                  | "RELATIONSHIP_PROPERTY_EXISTENCE" | "RELATIONSHIP" | ["WROTE"]      | ["year"]                           | NULL                          | NULL                             |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
示例 51. 返回所有约束的特定列

可以使用 YIELD 子句仅返回可用约束的特定列

仅列出 name、type 和 createStatement 列
SHOW CONSTRAINTS
YIELD name, type, createStatement
结果
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| name                          | type                              | createStatement                                                                                                                        |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| "actor_fullname"              | "NODE_KEY"                        | "CREATE CONSTRAINT `actor_fullname` FOR (n:`Actor`) REQUIRE (n.`firstname`, n.`surname`) IS NODE KEY"                                  |
| "author_name"                 | "NODE_PROPERTY_EXISTENCE"         | "CREATE CONSTRAINT `author_name` FOR (n:`Author`) REQUIRE (n.`name`) IS NOT NULL"                                                      |
| "book_isbn"                   | "UNIQUENESS"                      | "CREATE CONSTRAINT `book_isbn` FOR (n:`Book`) REQUIRE (n.`isbn`) IS UNIQUE"                                                            |
| "book_title_year"             | "UNIQUENESS"                      | "CREATE CONSTRAINT `book_title_year` FOR (n:`Book`) REQUIRE (n.`title`, n.`publicationYear`) IS UNIQUE"                                |
| "constraint_with_provider"    | "NODE_KEY"                        | "CREATE CONSTRAINT `constraint_with_provider` FOR (n:`Actor`) REQUIRE (n.`surname`) IS NODE KEY"                                       |
| "director_imdbId"             | "NODE_KEY"                        | "CREATE CONSTRAINT `director_imdbId` FOR (n:`Director`) REQUIRE (n.`imdbId`) IS NODE KEY"                                              |
| "knows_since_how"             | "RELATIONSHIP_KEY"                | "CREATE CONSTRAINT `knows_since_how` FOR ()-[r:`KNOWS`]-() REQUIRE (r.`since`, r.`how`) IS RELATIONSHIP KEY"                           |
| "movie_tagline"               | "NODE_PROPERTY_TYPE"              | "CREATE CONSTRAINT `movie_tagline` FOR (n:`Movie`) REQUIRE (n.`tagline`) IS :: STRING | LIST<STRING NOT NULL>"                         |
| "movie_title"                 | "NODE_PROPERTY_TYPE"              | "CREATE CONSTRAINT `movie_title` FOR (n:`Movie`) REQUIRE (n.`title`) IS :: STRING"                                                     |
| "node_uniqueness_param"       | "UNIQUENESS"                      | "CREATE CONSTRAINT `node_uniqueness_param` FOR (n:`Book`) REQUIRE (n.`prop1`) IS UNIQUE"                                               |
| "ownershipId"                 | "RELATIONSHIP_KEY"                | "CREATE CONSTRAINT `ownershipId` FOR ()-[r:`OWNS`]-() REQUIRE (r.`ownershipId`) IS RELATIONSHIP 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<STRING NOT NULL>"                     |
| "prequels"                    | "RELATIONSHIP_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"                                        |
| "sequels"                     | "RELATIONSHIP_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"                                                  |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

列出约束的结果列

表 4. 列出约束的输出
列 描述 类型

id

约束的 ID。默认输出

INTEGER

name

约束的名称（由用户显式设置或自动分配）。默认输出

STRING

type

此约束的 ConstraintType（UNIQUENESS（节点唯一性）、RELATIONSHIP_UNIQUENESS、NODE_PROPERTY_EXISTENCE、RELATIONSHIP_PROPERTY_EXISTENCE、NODE_PROPERTY_TYPE、RELATIONSHIP_PROPERTY_TYPE、NODE_KEY 或 RELATIONSHIP_KEY）。默认输出

UNIQUENESS 和 RELATIONSHIP_UNIQUENESS 在 Neo4j 的未来版本中将分别更新为 NODE_PROPERTY_UNIQUENESS 和 RELATIONSHIP_PROPERTY_UNIQUENESS。

STRING

entityType

此约束表示的实体类型（NODE 或 RELATIONSHIP）。默认输出

STRING

labelsOrTypes

此约束的标签或关系类型。返回的列表将只包含一个值（受约束的节点标签或关系类型的名称）。默认输出

LIST<STRING>

properties

此约束的属性。默认输出

LIST<STRING>

ownedIndex

与约束关联的索引名称，如果未关联索引则为 null。默认输出

STRING

propertyType

对于属性类型约束，属性被限制为的属性类型，对于其他约束则为 null。默认输出 5.9 版本引入

STRING

options

传递给 CREATE 命令的选项，用于与约束关联的索引，如果未与约束关联任何索引则为 null。

MAP

createStatement

用于创建约束的语句。

STRING

DROP CONSTRAINT

约束使用 DROP CONSTRAINT 命令删除。有关删除约束的完整命令语法，请参阅 语法 → DROP CONSTRAINT。

删除约束需要 DROP CONSTRAINT 权限。

按名称删除约束

可以使用 DROP CONSTRAINT constraint_name 命令按名称删除约束。这对于所有约束类型都是相同的命令。约束的名称可以通过 SHOW CONSTRAINTS 命令 的 name 输出列找到。

示例 52. 按名称删除约束
删除约束 book_isbn
DROP CONSTRAINT book_isbn
结果
Removed 1 constraint.

使用参数删除约束

约束可以使用参数化名称删除。

示例 53. 使用参数删除约束
参数
{
  "name": "actor_fullname"
}
删除具有参数化名称的约束
DROP CONSTRAINT $name
结果
Removed 1 constraint.

删除不存在的约束

如果不确定是否存在具有给定名称的约束，并且希望如果存在则删除它但如果不存在则不报错，请使用 IF EXISTS。这将确保不抛出错误。从 Neo4j 5.17 开始，将返回一条信息性通知，说明该约束不存在。

示例 54. 删除不存在的约束
删除不存在的约束 missing_constraint_name
DROP CONSTRAINT missing_constraint_name IF EXISTS
结果
(no changes, no records)
通知
`DROP CONSTRAINT missing_constraint_name IF EXISTS` has no effect. `missing_constraint_name` does not exist.
© . All rights reserved.