tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e78107bcea
memgraph/tck_engine/tests/memgraph_V1/features/unstable_test03.feature
Matej Gradiček 9ab4beac60 Removed wrong test 
Reviewers: teon.banek

Reviewed By: teon.banek

Differential Revision: https://phabricator.memgraph.io/D277
2017-04-13 14:43:14 +00:00

1110 lines
24 KiB
Gherkin
Raw Blame History

Feature: test03
Scenario: Match multiple patterns 01
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (a)-[:X]->(b), (c)-[:X]->(a)
"""
When executing query:
"""
MATCH (a)-[]->(), (b) CREATE (a)-[r:R]->(b) RETURN a, b, r
"""
Then the result should be:
| a | b | r |
| (:C) | (:A) | [:R] |
| (:C) | (:B) | [:R] |
| (:C) | (:C) | [:R] |
| (:A) | (:A) | [:R] |
| (:A) | (:B) | [:R] |
| (:A) | (:C) | [:R] |
Scenario: Match multiple patterns 02
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (d:D), (e:E), (f:F), (a)-[:X]->(b), (b)-[:X]->(c), (d)-[:X]->(e), (e)-[:X]->(f)
"""
When executing query:
"""
MATCH (a:B)--(b), (c:E)--(d) CREATE (b)-[r:R]->(d) return b, d, r
"""
Then the result should be:
| b | d | r |
| (:A) | (:D) | [:R] |
| (:A) | (:F) | [:R] |
| (:C) | (:D) | [:R] |
| (:C) | (:F) | [:R] |
Scenario: Match multiple patterns 03
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (d:D), (a)-[:R]->(b), (b)-[:R]->(c), (c)-[:R]->(d)
"""
When executing query:
"""
MATCH (a:B)--(b), (c:B)--(d) RETURN b, d
"""
Then the result should be:
| b | d |
| (:A) | (:C) |
| (:C) | (:A) |
Scenario: Match multiple patterns 04
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (d:D), (a)-[:R]->(b), (b)-[:R]->(c), (c)-[:R]->(d)
"""
When executing query:
"""
MATCH (a:A)--(b), (c:A)--(d) RETURN a, b, c, d
"""
Then the result should be empty
Scenario: Multiple match 01
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (d:D), (a)-[:R]->(b), (b)-[:R]->(c), (c)-[:R]->(d)
"""
When executing query:
"""
MATCH (a:B)--(b) MATCH (c:B)--(d) RETURN b, d
"""
Then the result should be:
| b | d |
| (:A) | (:A) |
| (:A) | (:C) |
| (:C) | (:A) |
| (:C) | (:C) |
Scenario: Multiple match 02
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (d:D), (a)-[:R]->(b), (b)-[:R]->(c), (c)-[:R]->(d)
"""
When executing query:
"""
MATCH (a:A)--(b) MATCH (a)--(c) RETURN a, b, c
"""
Then the result should be:
| a | b | c |
| (:A) | (:B) | (:B) |
Scenario: Multiple match 03
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (a)-[:X]->(b), (c)-[:X]->(a)
"""
When executing query:
"""
MATCH (a)-[]->() MATCH (b) CREATE (a)-[r:R]->(b) RETURN a, b, r
"""
Then the result should be:
| a | b | r |
| (:C) | (:A) | [:R] |
| (:C) | (:B) | [:R] |
| (:C) | (:C) | [:R] |
| (:A) | (:A) | [:R] |
| (:A) | (:B) | [:R] |
| (:A) | (:C) | [:R] |
Scenario: Multiple match 04
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (d:D), (e:E), (f:F), (a)-[:X]->(b), (b)-[:X]->(c), (d)-[:X]->(e), (e)-[:X]->(f)
"""
When executing query:
"""
MATCH (a:B)--(b) MATCH (c:E)--(d) CREATE (b)-[r:R]->(d) return b, d, r
"""
Then the result should be:
| b | d | r |
| (:A) | (:D) | [:R] |
| (:A) | (:F) | [:R] |
| (:C) | (:D) | [:R] |
| (:C) | (:F) | [:R] |
Scenario: Multiple match 05
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C)
"""
When executing query:
"""
MATCH(a) MATCH(a) RETURN a
"""
Then the result should be:
| a |
| (:A) |
| (:B) |
| (:C) |
Scenario: Multiple match 06
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (a)-[:R]->(b), (b)-[:R]->(c)
"""
When executing query:
"""
MATCH (a)-[]->() MATCH (a:B) MATCH (b:C) RETURN a, b
"""
Then the result should be:
| a | b |
| (:B) | (:C) |
Scenario: Multiple match 07
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C), (a)-[:R]->(b), (b)-[:R]->(c)
"""
When executing query:
"""
MATCH (a)-[]->() MATCH (a:B) MATCH (a:C) RETURN a
"""
Then the result should be empty
Scenario: Remove 01
Given an empty graph
And having executed
"""
CREATE (a:A:B:C)
"""
When executing query:
"""
MATCH (n) REMOVE n:A:B:C RETURN n
"""
Then the result should be:
| n |
| () |
Scenario: Remove 02
Given an empty graph
And having executed
"""
CREATE (a:A:B:C)
"""
When executing query:
"""
MATCH (n) REMOVE n:B:C RETURN n
"""
Then the result should be:
| n |
| (:A) |
Scenario: Remove 03
Given an empty graph
And having executed
"""
CREATE (a{a: 1, b: 1.0, c: 's', d: false})
"""
When executing query:
"""
MATCH (n) REMOVE n:A:B, n.a REMOVE n.b, n.c, n.d RETURN n
"""
Then the result should be:
| n |
| () |
Scenario: Remove 04
Given an empty graph
And having executed
"""
CREATE (a:A:B{a: 1, b: 's', c: 1.0, d: true})
"""
When executing query:
"""
MATCH (n) REMOVE n:B, n.a, n.d RETURN n
"""
Then the result should be:
| n |
| (:A{b: 's', c: 1.0}) |
Scenario: Multiple create 01:
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B) CREATE (c:C), (a)-[:R]->(b) CREATE (b)-[:R]->(c)
"""
When executing query:
"""
MATCH (a)-[]->() MATCH (a:B) MATCH (b:C) RETURN a, b
"""
Then the result should be:
| a | b |
| (:B) | (:C) |
Scenario: Multiple create 02:
Given an empty graph
When executing query:
"""
CREATE (a:A) CREATE (a:B)
"""
Then an error should be raised
Scenario: Multiple create 02:
Given an empty graph
When executing query:
"""
CREATE (a:A) CREATE (a:B)
"""
Then an error should be raised
Scenario: Count test 01:
Given an empty graph
And having executed
"""
CREATE (a:A), (b:B), (c:C)
"""
When executing query:
"""
MATCH (a) RETURN COUNT(a) AS n
"""
Then the result should be:
| n |
| 3 |
Scenario: Count test 02:
Given an empty graph
When executing query:
"""
RETURN COUNT(123) AS n
"""
Then the result should be:
| n |
| 1 |
Scenario: Count test 03:
Given an empty graph
When executing query:
"""
RETURN COUNT(true) AS n
"""
Then the result should be:
| n |
| 1 |
Scenario: Count test 04:
Given an empty graph
When executing query:
"""
RETURN COUNT('abcd') AS n
"""
Then the result should be:
| n |
| 1 |
Scenario: Count test 05:
Given an empty graph
And having executed
"""
CREATE (a{x: 0}), (b{x: 0}), (c{x: 0}), (d{x: 1}), (e{x: 1})
"""
When executing query:
"""
MATCH (a) RETURN COUNT(a) AS n, a.x
"""
Then the result should be:
| n | a.x |
| 3 | 0 |
| 2 | 1 |
Scenario: Count test 06:
Given an empty graph
And having executed
"""
CREATE (), (), (), (), ()
"""
When executing query:
"""
MATCH (n) RETURN COUNT(*) AS n
"""
Then the result should be:
| n |
| 5 |
Scenario: Sum test 01:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 7}), (c{x: 5}), (d{x: 'x'})
"""
When executing query:
"""
MATCH (a) RETURN SUM(a.x) AS n
"""
Then an error should be raised
Scenario: Sum test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b), (c{x: 5}), (d{x: null})
"""
When executing query:
"""
MATCH (a) RETURN SUM(a.x) AS n
"""
Then the result should be:
| n |
| 6 |
Scenario: Sum test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0, y:3}), (b{x: 0, y:1}), (c{x: 0}), (d{x: 1, y:4}), (e{x: 1})
"""
When executing query:
"""
MATCH (a) RETURN SUM(a.y) AS n, a.x
"""
Then the result should be:
| n | a.x |
| 4 | 0 |
| 4 | 1 |
Scenario: Avg test 01:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 7}), (c{x: 5}), (d{x: 'x'})
"""
When executing query:
"""
MATCH (a) RETURN AVG(a.x) AS n
"""
Then an error should be raised
Scenario: Avg test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1.25}), (b), (c{x: 4.75}), (d{x: null})
"""
When executing query:
"""
MATCH (a) RETURN AVG(a.x) AS n
"""
Then the result should be:
| n |
| 3.0 |
Scenario: Avg test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0, y:3}), (b{x: 0, y:1}), (c{x: 0}), (d{x: 1, y:4}), (e{x: 1})
"""
When executing query:
"""
MATCH (a) RETURN AVG(a.y) AS n, a.x
"""
Then the result should be:
| n | a.x |
| 2.0 | 0 |
| 4.0 | 1 |
Scenario: Sqrt test 01:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 7}), (c{x: 5}), (d{x: 'x'})
"""
When executing query:
"""
MATCH (a) RETURN SQRT(a.x) AS n
"""
Then an error should be raised
Scenario: Sqrt test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b), (c{x: 9}), (d{x: null})
"""
When executing query:
"""
MATCH (a) RETURN SQRT(a.x) AS n
"""
Then the result should be:
| n |
| 1.0 |
| null |
| 3.0 |
| null |
Scenario: Min test 01:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 7}), (c{x: 5}), (d{x: 'x'})
"""
When executing query:
"""
MATCH (a) RETURN MIN(a.x) AS n
"""
Then an error should be raised
Scenario: Min test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b), (c{x: 9}), (d{x: null})
"""
When executing query:
"""
MATCH (a) RETURN MIN(a.x) AS n
"""
Then the result should be:
| n |
| 1 |
Scenario: Min test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0, y:3}), (b{x: 0, y:1}), (c{x: 0}), (d{x: 1, y:4}), (e{x: 1})
"""
When executing query:
"""
MATCH (a) RETURN MIN(a.y) AS n, a.x
"""
Then the result should be:
| n | a.x |
| 1 | 0 |
| 4 | 1 |
Scenario: Max test 01:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 7}), (c{x: 5}), (d{x: 'x'})
"""
When executing query:
"""
MATCH (a) RETURN MAX(a.x) AS n
"""
Then an error should be raised
Scenario: Max test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b), (c{x: 9}), (d{x: null})
"""
When executing query:
"""
MATCH (a) RETURN MAX(a.x) AS n
"""
Then the result should be:
| n |
| 9 |
Scenario: Max test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0, y:3}), (b{x: 0, y:1}), (c{x: 0}), (d{x: 1, y:4}), (e{x: 1})
"""
When executing query:
"""
MATCH (a) RETURN Max(a.y) AS n, a.x
"""
Then the result should be:
| n | a.x |
| 3 | 0 |
| 4 | 1 |
Scenario: ToBoolean test 01:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 0}))
"""
When executing query:
"""
MATCH (a) RETURN TOBOOLEAN(a.x) AS n
"""
Then an error should be raised
Scenario: ToBoolean test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 'TrUe'}), (b{x: 'not bool'}), (c{x: faLsE}), (d{x: null}), (e{x: 'fALse'}), (f{x: tRuE})
"""
When executing query:
"""
MATCH (a) RETURN TOBOOLEAN(a.x) AS n
"""
Then the result should be:
| n |
| true |
| null |
| false |
| null |
| false |
| true |
Scenario: ToInteger test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN TOINTEGER(a.x) AS n
"""
Then an error should be raised
Scenario: ToInteger test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 'not int'}), (c{x: '-12'}), (d{x: null}), (e{x: '1.2'}), (f{x: '1.9'})
"""
When executing query:
"""
MATCH (a) RETURN TOINTEGER(a.x) AS n
"""
Then the result should be:
| n |
| 1 |
| null |
| -12 |
| null |
| 1 |
| 1 |
Scenario: ToFloat test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN TOFLOAT(a.x) AS n
"""
Then an error should be raised
Scenario: ToFloat test 02:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (b{x: 'not float'}), (c{x: '-12'}), (d{x: null}), (e{x: '1.2'}), (f{x: 1.9})
"""
When executing query:
"""
MATCH (a) RETURN TOFLOAT(a.x) AS n
"""
Then the result should be:
| n |
| 1.0 |
| null |
| -12.0 |
| null |
| 1.2 |
| 1.9 |
Scenario: Abs test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true})
"""
When executing query:
"""
MATCH (a) RETURN ABS(a.x) AS n
"""
Then an error should be raised
Scenario: Abs test 02:
Given an empty graph
And having executed
"""
CREATE (b{x: '1.0'})
"""
When executing query:
"""
MATCH (a) RETURN ABS(a.x) AS n
"""
Then an error should be raised
Scenario: Abs test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (c{x: -12}), (d{x: null}), (e{x: -2.3}), (f{x: 1.9})
"""
When executing query:
"""
MATCH (a) RETURN ABS(a.x) AS n
"""
Then the result should be:
| n |
| 1 |
| 12 |
| null |
| 2.3 |
| 1.9 |
Scenario: Exp test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN EXP(a.x) AS n
"""
Then an error should be raised
Scenario: Exp test 02:
Given an empty graph
And having executed
"""
CREATE (b{x: '1.0'})),
"""
When executing query:
"""
MATCH (a) RETURN EXP(a.x) AS n
"""
Then an error should be raised
Scenario: Exp test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 1}), (c{x: -12}), (d{x: null}), (e{x: -2.3}), (f{x: 1.9})
"""
When executing query:
"""
MATCH (a) RETURN EXP(a.x) AS n
"""
Then the result should be:
| n |
| 2.718281828459045 |
| .00000614421235332821 |
| null |
| 0.10025884372280375 |
| 6.6858944422792685 |
Scenario: Log test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN LOG(a.x) AS n
"""
Then an error should be raised
Scenario: Log test 02:
Given an empty graph
And having executed
"""
CREATE (b{x: '1.0'})),
"""
When executing query:
"""
MATCH (a) RETURN LOG(a.x) AS n
"""
Then an error should be raised
Scenario: Log test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0.123}), (c{x: -12}), (d{x: null}), (e{x: 27})
"""
When executing query:
"""
MATCH (a) RETURN LOG(a.x) AS n
"""
Then the result should be:
| n |
| -2.0955709236097197 |
| nan |
| null |
| 3.295836866004329 |
Scenario: Log10 test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN LOG10(a.x) AS n
"""
Then an error should be raised
Scenario: Log10 test 02:
Given an empty graph
And having executed
"""
CREATE (b{x: '1.0'})),
"""
When executing query:
"""
MATCH (a) RETURN LOG10(a.x) AS n
"""
Then an error should be raised
Scenario: Log10 test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0.123}), (c{x: -12}), (d{x: null}), (e{x: 27})
"""
When executing query:
"""
MATCH (a) RETURN LOG10(a.x) AS n
"""
Then the result should be:
| n |
| -0.9100948885606021 |
| nan |
| null |
| 1.4313637641589874 |
Scenario: Sin test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN SIN(a.x) AS n
"""
Then an error should be raised
Scenario: Sin test 02:
Given an empty graph
And having executed
"""
CREATE (b{x: '1.0'})),
"""
When executing query:
"""
MATCH (a) RETURN SIN(a.x) AS n
"""
Then an error should be raised
Scenario: Sin test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0.123}), (c{x: -12}), (d{x: null}), (e{x: 27})
"""
When executing query:
"""
MATCH (a) RETURN SIN(a.x) AS n
"""
Then the result should be:
| n |
| 0.12269009002431533 |
| 0.5365729180004349 |
| null |
| 0.956375928404503 |
Scenario: Cos test 01:
Given an empty graph
And having executed
"""
CREATE (b{x: true}))
"""
When executing query:
"""
MATCH (a) RETURN COS(a.x) AS n
"""
Then an error should be raised
Scenario: Cos test 02:
Given an empty graph
And having executed
"""
CREATE (b{x: '1.0'})),
"""
When executing query:
"""
MATCH (a) RETURN COS(a.x) AS n
"""
Then an error should be raised
Scenario: Cos test 03:
Given an empty graph
And having executed
"""
CREATE (a{x: 0.123}), (c{x: -12}), (d{x: null}), (e{x: 27})
"""
When executing query:
"""
MATCH (a) RETURN COS(a.x) AS n
"""
Then the result should be:
| n |
| 0.9924450321351935 |
| 0.8438539587324921 |
| null |
| -0.2921388087338362 |
Scenario: With test 01:
Given an empty graph
And having executed:
"""
CREATE (a:A), (b:B), (c:C), (d:D), (e:E), (a)-[:R]->(b), (b)-[:R]->(c),
(b)-[:R]->(d), (c)-[:R]->(a), (c)-[:R]->(e), (d)-[:R]->(e)
"""
When executing query:
"""
MATCH (:A)--(a)-->() WITH a, COUNT(*) AS n WHERE n > 1 RETURN a
"""
Then the result should be:
| a |
| (:B) |
Scenario: With 02
Given an empty graph
And having executed
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (c:C{x: 3}), (d:D{x: 4}), (a)-[:R]->(b), (b)-[:R]->(c), (c)-[:R]->(d), (d)-[:R]->(a)
"""
When executing query:
"""
MATCH (a)--(b)
WITH a, MAX(b.x) AS s
RETURN a, s
"""
Then the result should be:
| a | s |
| (:A{x: 1}) | 4 |
| (:B{x: 2}) | 3 |
| (:C{x: 3}) | 4 |
| (:D{x: 4}) | 3 |
Scenario: With 03
Given an empty graph
And having executed
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (a)-[:R]->(b), (a)-[:R]->(b), (b)-[:R]->(a), (b)-[:R]->(a)
"""
When executing query:
"""
MATCH (b)--(a)--(c)
WITH a, (SUM(b.x)+SUM(c.x)) AS s
RETURN a, s
"""
Then the result should be:
| a | s |
| (:A{x: 1}) | 48 |
| (:B{x: 2}) | 24 |
Scenario: With test 04:
Given an empty graph
And having executed:
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (c:C{x: 3}), (d:D{x: 4}), (e:E{x: 5}), (a)-[:R]->(b), (b)-[:R]->(c),
(b)-[:R]->(d), (c)-[:R]->(a), (c)-[:R]->(e), (d)-[:R]->(e)
"""
When executing query:
"""
MATCH (c)--(a:B)--(b)--(d)
WITH a, b, SUM(c.x)+SUM(d.x) AS n RETURN a, b, n
"""
Then the result should be:
| a | b | n |
| (:B{x: 2}) | (:A{x: 1}) | 13 |
| (:B{x: 2}) | (:C{x: 3}) | 22 |
| (:B{x: 2}) | (:D{x: 4}) | 14 |
Scenario: With test 05:
Given an empty graph
And having executed:
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (c:C{x: 3}), (d:D{x: 4}), (e:E{x: 5}), (a)-[:R]->(b), (b)-[:R]->(c),
(b)-[:R]->(d), (c)-[:R]->(a), (c)-[:R]->(e), (d)-[:R]->(e)
"""
When executing query:
"""
MATCH (c)--(a:B)--(b)--(d)
WITH a, b, AVG(c.x + d.x) AS n RETURN a, b, n
"""
Then the result should be:
| a | b | n |
| (:B{x: 2}) | (:A{x: 1}) | 6.5 |
| (:B{x: 2}) | (:C{x: 3}) | 5.5 |
| (:B{x: 2}) | (:D{x: 4}) | 7.0 |
Scenario: With test 06:
Given an empty graph
And having executed:
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (c:C{x: 3}), (d:D{x: 4}), (e:E{x: 5}), (a)-[:R]->(b), (b)-[:R]->(c),
(b)-[:R]->(d), (c)-[:R]->(a), (c)-[:R]->(e), (d)-[:R]->(e)
"""
When executing query:
"""
MATCH (c)--(a:B)--(b)--(d)
WITH a, b, AVG(c.x + d.x) AS n RETURN MAX(n) AS n
"""
Then the result should be:
| n |
| 7.0 |
Scenario: With test 07:
Given an empty graph
And having executed:
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (c:C{x: 3}), (d:D{x: 4}), (e:E{x: 5}), (a)-[:R]->(b), (b)-[:R]->(c),
(b)-[:R]->(d), (c)-[:R]->(a), (c)-[:R]->(e), (d)-[:R]->(e)
"""
When executing query:
"""
MATCH (c)--(a:B)--(b)--(d)
WITH a, b, AVG(c.x + d.x) AS n
WITH a, MAX(n) AS n RETURN a, n
"""
Then the result should be:
| a | n |
| (:B{x: 2}) | 7.0 |
Scenario: With test 07:
Given an empty graph
When executing query:
"""
CREATE (a), (b) WITH a, b CREATE (a)-[r:R]->(b) RETURN r
"""
Then the result should be:
| r |
| [:R] |
Scenario: With test 08:
Given an empty graph
When executing query:
"""
CREATE (a), (b) WITH a, b SET a:X SET b:Y WITH a, b MATCH(x:X) RETURN x
"""
Then the result should be:
| x |
| (:X) |
Scenario: With test 09:
Given an empty graph
When executing query:
"""
CREATE (a), (b), (a)-[:R]->(b) WITH a, b SET a:X SET b:Y
WITH a MATCH(x:X)--(b) RETURN x, x AS y
"""
Then the result should be:
| x | y |
| (:X) | (:X) |
Scenario: With test 10:
Given an empty graph
And having executed:
"""
CREATE (a:A{x: 1}), (b:B{x: 2}), (c:C{x: 3}), (d:D{x: 4}), (e:E{x: 5}), (a)-[:R]->(b), (b)-[:R]->(c),
(b)-[:R]->(d), (c)-[:R]->(a), (c)-[:R]->(e), (d)-[:R]->(e)
"""
When executing query:
"""
MATCH (c)--(a:B)--(b)--(d) WITH a, b, AVG(c.x + d.x) AS av WITH AVG(av) AS avg
MATCH (c)--(a:B)--(b)--(d) WITH a, b, avg, AVG(c.x + d.x) AS av WHERE av>avg RETURN av
"""
Then the result should be:
| av |
| 6.5 |
| 7.0 |
Scenario: With test 11:
Given an empty graph
When executing query:
"""
CREATE(a:A), (b:B), (c:C), (a)-[:T]->(b) WITH a DETACH DELETE a WITH a MATCH()-[r:T]->() RETURN r
"""
Then the result should be empty
Scenario: Exception test scenario:
Given an empty graph
When executing query:
"""
CREATE(a:A) CREATE(a:B)
"""
Then an error should be raised
Reference in New Issue View Git Blame Copy Permalink