-
Notifications
You must be signed in to change notification settings - Fork 2.3k
/
DeleteAcceptanceTest.scala
159 lines (120 loc) · 4.56 KB
/
DeleteAcceptanceTest.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/*
* Copyright (c) 2002-2015 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.internal.cypher.acceptance
import org.neo4j.cypher._
class DeleteAcceptanceTest extends ExecutionEngineFunSuite with QueryStatisticsTestSupport with NewPlannerTestSupport {
test("should be able to delete nodes") {
createNode()
val result = updateWithBothPlanners(
s"match (n) delete n"
)
assertStats(result, nodesDeleted = 1)
}
test("should be able to delete relationships") {
relate(createNode(), createNode())
relate(createNode(), createNode())
relate(createNode(), createNode())
val result = updateWithBothPlanners(
s"match ()-[r]-() delete r"
)
assertStats(result, relationshipsDeleted = 3)
}
test("should be able to detach delete node") {
createNode("foo" -> "bar")
val result = updateWithBothPlanners(
s"match (n) detach delete n"
)
assertStats(result, nodesDeleted = 1)
}
test("should not be able to delete nodes when connected") {
val x = createLabeledNode("X")
relate(x, createNode())
relate(x, createNode())
relate(x, createNode())
a [ConstraintValidationException] should be thrownBy
executeWithCostPlannerOnly(s"match (n:X) delete n")
}
test("should be able to detach delete nodes and their relationships") {
val x = createLabeledNode("X")
relate(x, createNode())
relate(x, createNode())
relate(x, createNode())
val result = updateWithBothPlanners(
s"match (n:X) detach delete n"
)
assertStats(result, nodesDeleted = 1, relationshipsDeleted = 3)
}
test("should handle detach delete paths") {
val x = createLabeledNode("X")
val n1 = createNode()
val n2 = createNode()
val n3 = createNode()
relate(x, n1)
relate(n1, n2)
relate(n2, n3)
val result = updateWithBothPlanners(
s"match p = (:X)-->()-->()-->() detach delete p"
)
assertStats(result, nodesDeleted = 4, relationshipsDeleted = 3)
}
test("undirected expand followed by delete and count") {
relate(createNode(), createNode())
val result = updateWithBothPlanners(s"MATCH (a)-[r]-(b) DELETE r,a,b RETURN count(*) AS c")
assertStats(result, nodesDeleted = 2, relationshipsDeleted = 1)
result.toList should equal(List(Map("c" -> 2)))
}
test("undirected variable length expand followed by delete and count") {
val node1 = createNode()
val node2 = createNode()
val node3 = createNode()
relate(node1, node2)
relate(node2, node3)
val result = executeWithCostPlannerOnly(s"MATCH (a)-[*]-(b) DETACH DELETE a,b RETURN count(*) AS c")
assertStats(result, nodesDeleted = 3, relationshipsDeleted = 2)
//(1)-->(2), (2)<--(1), (2)-->(3), (3)<--(2), (1)-*->(3), (3)<-*-(1)
result.toList should equal(List(Map("c" -> 6)))
}
test("should be possible to create and delete in one statement") {
createNode()
val result = updateWithBothPlanners("MATCH () CREATE (n) DELETE n")
assertStats(result, nodesCreated = 1, nodesDeleted = 1)
}
test("should be able to delete on optional match relationship") {
createNode()
val query = "MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r"
val result = updateWithBothPlanners(query)
assertStats(result, nodesDeleted = 1)
}
test("should be able to handle detach deleting null node") {
val query = "OPTIONAL MATCH (n) DETACH DELETE n"
val result = updateWithBothPlanners(query)
assertStats(result, nodesDeleted = 0)
}
test("should be able to handle deleting null node") {
val query = "OPTIONAL MATCH (n) DELETE n"
val result = updateWithBothPlanners(query)
assertStats(result, nodesDeleted = 0)
}
test("should be able to handle deleting null path") {
val query = "OPTIONAL MATCH p = (n)-->() DETACH DELETE p"
val result = updateWithBothPlanners(query)
assertStats(result, nodesDeleted = 0)
}
}