创建、显示和删除约束
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 版本引入
有关创建属性唯一性约束的完整命令语法,请参阅 语法 → 创建属性唯一性约束。
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 。 |
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 版本引入
有关创建属性唯一性约束的完整命令语法,请参阅 语法 → 创建属性唯一性约束。
Book
节点具有 title
和 publicationYear
属性唯一组合的约束CREATE CONSTRAINT book_title_year
FOR (book:Book) REQUIRE (book.title, book.publicationYear) IS UNIQUE
Added 1 constraint.
PREQUEL_OF
关系具有 order
和 author
属性唯一组合的约束CREATE CONSTRAINT prequels
FOR ()-[prequel:PREQUEL_OF]-() REQUIRE (prequel.order, prequel.author) IS UNIQUE
Added 1 constraint.
创建符合现有属性唯一性约束的数据
isbn
属性的 Book
节点CREATE (book:Book {isbn: '1449356265', title: 'Graph Databases'})
Added 1 label, created 1 node, set 2 properties
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
。
有关创建存在性约束的完整命令语法,请参阅 语法 → 创建属性存在性约束。
无法在多个属性上创建复合存在性约束。 |
Author
节点具有 name
属性的约束CREATE CONSTRAINT author_name
FOR (author:Author) REQUIRE author.name IS NOT NULL
Added 1 constraint.
WROTE
关系具有 year
属性的约束CREATE CONSTRAINT wrote_year
FOR ()-[wrote:WROTE]-() REQUIRE wrote.year IS NOT NULL
Added 1 constraint.
创建符合现有属性存在性约束的数据
name
属性的 Author
节点CREATE (author:Author {name:'Virginia Woolf', surname: 'Woolf'})
Added 1 label, created 1 node, set 2 properties
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 中不同数据类型的信息,请参阅 值和类型。有关创建属性类型约束的完整命令语法,请参阅 语法 → 创建属性类型约束。
无法在多个属性上创建复合属性类型约束。 |
Movie
节点上的 title
属性为 STRING
类型的约束CREATE CONSTRAINT movie_title
FOR (movie:Movie) REQUIRE movie.title IS :: STRING
Added 1 constraint.
PART_OF
关系上的 order
属性为 INTEGER
类型的约束CREATE CONSTRAINT part_of
FOR ()-[part:PART_OF]-() REQUIRE part.order IS :: INTEGER
Added 1 constraint.
创建具有联合类型的属性类型约束
封闭动态联合允许节点或关系属性在保持一定类型灵活性的同时,防止存储意外值。
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.
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 中所有可用类型的完整参考,请参阅 类型及其同义词 部分。
在无效类型上创建属性类型约束将失败
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`.
创建符合现有属性类型约束的数据
STRING
类型 title
属性的 Movie
节点CREATE (movie:Movie {title:'Iron Man'})
Added 1 label, created 1 node, set 1 properties
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 版本引入
有关创建键约束的完整命令语法,请参阅 语法 → 创建键约束。
Director
节点具有唯一 imdbId
属性作为节点键的约束。CREATE CONSTRAINT director_imdbId
FOR (director:Director) REQUIRE (director.imdbId) IS NODE KEY
Added 1 constraint.
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 版本引入
有关创建键约束的完整命令语法,请参阅 语法 → 创建键约束。
Actor
节点具有 firstname
和 surname
属性唯一组合作为节点键的约束CREATE CONSTRAINT actor_fullname
FOR (actor:Actor) REQUIRE (actor.firstname, actor.surname) IS NODE KEY
Added 1 constraint.
KNOWS
关系具有 since
和 how
属性唯一组合作为关系键的约束CREATE CONSTRAINT knows_since_how
FOR ()-[knows:KNOWS]-() REQUIRE (knows.since, knows.how) IS RELATIONSHIP KEY
Added 1 constraint.
创建符合现有键约束的数据
firstname
和 surname
属性的 Actor
节点CREATE (actor:Actor {firstname: 'Keanu', surname: 'Reeves'})
Added 1 label, created 1 node, set 2 properties.
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.
使用参数创建约束
所有约束类型都可以使用参数化名称创建。
{
"name": "node_uniqueness_param"
}
CREATE CONSTRAINT $name
FOR (book:Book) REQUIRE book.prop1 IS UNIQUE
Added 1 constraint.
{
"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 开始,将返回一条信息性通知,显示阻止创建的现有约束。
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.
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.
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.
创建已存在的约束将失败
创建与现有约束同名,或在相同节点标签或关系类型和属性上(这些属性已被同类型约束限制)的约束将失败。属性唯一性约束和键约束也不允许在相同模式上共存。
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 。 |
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 。 |
AUTHORED
关系具有唯一 name
属性的约束,前提是已存在具有相同名称但模式不同的约束CREATE CONSTRAINT author_name
FOR ()-[a:AUTHORED]-() REQUIRE a.name IS UNIQUE
There already exists a constraint called 'author_name'.
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 )
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
列中。
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 |
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+
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 |
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
属性存在性约束和属性类型约束不受索引支持。 |
约束失败和索引
尝试创建与现有索引同名的任何类型约束将失败。
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'.
在与现有索引相同的模式上创建键或属性唯一性约束将失败。
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.
约束和数据违规场景
创建违反现有约束的数据将失败
约束类型 | 创建缺少存在性约束属性的节点和关系 | 创建具有非唯一属性/属性组合的节点和关系 | 创建具有错误属性类型的节点和关系 |
---|---|---|---|
属性唯一性约束 |
❌ |
||
属性存在性约束 |
❌ |
||
属性类型约束 |
❌ |
||
键约束 |
❌ |
❌ |
isbn
属性的 Book
节点CREATE (book:Book {isbn: '1449356265', title: 'Graph Databases'})
Node(0) already exists with label `Book` and property `isbn` = '1449356265'
name
属性的 Author
节点,前提是存在 :Author(name)
的属性存在性约束CREATE (author:Author {surname: 'Austen'})
Node(0) with label `Author` must have the property `name`
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
firstname
属性的 Actor
节点,前提是存在 :Actor(firstname, surname)
的节点键约束CREATE (actor:Actor {surname: 'Wood'})
Node(0) with label `Actor` must have the properties (`firstname`, `surname`)
删除存在性和键约束的属性将失败
Author
节点中删除 name
属性,前提是存在 :Author(name)
的属性存在性约束MATCH (author:Author {name: 'Virginia Woolf'})
REMOVE author.name
Node(0) with label `Author` must have the property `name`
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`)
修改类型约束的属性将失败
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`.
当存在冲突数据时创建约束将失败
约束类型 | 不存在的属性 | 非唯一的属性/属性组合 | 类型错误的属性 |
---|---|---|---|
属性唯一性约束 |
❌ |
||
属性存在性约束 |
❌ |
||
属性类型约束 |
❌ |
||
键约束 |
❌ |
❌ |
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
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
约束 | 查询 |
---|---|
节点属性唯一性约束 |
|
关系属性唯一性约束 |
|
节点属性存在性约束 |
|
关系属性存在性约束 |
|
节点属性类型约束 |
|
关系属性类型约束 |
|
节点键约束 |
|
关系键约束 |
|
SHOW CONSTRAINTS
要列出所有约束及其默认输出列,请使用 SHOW CONSTRAINTS
。如果需要所有列,请使用 SHOW CONSTRAINTS YIELD *
。有关列出约束的完整命令语法,请参阅 语法 → SHOW CONSTRAINTS。
SHOW CONSTRAINTS
的输出列之一是约束的名称。这可用于使用 DROP CONSTRAINT
命令 删除约束。
列出约束需要 SHOW CONSTRAINTS 权限。 |
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 |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
要返回数据库上约束的完整详细信息,请使用 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
子句中指定所需列来实现。
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。
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 |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
可以使用 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" |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
列出约束的结果列
列 | 描述 | 类型 | ||
---|---|---|---|---|
|
约束的 ID。默认输出 |
|
||
|
约束的名称(由用户显式设置或自动分配)。默认输出 |
|
||
|
此约束的 ConstraintType(
|
|
||
|
此约束表示的实体类型( |
|
||
|
此约束的标签或关系类型。返回的列表将只包含一个值(受约束的节点标签或关系类型的名称)。默认输出 |
|
||
|
此约束的属性。默认输出 |
|
||
|
与约束关联的索引名称,如果未关联索引则为 |
|
||
|
对于属性类型约束,属性被限制为的属性类型,对于其他约束则为 |
|
||
|
传递给 |
|
||
|
用于创建约束的语句。 |
|
DROP CONSTRAINT
约束使用 DROP CONSTRAINT
命令删除。有关删除约束的完整命令语法,请参阅 语法 → DROP CONSTRAINT。
删除约束需要 DROP CONSTRAINT 权限。 |
按名称删除约束
可以使用 DROP CONSTRAINT constraint_name
命令按名称删除约束。这对于所有约束类型都是相同的命令。约束的名称可以通过 SHOW CONSTRAINTS
命令 的 name
输出列找到。
book_isbn
DROP CONSTRAINT book_isbn
Removed 1 constraint.
使用参数删除约束
约束可以使用参数化名称删除。
{
"name": "actor_fullname"
}
DROP CONSTRAINT $name
Removed 1 constraint.
删除不存在的约束
如果不确定是否存在具有给定名称的约束,并且希望如果存在则删除它但如果不存在则不报错,请使用 IF EXISTS
。这将确保不抛出错误。从 Neo4j 5.17 开始,将返回一条信息性通知,说明该约束不存在。
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.