Cucumber Reports (no 1.0.2) - Feature: MatchAcceptance

Project	Number	Date
cypher-for-gremlin	1.0.2	10 Jun 2019, 13:01

	Steps	Scenarios	Features
MatchAcceptance	150	0	0	0	0	150	30	0	30	0.000	Passed

0.000

Scenario Path query should return results in written order

Steps

Given an empty graph 0.000

Output 1

13:00:18.993 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (:Label1)<-[:TYPE]-(:Label2)

Output 1

13:00:18.994 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (:Label1)<-[:TYPE]-(:Label2)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:18.995 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:Label1)<-[:TYPE]-(:Label2)
13:00:18.997 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('Label1').as('  UNNAMED8').addV('Label2').as('  UNNAMED27').addE('TYPE').from('  UNNAMED27').to('  UNNAMED8').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a:Label1)<--(:Label2)
RETURN p

Output 1

13:00:19.024 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a:Label1)<--(:Label2) RETURN p
13:00:19.026 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a:Label1)<--(:Label2)
RETURN p}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.030 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').hasLabel('Label1').inE().aggregate('  cypher.path.edge.p').outV().hasLabel('Label2').path().from('a').project('p').by(__.is(neq('  cypher.unused')).project('  cypher.relationship', '  cypher.element').by(__.select('  cypher.path.edge.p').unfold().project('  cypher.id', '  cypher.inv', '  cypher.outv').by(__.id()).by(__.inV().id()).by(__.outV().id()).fold()).by(__.unfold().is(neq('  cypher.start')).valueMap().with('~tinkerpop.valueMap.tokens').fold()))

Then the result should be: 0.000

p

<(:Label1)<-[:TYPE]-(:Label2)>

And no side effects 0.000

Output 1

13:00:19.031 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.031 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.034 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.034 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.034 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.038 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.038 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.038 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.041 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.042 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.047 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Longer path query should return results in written order

Steps

Given an empty graph 0.000

Output 1

13:00:19.052 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (:Label1)<-[:T1]-(:Label2)-[:T2]->(:Label3)

Output 1

13:00:19.054 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (:Label1)<-[:T1]-(:Label2)-[:T2]->(:Label3)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.054 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:Label1)<-[:T1]-(:Label2)-[:T2]->(:Label3)
13:00:19.058 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('Label1').as('  UNNAMED8').addV('Label2').as('  UNNAMED25').addE('T1').from('  UNNAMED25').to('  UNNAMED8').addV('Label3').as('  UNNAMED42').addE('T2').from('  UNNAMED25').to('  UNNAMED42').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a:Label1)<--(:Label2)--()
RETURN p

Output 1

13:00:19.089 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a:Label1)<--(:Label2)--() RETURN p
13:00:19.091 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a:Label1)<--(:Label2)--()
RETURN p}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.095 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').hasLabel('Label1').inE().as('  UNNAMED21').aggregate('  cypher.path.edge.p').outV().hasLabel('Label2').bothE().dedup().by(__.path()).as('  UNNAMED33').aggregate('  cypher.path.edge.p').otherV().path().from('a').as('p').where(__.select('  UNNAMED21').where(neq('  UNNAMED33'))).select('p').project('p').by(__.is(neq('  cypher.unused')).project('  cypher.relationship', '  cypher.element').by(__.select('  cypher.path.edge.p').unfold().project('  cypher.id', '  cypher.inv', '  cypher.outv').by(__.id()).by(__.inV().id()).by(__.outV().id()).fold()).by(__.unfold().is(neq('  cypher.start')).valueMap().with('~tinkerpop.valueMap.tokens').fold()))

Then the result should be: 0.000

p

<(:Label1)<-[:T1]-(:Label2)-[:T2]->(:Label3)>

And no side effects 0.000

Output 1

13:00:19.097 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.097 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.100 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.101 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.101 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.104 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.105 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.105 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.108 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.109 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.115 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Use multiple MATCH clauses to do a Cartesian product

Steps

Given an empty graph 0.000

Output 1

13:00:19.121 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE ({value: 1}),
  ({value: 2}),
  ({value: 3})

Output 1

13:00:19.122 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({value: 1}),   ({value: 2}),   ({value: 3})
13:00:19.123 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE ({value: 1}),
  ({value: 2}),
  ({value: 3})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.125 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV().property(single, 'value', 1).addV().property(single, 'value', 2).addV().property(single, 'value', 3).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n), (m)
RETURN n.value AS n, m.value AS m

Output 1

13:00:19.154 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n), (m)
RETURN n.value AS n, m.value AS m}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.155 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n), (m) RETURN n.value AS n, m.value AS m
13:00:19.158 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').V().as('m').select('n', 'm').project('n', 'm').by(__.select('n').choose(__.values('value'), __.values('value'), __.constant('  cypher.null'))).by(__.select('m').choose(neq('  cypher.null'), __.choose(__.values('value'), __.values('value'), __.constant('  cypher.null'))))

Then the result should be: 0.000

n	m
1	1
1	2
1	3
2	1
2	2
2	3
3	3
3	1
3	2

And no side effects 0.000

Output 1

13:00:19.163 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.164 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.166 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.167 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.167 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.170 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.174 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.174 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.177 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.182 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.183 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Use params in pattern matching predicates

Steps

Given an empty graph 0.000

Output 1

13:00:19.189 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (:A)-[:T {foo: 'bar'}]->(:B {name: 'me'})

Output 1

13:00:19.198 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:A)-[:T {foo: 'bar'}]->(:B {name: 'me'})
13:00:19.199 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (:A)-[:T {foo: 'bar'}]->(:B {name: 'me'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.201 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('  UNNAMED8').addV('B').as('  UNNAMED32').property(single, 'name', 'me').addE('T').from('  UNNAMED8').to('  UNNAMED32').property('foo', 'bar').barrier().limit(0)

And parameters are: 0.000

param

'bar'

When executing query: 0.000

Doc string

MATCH (a)-[r]->(b)
WHERE r.foo = $param
RETURN b

Output 1

13:00:19.218 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a)-[r]->(b)
WHERE r.foo = $param
RETURN b, bindings={param=bar}}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.218 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r]->(b) WHERE r.foo = $param RETURN b
13:00:19.223 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().outE().as('r').inV().as('b').where(__.choose(__.constant('bar'), __.constant('bar'), __.constant('  cypher.null')).is(neq('  cypher.null')).as('  GENERATED2').select('r').values('foo').where(eq('  GENERATED2'))).select('b').project('b').by(__.choose(neq('  cypher.null'), __.valueMap().with('~tinkerpop.valueMap.tokens')))

Then the result should be: 0.000

b

(:B {name: 'me'})

And no side effects 0.000

Output 1

13:00:19.224 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.225 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.228 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.229 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.229 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.232 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.232 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.233 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.236 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.236 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.237 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Filter out based on node prop name

Steps

Given an empty graph 0.000

Output 1

13:00:19.238 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE ({name: 'Someone'})<-[:X]-()-[:X]->({name: 'Andres'})

Output 1

13:00:19.239 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE ({name: 'Someone'})<-[:X]-()-[:X]->({name: 'Andres'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.239 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({name: 'Someone'})<-[:X]-()-[:X]->({name: 'Andres'})
13:00:19.242 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV().as('  UNNAMED8').property(single, 'name', 'Someone').addV().as('  UNNAMED34').addE('X').from('  UNNAMED34').to('  UNNAMED8').addV().as('  UNNAMED43').property(single, 'name', 'Andres').addE('X').from('  UNNAMED34').to('  UNNAMED43').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH ()-[rel:X]-(a)
WHERE a.name = 'Andres'
RETURN a

Output 1

13:00:19.272 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[rel:X]-(a)
WHERE a.name = 'Andres'
RETURN a}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.273 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[rel:X]-(a) WHERE a.name = 'Andres' RETURN a
13:00:19.277 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().bothE('X').dedup().by(__.path()).otherV().has('name', eq('Andres')).project('a').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

a

({name: 'Andres'})

And no side effects 0.000

Output 1

13:00:19.278 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.278 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.281 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.281 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.281 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.284 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.285 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.285 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.289 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.292 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.294 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Honour the column name for RETURN items

Steps

Given an empty graph 0.000

Output 1

13:00:19.300 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE ({name: 'Someone'})

Output 1

13:00:19.302 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE ({name: 'Someone'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.302 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({name: 'Someone'})
13:00:19.304 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV().property(single, 'name', 'Someone').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (a)
WITH a.name AS a
RETURN a

Output 1

13:00:19.330 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a)
WITH a.name AS a
RETURN a}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.330 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a) WITH a.name AS a RETURN a
13:00:19.334 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.choose(neq('  cypher.null'), __.choose(__.values('name'), __.values('name'), __.constant('  cypher.null')))).project('a').by(__.identity())

Then the result should be: 0.000

a

'Someone'

And no side effects 0.000

Output 1

13:00:19.335 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.335 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.338 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.338 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.339 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.342 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.345 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.345 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.348 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.351 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.358 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Filter based on rel prop name

Steps

Given an empty graph 0.000

Output 1

13:00:19.364 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (:A)<-[:KNOWS {name: 'monkey'}]-()-[:KNOWS {name: 'woot'}]->(:B)

Output 1

13:00:19.365 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (:A)<-[:KNOWS {name: 'monkey'}]-()-[:KNOWS {name: 'woot'}]->(:B)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.367 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:A)<-[:KNOWS {name: 'monkey'}]-()-[:KNOWS {name: 'woot'}]->(:B)
13:00:19.371 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('  UNNAMED8').addV().as('  UNNAMED40').addE('KNOWS').from('  UNNAMED40').to('  UNNAMED8').property('name', 'monkey').addV('B').as('  UNNAMED68').addE('KNOWS').from('  UNNAMED40').to('  UNNAMED68').property('name', 'woot').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (node)-[r:KNOWS]->(a)
WHERE r.name = 'monkey'
RETURN a

Output 1

13:00:19.393 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (node)-[r:KNOWS]->(a)
WHERE r.name = 'monkey'
RETURN a}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.393 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (node)-[r:KNOWS]->(a) WHERE r.name = 'monkey' RETURN a
13:00:19.399 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().outE('KNOWS').has('name', eq('monkey')).inV().project('a').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

a

(:A)

And no side effects 0.000

Output 1

13:00:19.400 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.400 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.403 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.403 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.403 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.406 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.407 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.407 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.410 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.411 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.415 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Cope with shadowed variables

Steps

Given an empty graph 0.000

Output 1

13:00:19.417 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE ({value: 1, name: 'King Kong'}),
  ({value: 2, name: 'Ann Darrow'})

Output 1

13:00:19.420 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE ({value: 1, name: 'King Kong'}),
  ({value: 2, name: 'Ann Darrow'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.424 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({value: 1, name: 'King Kong'}),   ({value: 2, name: 'Ann Darrow'})
13:00:19.427 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV().property(single, 'value', 1).property(single, 'name', 'King Kong').addV().property(single, 'value', 2).property(single, 'name', 'Ann Darrow').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n)
WITH n.name AS n
RETURN n

Output 1

13:00:19.465 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
WITH n.name AS n
RETURN n}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.466 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) WITH n.name AS n RETURN n
13:00:19.471 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.choose(neq('  cypher.null'), __.choose(__.values('name'), __.values('name'), __.constant('  cypher.null')))).project('n').by(__.identity())

Then the result should be: 0.000

n

'Ann Darrow'

'King Kong'

And no side effects 0.000

Output 1

13:00:19.472 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.472 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.476 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.477 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.477 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.481 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.484 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.484 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.487 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.491 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.492 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Get neighbours

Steps

Given an empty graph 0.000

Output 1

13:00:19.498 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2})

Output 1

13:00:19.499 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.499 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2})
13:00:19.502 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'value', 1).addV('B').as('b').property(single, 'value', 2).addE('KNOWS').from('a').to('b').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n1)-[rel:KNOWS]->(n2)
RETURN n1, n2

Output 1

13:00:19.523 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n1)-[rel:KNOWS]->(n2)
RETURN n1, n2}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.524 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n1)-[rel:KNOWS]->(n2) RETURN n1, n2
13:00:19.527 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n1').outE('KNOWS').inV().as('n2').select('n1', 'n2').project('n1', 'n2').by(__.select('n1').valueMap().with('~tinkerpop.valueMap.tokens')).by(__.select('n2').valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

n1	n2
(:A {value: 1})	(:B {value: 2})

And no side effects 0.000

Output 1

13:00:19.528 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.529 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.532 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.532 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.532 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.536 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.536 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.536 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.539 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.540 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.541 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Get two related nodes

Steps

Given an empty graph 0.000

Output 1

13:00:19.547 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {value: 1}),
  (a)-[:KNOWS]->(b:B {value: 2}),
  (a)-[:KNOWS]->(c:C {value: 3})

Output 1

13:00:19.548 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {value: 1}),
  (a)-[:KNOWS]->(b:B {value: 2}),
  (a)-[:KNOWS]->(c:C {value: 3})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.548 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {value: 1}),   (a)-[:KNOWS]->(b:B {value: 2}),   (a)-[:KNOWS]->(c:C {value: 3})
13:00:19.552 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'value', 1).addV('B').as('b').property(single, 'value', 2).addE('KNOWS').from('a').to('b').addV('C').as('c').property(single, 'value', 3).addE('KNOWS').from('a').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH ()-[rel:KNOWS]->(x)
RETURN x

Output 1

13:00:19.576 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[rel:KNOWS]->(x)
RETURN x}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.576 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[rel:KNOWS]->(x) RETURN x
13:00:19.580 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().outE('KNOWS').inV().project('x').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

x

(:B {value: 2})

(:C {value: 3})

And no side effects 0.000

Output 1

13:00:19.581 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.581 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.584 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.585 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.587 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.591 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.592 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.593 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.596 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.597 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.598 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Get related to related to

Steps

Given an empty graph 0.000

Output 1

13:00:19.605 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2})-[:FRIEND]->(c:C {value: 3})

Output 1

13:00:19.607 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2})-[:FRIEND]->(c:C {value: 3})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.607 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2})-[:FRIEND]->(c:C {value: 3})
13:00:19.611 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'value', 1).addV('B').as('b').property(single, 'value', 2).addE('KNOWS').from('a').to('b').addV('C').as('c').property(single, 'value', 3).addE('FRIEND').from('b').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n)-->(a)-->(b)
RETURN b

Output 1

13:00:19.638 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)-->(a)-->(b)
RETURN b}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.638 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n)-->(a)-->(b) RETURN b
13:00:19.643 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().outE().as('  UNNAMED10').inV().outE().as('  UNNAMED16').inV().as('b').where(__.select('  UNNAMED10').where(neq('  UNNAMED16'))).select('b').project('b').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

b

(:C {value: 3})

And no side effects 0.000

Output 1

13:00:19.644 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.644 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.647 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.648 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.649 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.652 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.653 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.654 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.657 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.658 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.659 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Handle comparison between node properties

Steps

Given an empty graph 0.000

Output 1

13:00:19.665 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {animal: 'monkey'}),
  (b:B {animal: 'cow'}),
  (c:C {animal: 'monkey'}),
  (d:D {animal: 'cow'}),
  (a)-[:KNOWS]->(b),
  (a)-[:KNOWS]->(c),
  (d)-[:KNOWS]->(b),
  (d)-[:KNOWS]->(c)

Output 1

13:00:19.667 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {animal: 'monkey'}),
  (b:B {animal: 'cow'}),
  (c:C {animal: 'monkey'}),
  (d:D {animal: 'cow'}),
  (a)-[:KNOWS]->(b),
  (a)-[:KNOWS]->(c),
  (d)-[:KNOWS]->(b),
  (d)-[:KNOWS]->(c)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.668 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {animal: 'monkey'}),   (b:B {animal: 'cow'}),   (c:C {animal: 'monkey'}),   (d:D {animal: 'cow'}),   (a)-[:KNOWS]->(b),   (a)-[:KNOWS]->(c),   (d)-[:KNOWS]->(b),   (d)-[:KNOWS]->(c)
13:00:19.674 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'animal', 'monkey').addV('B').as('b').property(single, 'animal', 'cow').addV('C').as('c').property(single, 'animal', 'monkey').addV('D').as('d').property(single, 'animal', 'cow').addE('KNOWS').from('a').to('b').addE('KNOWS').from('a').to('c').addE('KNOWS').from('d').to('b').addE('KNOWS').from('d').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n)-[rel]->(x)
WHERE n.animal = x.animal
RETURN n, x

Output 1

13:00:19.702 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)-[rel]->(x)
WHERE n.animal = x.animal
RETURN n, x}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.703 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n)-[rel]->(x) WHERE n.animal = x.animal RETURN n, x
13:00:19.708 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').outE().inV().as('x').where(__.select('x').values('animal').as('  GENERATED2').select('n').values('animal').where(eq('  GENERATED2'))).select('n', 'x').project('n', 'x').by(__.select('n').valueMap().with('~tinkerpop.valueMap.tokens')).by(__.select('x').valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

n	x
(:A {animal: 'monkey'})	(:C {animal: 'monkey'})
(:D {animal: 'cow'})	(:B {animal: 'cow'})

And no side effects 0.000

Output 1

13:00:19.709 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.713 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.716 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.716 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.717 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.720 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.721 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.722 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.725 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.726 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.727 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return two subgraphs with bound undirected relationship

Steps

Given an empty graph 0.000

Output 1

13:00:19.734 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {value: 1})-[:REL {name: 'r'}]->(b:B {value: 2})

Output 1

13:00:19.737 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {value: 1})-[:REL {name: 'r'}]->(b:B {value: 2})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.737 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {value: 1})-[:REL {name: 'r'}]->(b:B {value: 2})
13:00:19.740 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'value', 1).addV('B').as('b').property(single, 'value', 2).addE('REL').from('a').to('b').property('name', 'r').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (a)-[r {name: 'r'}]-(b)
RETURN a, b

Output 1

13:00:19.761 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a)-[r {name: 'r'}]-(b)
RETURN a, b}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.762 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r {name: 'r'}]-(b) RETURN a, b
13:00:19.767 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').bothE().dedup().by(__.path()).has('name', eq('r')).otherV().as('b').select('a', 'b').project('a', 'b').by(__.select('a').valueMap().with('~tinkerpop.valueMap.tokens')).by(__.select('b').valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

a	b
(:B {value: 2})	(:A {value: 1})
(:A {value: 1})	(:B {value: 2})

And no side effects 0.000

Output 1

13:00:19.769 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.770 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.776 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.776 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.777 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.781 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.782 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.782 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.786 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.786 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.788 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return two subgraphs with bound undirected relationship and optional relationship

Steps

Given an empty graph 0.000

Output 1

13:00:19.789 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {value: 1})-[:REL {name: 'r1'}]->(b:B {value: 2})-[:REL {name: 'r2'}]->(c:C {value: 3})

Output 1

13:00:19.790 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {value: 1})-[:REL {name: 'r1'}]->(b:B {value: 2})-[:REL {name: 'r2'}]->(c:C {value: 3})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.791 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {value: 1})-[:REL {name: 'r1'}]->(b:B {value: 2})-[:REL {name: 'r2'}]->(c:C {value: 3})
13:00:19.796 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'value', 1).addV('B').as('b').property(single, 'value', 2).addE('REL').from('a').to('b').property('name', 'r1').addV('C').as('c').property(single, 'value', 3).addE('REL').from('b').to('c').property('name', 'r2').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (a)-[r {name: 'r1'}]-(b)
OPTIONAL MATCH (b)-[r2]-(c)
WHERE r <> r2
RETURN a, b, c

Output 1

13:00:19.821 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a)-[r {name: 'r1'}]-(b)
OPTIONAL MATCH (b)-[r2]-(c)
WHERE r <> r2
RETURN a, b, c}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.821 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r {name: 'r1'}]-(b) OPTIONAL MATCH (b)-[r2]-(c) WHERE r <> r2 RETURN a, b, c
13:00:19.830 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').bothE().dedup().by(__.path()).as('r').has('name', eq('r1')).otherV().as('b').choose(__.select('b').is(neq('  cypher.null')).bothE().dedup().by(__.path()).as('r2').otherV().as('c').where(__.select('r').where(neq('r2'))), __.select('b').is(neq('  cypher.null')).bothE().dedup().by(__.path()).as('r2').otherV().as('c').where(__.select('r').where(neq('r2'))), __.constant('  cypher.null').as('r2').as('c')).select('a', 'b', 'c').project('a', 'b', 'c').by(__.select('a').choose(neq('  cypher.null'), __.valueMap().with('~tinkerpop.valueMap.tokens'))).by(__.select('b').choose(neq('  cypher.null'), __.valueMap().with('~tinkerpop.valueMap.tokens'))).by(__.select('c').choose(neq('  cypher.null'), __.valueMap().with('~tinkerpop.valueMap.tokens')))

Then the result should be: 0.000

a	b	c
(:A {value: 1})	(:B {value: 2})	(:C {value: 3})
(:B {value: 2})	(:A {value: 1})	null

And no side effects 0.000

Output 1

13:00:19.834 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.835 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.838 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.839 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.839 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.842 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.843 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.843 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.846 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.847 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.848 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Rel type function works as expected

Steps

Given an empty graph 0.000

Output 1

13:00:19.849 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'}),
  (b:B {name: 'B'}),
  (c:C {name: 'C'}),
  (a)-[:KNOWS]->(b),
  (a)-[:HATES]->(c)

Output 1

13:00:19.850 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'}),
  (b:B {name: 'B'}),
  (c:C {name: 'C'}),
  (a)-[:KNOWS]->(b),
  (a)-[:HATES]->(c)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.850 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'}),   (b:B {name: 'B'}),   (c:C {name: 'C'}),   (a)-[:KNOWS]->(b),   (a)-[:HATES]->(c)
13:00:19.863 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addV('C').as('c').property(single, 'name', 'C').addE('KNOWS').from('a').to('b').addE('HATES').from('a').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n {name: 'A'})-[r]->(x)
WHERE type(r) = 'KNOWS'
RETURN x

Output 1

13:00:19.893 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n {name: 'A'})-[r]->(x)
WHERE type(r) = 'KNOWS'
RETURN x}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.893 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n {name: 'A'})-[r]->(x) WHERE type(r) = 'KNOWS' RETURN x
13:00:19.898 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().has('name', eq('A')).outE().as('r').inV().as('x').where(__.select('r').choose(neq('  cypher.null'), __.label().is(neq('vertex'))).is(neq('  cypher.null')).is(eq('KNOWS'))).select('x').project('x').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

x

(:B {name: 'B'})

And no side effects 0.000

Output 1

13:00:19.899 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.899 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.902 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.902 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.903 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.906 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.907 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.907 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.910 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.910 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.911 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Walk alternative relationships

Steps

Given an empty graph 0.000

Output 1

13:00:19.917 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a {name: 'A'}),
  (b {name: 'B'}),
  (c {name: 'C'}),
  (a)-[:KNOWS]->(b),
  (a)-[:HATES]->(c),
  (a)-[:WONDERS]->(c)

Output 1

13:00:19.918 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a {name: 'A'}),
  (b {name: 'B'}),
  (c {name: 'C'}),
  (a)-[:KNOWS]->(b),
  (a)-[:HATES]->(c),
  (a)-[:WONDERS]->(c)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.919 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a {name: 'A'}),   (b {name: 'B'}),   (c {name: 'C'}),   (a)-[:KNOWS]->(b),   (a)-[:HATES]->(c),   (a)-[:WONDERS]->(c)
13:00:19.923 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV().as('a').property(single, 'name', 'A').addV().as('b').property(single, 'name', 'B').addV().as('c').property(single, 'name', 'C').addE('KNOWS').from('a').to('b').addE('HATES').from('a').to('c').addE('WONDERS').from('a').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n)-[r]->(x)
WHERE type(r) = 'KNOWS' OR type(r) = 'HATES'
RETURN r

Output 1

13:00:19.955 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)-[r]->(x)
WHERE type(r) = 'KNOWS' OR type(r) = 'HATES'
RETURN r}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.955 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n)-[r]->(x) WHERE type(r) = 'KNOWS' OR type(r) = 'HATES' RETURN r
13:00:19.970 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().outE().as('r').inV().where(__.or(__.select('r').choose(neq('  cypher.null'), __.label().is(neq('vertex'))).is(neq('  cypher.null')).is(eq('KNOWS')), __.select('r').choose(neq('  cypher.null'), __.label().is(neq('vertex'))).is(neq('  cypher.null')).is(eq('HATES')))).select('r').project('r').by(__.project('  cypher.element', '  cypher.inv', '  cypher.outv').by(__.valueMap().with('~tinkerpop.valueMap.tokens')).by(__.inV().id()).by(__.outV().id()))

Then the result should be: 0.000

r

[:KNOWS]

[:HATES]

And no side effects 0.000

Output 1

13:00:19.971 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.972 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:19.974 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:19.975 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.975 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:19.979 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:19.979 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.980 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:19.983 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:19.986 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.988 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Handle OR in the WHERE clause

Steps

Given an empty graph 0.000

Output 1

13:00:19.994 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {p1: 12}),
  (b:B {p2: 13}),
  (c:C)

Output 1

13:00:19.995 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {p1: 12}),
  (b:B {p2: 13}),
  (c:C)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:19.995 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {p1: 12}),   (b:B {p2: 13}),   (c:C)
13:00:19.999 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').property(single, 'p1', 12).addV('B').property(single, 'p2', 13).addV('C').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n)
WHERE n.p1 = 12 OR n.p2 = 13
RETURN n

Output 1

13:00:20.024 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
WHERE n.p1 = 12 OR n.p2 = 13
RETURN n}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.024 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) WHERE n.p1 = 12 OR n.p2 = 13 RETURN n
13:00:20.029 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').where(__.or(__.select('n').values('p1').is(eq(12)), __.select('n').values('p2').is(eq(13)))).select('n').project('n').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

n

(:A {p1: 12})

(:B {p2: 13})

And no side effects 0.000

Output 1

13:00:20.031 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.031 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.034 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.036 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.036 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.039 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.043 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.043 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.046 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.047 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.048 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return a simple path

Steps

Given an empty graph 0.000

Output 1

13:00:20.053 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})

Output 1

13:00:20.055 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.056 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})
13:00:20.059 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addE('KNOWS').from('a').to('b').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a {name: 'A'})-->(b)
RETURN p

Output 1

13:00:20.079 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a {name: 'A'})-->(b)
RETURN p}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.079 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a {name: 'A'})-->(b) RETURN p
13:00:20.083 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').has('name', eq('A')).outE().aggregate('  cypher.path.edge.p').inV().path().from('a').project('p').by(__.is(neq('  cypher.unused')).project('  cypher.relationship', '  cypher.element').by(__.select('  cypher.path.edge.p').unfold().project('  cypher.id', '  cypher.inv', '  cypher.outv').by(__.id()).by(__.inV().id()).by(__.outV().id()).fold()).by(__.unfold().is(neq('  cypher.start')).valueMap().with('~tinkerpop.valueMap.tokens').fold()))

Then the result should be: 0.000

p

<(:A {name: 'A'})-[:KNOWS]->(:B {name: 'B'})>

And no side effects 0.000

Output 1

13:00:20.086 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.086 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.088 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.089 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.089 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.092 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.092 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.095 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.098 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.099 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.100 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return a three node path

Steps

Given an empty graph 0.000

Output 1

13:00:20.106 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})-[:KNOWS]->(c:C {name: 'C'})

Output 1

13:00:20.107 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})-[:KNOWS]->(c:C {name: 'C'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.107 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})-[:KNOWS]->(c:C {name: 'C'})
13:00:20.111 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addE('KNOWS').from('a').to('b').addV('C').as('c').property(single, 'name', 'C').addE('KNOWS').from('b').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a {name: 'A'})-[rel1]->(b)-[rel2]->(c)
RETURN p

Output 1

13:00:20.142 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a {name: 'A'})-[rel1]->(b)-[rel2]->(c)
RETURN p}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.142 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a {name: 'A'})-[rel1]->(b)-[rel2]->(c) RETURN p
13:00:20.152 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').has('name', eq('A')).outE().as('rel1').aggregate('  cypher.path.edge.p').inV().outE().as('rel2').aggregate('  cypher.path.edge.p').inV().path().from('a').as('p').where(__.select('rel1').where(neq('rel2'))).select('p').project('p').by(__.is(neq('  cypher.unused')).project('  cypher.relationship', '  cypher.element').by(__.select('  cypher.path.edge.p').unfold().project('  cypher.id', '  cypher.inv', '  cypher.outv').by(__.id()).by(__.inV().id()).by(__.outV().id()).fold()).by(__.unfold().is(neq('  cypher.start')).valueMap().with('~tinkerpop.valueMap.tokens').fold()))

Then the result should be: 0.000

p

<(:A {name: 'A'})-[:KNOWS]->(:B {name: 'B'})-[:KNOWS]->(:C {name: 'C'})>

And no side effects 0.000

Output 1

13:00:20.154 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.155 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.158 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.158 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.159 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.162 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.163 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.163 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.166 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.167 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.168 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Do not return anything because path length does not match

Steps

Given an empty graph 0.000

Output 1

13:00:20.178 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})

Output 1

13:00:20.179 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.180 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})
13:00:20.182 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addE('KNOWS').from('a').to('b').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (n)-->(x)
WHERE length(p) = 10
RETURN x

Output 1

13:00:20.210 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (n)-->(x)
WHERE length(p) = 10
RETURN x}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.210 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (n)-->(x) WHERE length(p) = 10 RETURN x
13:00:20.219 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').outE().aggregate('  cypher.path.edge.p').inV().as('x').path().from('n').as('p').where(__.select('p').count(local).math('(_-1)/2').is(neq('  cypher.null')).is(eq(10))).select('x').project('x').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

x

And no side effects 0.000

Output 1

13:00:20.225 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.232 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.234 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.235 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.235 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.237 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.238 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.238 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.241 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.241 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.242 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Pass the path length test

Steps

Given an empty graph 0.000

Output 1

13:00:20.247 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})

Output 1

13:00:20.247 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.248 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})
13:00:20.251 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addE('KNOWS').from('a').to('b').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (n)-->(x)
WHERE length(p) = 1
RETURN x

Output 1

13:00:20.277 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (n)-->(x)
WHERE length(p) = 1
RETURN x}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.277 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (n)-->(x) WHERE length(p) = 1 RETURN x
13:00:20.281 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').outE().aggregate('  cypher.path.edge.p').inV().as('x').path().from('n').as('p').where(__.select('p').count(local).math('(_-1)/2').is(neq('  cypher.null')).is(eq(1))).select('x').project('x').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

x

(:B {name: 'B'})

And no side effects 0.000

Output 1

13:00:20.283 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.283 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.285 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.286 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.286 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.289 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.290 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.291 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.294 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.295 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.296 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return relationships by fetching them from the path - starting from the end

Steps

Given an empty graph 0.000

Output 1

13:00:20.303 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(e:End)

Output 1

13:00:20.305 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(e:End)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.305 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(e:End)
13:00:20.307 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').addV('B').as('b').addE('REL').from('a').to('b').property('value', 1).addV('End').as('e').addE('REL').from('b').to('e').property('value', 2).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a)-[:REL*2..2]->(b:End)
RETURN relationships(p)

Output 1

13:00:20.337 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a)-[:REL*2..2]->(b:End) RETURN relationships(p)
13:00:20.342 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a)-[:REL*2..2]->(b:End)
RETURN relationships(p)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.344 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').times(2).repeat(__.outE('REL').as('  UNNAMED14').aggregate('  cypher.path.edge.p').inV()).hasLabel('End').path().from('a').as('p').optional(__.select(all, '  UNNAMED14').as('  UNNAMED14')).select('p').project('relationships(p)').by(__.map(__.unfold().is(cypherIsRelationship()).fold())).project('relationships(p)').by(__.select('relationships(p)').local(__.unfold().choose(neq('  cypher.null'), __.project('  cypher.element', '  cypher.inv', '  cypher.outv').by(__.valueMap().with('~tinkerpop.valueMap.tokens')).by(__.inV().id()).by(__.outV().id())).fold()))

Then the result should be: 0.000

relationships(p)

[[:REL {value: 1}], [:REL {value: 2}]]

And no side effects 0.000

Output 1

13:00:20.347 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.347 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.351 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.351 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.352 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.356 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.357 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.358 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.361 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.362 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.369 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return relationships by fetching them from the path

Steps

Given an empty graph 0.000

Output 1

13:00:20.370 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (s:Start)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:C)

Output 1

13:00:20.372 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (s:Start)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:C)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.372 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (s:Start)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:C)
13:00:20.379 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('Start').as('s').addV('B').as('b').addE('REL').from('s').to('b').property('value', 1).addV('C').as('c').addE('REL').from('b').to('c').property('value', 2).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a:Start)-[:REL*2..2]->(b)
RETURN relationships(p)

Output 1

13:00:20.405 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a:Start)-[:REL*2..2]->(b)
RETURN relationships(p)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.406 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a:Start)-[:REL*2..2]->(b) RETURN relationships(p)
13:00:20.411 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').hasLabel('Start').times(2).repeat(__.outE('REL').as('  UNNAMED20').aggregate('  cypher.path.edge.p').inV()).path().from('a').as('p').optional(__.select(all, '  UNNAMED20').as('  UNNAMED20')).select('p').project('relationships(p)').by(__.map(__.unfold().is(cypherIsRelationship()).fold())).project('relationships(p)').by(__.select('relationships(p)').local(__.unfold().choose(neq('  cypher.null'), __.project('  cypher.element', '  cypher.inv', '  cypher.outv').by(__.valueMap().with('~tinkerpop.valueMap.tokens')).by(__.inV().id()).by(__.outV().id())).fold()))

Then the result should be: 0.000

relationships(p)

[[:REL {value: 1}], [:REL {value: 2}]]

And no side effects 0.000

Output 1

13:00:20.413 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.414 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.418 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.418 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.419 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.423 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.423 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.424 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.427 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.428 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.436 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return relationships by collecting them as a list - directed, one way

Steps

Given an empty graph 0.000

Output 1

13:00:20.437 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(e:End)

Output 1

13:00:20.439 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(e:End)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.439 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(e:End)
13:00:20.443 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').addV('B').as('b').addE('REL').from('a').to('b').property('value', 1).addV('End').as('e').addE('REL').from('b').to('e').property('value', 2).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (a)-[r:REL*2..2]->(b:End)
RETURN r

Output 1

13:00:20.467 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a)-[r:REL*2..2]->(b:End)
RETURN r}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.467 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r:REL*2..2]->(b:End) RETURN r
13:00:20.473 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().times(2).repeat(__.outE('REL').as('r').inV()).hasLabel('End').optional(__.select(all, 'r').as('r')).select('r').project('r').by(__.local(__.unfold().choose(neq('  cypher.null'), __.project('  cypher.element', '  cypher.inv', '  cypher.outv').by(__.valueMap().with('~tinkerpop.valueMap.tokens')).by(__.inV().id()).by(__.outV().id())).fold()))

Then the result should be: 0.000

r

[[:REL {value: 1}], [:REL {value: 2}]]

And no side effects 0.000

Output 1

13:00:20.475 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.476 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.479 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.479 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.480 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.483 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.484 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.484 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.487 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.489 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.495 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return relationships by collecting them as a list - undirected, starting from two extremes

Steps

Given an empty graph 0.000

Output 1

13:00:20.496 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:End)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:End)

Output 1

13:00:20.498 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:End)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:End)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.499 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:End)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:End)
13:00:20.502 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('End').as('a').addV('B').as('b').addE('REL').from('a').to('b').property('value', 1).addV('End').as('c').addE('REL').from('b').to('c').property('value', 2).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (a)-[r:REL*2..2]-(b:End)
RETURN r

Output 1

13:00:20.526 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a)-[r:REL*2..2]-(b:End)
RETURN r}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.526 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r:REL*2..2]-(b:End) RETURN r
13:00:20.531 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').times(2).repeat(__.bothE('REL').dedup().by(__.path()).as('r').otherV()).simplePath().from('a').hasLabel('End').optional(__.select(all, 'r').as('r')).select('r').project('r').by(__.local(__.unfold().choose(neq('  cypher.null'), __.project('  cypher.element', '  cypher.inv', '  cypher.outv').by(__.valueMap().with('~tinkerpop.valueMap.tokens')).by(__.inV().id()).by(__.outV().id())).fold()))

Then the result should be: 0.000

r

[[:REL {value:1}], [:REL {value:2}]]

[[:REL {value:2}], [:REL {value:1}]]

And no side effects 0.000

Output 1

13:00:20.533 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.533 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.536 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.537 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.537 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.541 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.542 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.543 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.546 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.547 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.552 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return relationships by collecting them as a list - undirected, starting from one extreme

Steps

Given an empty graph 0.000

Output 1

13:00:20.554 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (s:Start)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:C)

Output 1

13:00:20.555 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (s:Start)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:C)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.555 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (s:Start)-[:REL {value: 1}]->(b:B)-[:REL {value: 2}]->(c:C)
13:00:20.559 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('Start').as('s').addV('B').as('b').addE('REL').from('s').to('b').property('value', 1).addV('C').as('c').addE('REL').from('b').to('c').property('value', 2).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (a:Start)-[r:REL*2..2]-(b)
RETURN r

Output 1

13:00:20.585 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (a:Start)-[r:REL*2..2]-(b)
RETURN r}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.586 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a:Start)-[r:REL*2..2]-(b) RETURN r
13:00:20.591 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').hasLabel('Start').times(2).repeat(__.bothE('REL').dedup().by(__.path()).as('r').otherV()).simplePath().from('a').optional(__.select(all, 'r').as('r')).select('r').project('r').by(__.local(__.unfold().choose(neq('  cypher.null'), __.project('  cypher.element', '  cypher.inv', '  cypher.outv').by(__.valueMap().with('~tinkerpop.valueMap.tokens')).by(__.inV().id()).by(__.outV().id())).fold()))

Then the result should be: 0.000

r

[[:REL {value: 1}], [:REL {value: 2}]]

And no side effects 0.000

Output 1

13:00:20.593 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.593 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.597 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.597 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.598 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.602 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.602 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.603 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.606 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.608 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.613 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return a var length path

Steps

Given an empty graph 0.000

Output 1

13:00:20.615 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'})-[:KNOWS {value: 1}]->(b:B {name: 'B'})-[:KNOWS {value: 2}]->(c:C {name: 'C'})

Output 1

13:00:20.616 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'})-[:KNOWS {value: 1}]->(b:B {name: 'B'})-[:KNOWS {value: 2}]->(c:C {name: 'C'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.617 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS {value: 1}]->(b:B {name: 'B'})-[:KNOWS {value: 2}]->(c:C {name: 'C'})
13:00:20.622 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addE('KNOWS').from('a').to('b').property('value', 1).addV('C').as('c').property(single, 'name', 'C').addE('KNOWS').from('b').to('c').property('value', 2).barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (n {name: 'A'})-[:KNOWS*1..2]->(x)
RETURN p

Output 1

13:00:20.642 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (n {name: 'A'})-[:KNOWS*1..2]->(x)
RETURN p}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.642 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (n {name: 'A'})-[:KNOWS*1..2]->(x) RETURN p
13:00:20.646 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').has('name', eq('A')).emit(__.loops().is(gte(1))).repeat(__.outE('KNOWS').as('  UNNAMED26').aggregate('  cypher.path.edge.p').inV()).times(2).path().from('n').as('p').optional(__.select(all, '  UNNAMED26').as('  UNNAMED26')).select('p').project('p').by(__.is(neq('  cypher.unused')).project('  cypher.relationship', '  cypher.element').by(__.select('  cypher.path.edge.p').unfold().project('  cypher.id', '  cypher.inv', '  cypher.outv').by(__.id()).by(__.inV().id()).by(__.outV().id()).fold()).by(__.unfold().is(neq('  cypher.start')).valueMap().with('~tinkerpop.valueMap.tokens').fold()))

Then the result should be: 0.000

p

<(:A {name: 'A'})-[:KNOWS {value: 1}]->(:B {name: 'B'})>

<(:A {name: 'A'})-[:KNOWS {value: 1}]->(:B {name: 'B'})-[:KNOWS {value: 2}]->(:C {name: 'C'})>

And no side effects 0.000

Output 1

13:00:20.648 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.649 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.651 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.652 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.652 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.655 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.656 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.656 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.659 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.660 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.661 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return a var length path of length zero

Steps

Given an empty graph 0.000

Output 1

13:00:20.662 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A)-[:REL]->(b:B)

Output 1

13:00:20.663 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A)-[:REL]->(b:B)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.663 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A)-[:REL]->(b:B)
13:00:20.665 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').addV('B').as('b').addE('REL').from('a').to('b').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a)-[*0..1]->(b)
RETURN a, b, length(p) AS l

Output 1

13:00:20.691 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a)-[*0..1]->(b) RETURN a, b, length(p) AS l
13:00:20.696 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').emit(__.loops().is(gte(0))).repeat(__.outE().as('  UNNAMED14').aggregate('  cypher.path.edge.p').inV()).times(1).as('b').path().from('a').as('p').optional(__.select(all, '  UNNAMED14').as('  UNNAMED14')).select('a', 'b', 'p').project('a', 'b', 'l').by(__.select('a')).by(__.select('b')).by(__.select('p').count(local).math('(_-1)/2')).project('a', 'b', 'l').by(__.select('a').valueMap().with('~tinkerpop.valueMap.tokens')).by(__.select('b').valueMap().with('~tinkerpop.valueMap.tokens')).by(__.select('l').identity())
13:00:20.696 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a)-[*0..1]->(b)
RETURN a, b, length(p) AS l}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

Then the result should be: 0.000

a	b	l
(:A)	(:A)	0
(:B)	(:B)	0
(:A)	(:B)	1

And no side effects 0.000

Output 1

13:00:20.698 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.698 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.702 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.702 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.702 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.706 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.706 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.707 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.710 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.710 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.716 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Return a named var length path of length zero

Steps

Given an empty graph 0.000

Output 1

13:00:20.722 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}

And having executed: 0.000

Doc string

CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})-[:FRIEND]->(c:C {name: 'C'})

Output 1

13:00:20.723 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})-[:FRIEND]->(c:C {name: 'C'})
13:00:20.726 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'})-[:FRIEND]->(c:C {name: 'C'})}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.727 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'A').addV('B').as('b').property(single, 'name', 'B').addE('KNOWS').from('a').to('b').addV('C').as('c').property(single, 'name', 'C').addE('FRIEND').from('b').to('c').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH p = (a {name: 'A'})-[:KNOWS*0..1]->(b)-[:FRIEND*0..1]->(c)
RETURN p

Output 1

13:00:20.752 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH p = (a {name: 'A'})-[:KNOWS*0..1]->(b)-[:FRIEND*0..1]->(c)
RETURN p}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.752 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a {name: 'A'})-[:KNOWS*0..1]->(b)-[:FRIEND*0..1]->(c) RETURN p
13:00:20.757 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('a').has('name', eq('A')).emit(__.loops().is(gte(0))).repeat(__.outE('KNOWS').as('  UNNAMED26').aggregate('  cypher.path.edge.p').inV()).times(1).emit(__.loops().is(gte(0))).repeat(__.outE('FRIEND').as('  UNNAMED45').aggregate('  cypher.path.edge.p').inV()).times(1).path().from('a').as('p').optional(__.select(all, '  UNNAMED45').as('  UNNAMED45')).optional(__.select(all, '  UNNAMED26').as('  UNNAMED26')).select('p').project('p').by(__.is(neq('  cypher.unused')).project('  cypher.relationship', '  cypher.element').by(__.select('  cypher.path.edge.p').unfold().project('  cypher.id', '  cypher.inv', '  cypher.outv').by(__.id()).by(__.inV().id()).by(__.outV().id()).fold()).by(__.unfold().is(neq('  cypher.start')).valueMap().with('~tinkerpop.valueMap.tokens').fold()))

Then the result should be: 0.000

p

<(:A {name: 'A'})>

<(:A {name: 'A'})-[:KNOWS]->(:B {name: 'B'})>

<(:A {name: 'A'})-[:KNOWS]->(:B {name: 'B'})-[:FRIEND]->(:C {name: 'C'})>

And no side effects 0.000

Output 1

13:00:20.758 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.759 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.761 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.761 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.761 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.764 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.764 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.764 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.766 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.767 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.768 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

0.000

Scenario Accept skip zero

Steps

Given any graph 0.000

Output 1

13:00:20.772 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.776 [Test worker] DEBUG o.a.t.g.driver.Client - 
CREATE (a:A {name: 'a'}),
       (b1:X {name: 'b1'}),
       (b2:X {name: 'b2'}),
       (b3:X {name: 'b3'}),
       (b4:X {name: 'b4'}),
       (c11:X {name: 'c11'}),
       (c12:X {name: 'c12'}),
       (c21:X {name: 'c21'}),
       (c22:X {name: 'c22'}),
       (c31:X {name: 'c31'}),
       (c32:X {name: 'c32'}),
       (c41:X {name: 'c41'}),
       (c42:X {name: 'c42'})
CREATE (a)-[:KNOWS]->(b1),
       (a)-[:KNOWS]->(b2),
       (a)-[:FOLLOWS]->(b3),
       (a)-[:FOLLOWS]->(b4)
CREATE (b1)-[:FRIEND]->(c11),
       (b1)-[:FRIEND]->(c12),
       (b2)-[:FRIEND]->(c21),
       (b2)-[:FRIEND]->(c22),
       (b3)-[:FRIEND]->(c31),
       (b3)-[:FRIEND]->(c32),
       (b4)-[:FRIEND]->(c41),
       (b4)-[:FRIEND]->(c42)
CREATE (b1)-[:FRIEND]->(b2),
       (b2)-[:FRIEND]->(b3),
       (b3)-[:FRIEND]->(b4),
       (b4)-[:FRIEND]->(b1);
    }} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.784 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher:  CREATE (a:A {name: 'a'}),        (b1:X {name: 'b1'}),        (b2:X {name: 'b2'}),        (b3:X {name: 'b3'}),        (b4:X {name: 'b4'}),        (c11:X {name: 'c11'}),        (c12:X {name: 'c12'}),        (c21:X {name: 'c21'}),        (c22:X {name: 'c22'}),        (c31:X {name: 'c31'}),        (c32:X {name: 'c32'}),        (c41:X {name: 'c41'}),        (c42:X {name: 'c42'}) CREATE (a)-[:KNOWS]->(b1),        (a)-[:KNOWS]->(b2),        (a)-[:FOLLOWS]->(b3),        (a)-[:FOLLOWS]->(b4) CREATE (b1)-[:FRIEND]->(c11),        (b1)-[:FRIEND]->(c12),        (b2)-[:FRIEND]->(c21),        (b2)-[:FRIEND]->(c22),        (b3)-[:FRIEND]->(c31),        (b3)-[:FRIEND]->(c32),        (b4)-[:FRIEND]->(c41),        (b4)-[:FRIEND]->(c42) CREATE (b1)-[:FRIEND]->(b2),        (b2)-[:FRIEND]->(b3),        (b3)-[:FRIEND]->(b4),        (b4)-[:FRIEND]->(b1);     
13:00:20.805 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.addV('A').as('a').property(single, 'name', 'a').addV('X').as('b1').property(single, 'name', 'b1').addV('X').as('b2').property(single, 'name', 'b2').addV('X').as('b3').property(single, 'name', 'b3').addV('X').as('b4').property(single, 'name', 'b4').addV('X').as('c11').property(single, 'name', 'c11').addV('X').as('c12').property(single, 'name', 'c12').addV('X').as('c21').property(single, 'name', 'c21').addV('X').as('c22').property(single, 'name', 'c22').addV('X').as('c31').property(single, 'name', 'c31').addV('X').as('c32').property(single, 'name', 'c32').addV('X').as('c41').property(single, 'name', 'c41').addV('X').as('c42').property(single, 'name', 'c42').addE('KNOWS').from('a').to('b1').addE('KNOWS').from('a').to('b2').addE('FOLLOWS').from('a').to('b3').addE('FOLLOWS').from('a').to('b4').addE('FRIEND').from('b1').to('c11').addE('FRIEND').from('b1').to('c12').addE('FRIEND').from('b2').to('c21').addE('FRIEND').from('b2').to('c22').addE('FRIEND').from('b3').to('c31').addE('FRIEND').from('b3').to('c32').addE('FRIEND').from('b4').to('c41').addE('FRIEND').from('b4').to('c42').addE('FRIEND').from('b1').to('b2').addE('FRIEND').from('b2').to('b3').addE('FRIEND').from('b3').to('b4').addE('FRIEND').from('b4').to('b1').barrier().limit(0)

When executing query: 0.000

Doc string

MATCH (n)
WHERE 1 = 0
RETURN n SKIP 0

Output 1

13:00:20.838 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
WHERE 1 = 0
RETURN n SKIP 0}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.839 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) WHERE 1 = 0 RETURN n SKIP 0
13:00:20.841 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().as('n').limit(0).select('n').project('n').by(__.valueMap().with('~tinkerpop.valueMap.tokens'))

Then the result should be: 0.000

n

And no side effects 0.000

Output 1

13:00:20.844 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.844 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n)
13:00:20.846 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id())
13:00:20.847 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.847 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r)
13:00:20.849 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id())
13:00:20.850 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n)
UNWIND labels(n) AS label
RETURN DISTINCT label}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.850 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label
13:00:20.852 [gremlin-server-worker-1] INFO  o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().map(__.label().is(neq('vertex')).fold()).unfold().project('label').by(__.identity()).dedup()
13:00:20.853 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().as('V').properties().project('nodeId', 'key', 'value').by(__.select('V').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
13:00:20.853 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().outE().as('E').properties().project('relId', 'key', 'value').by(__.select('E').id()).by(__.key()).by(__.value())}} to - Connection{host=Host{address=localhost/127.0.0.1:44141, hostUri=ws://localhost:44141/gremlin}}
-labels:        0
+labels:        0
+nodes:         0
-nodes:         0
-properties:    0
+properties:    0
-relationships: 0
+relationships: 0

	Steps						Scenarios			Features
Feature	Passed	Failed	Skipped	Pending	Undefined	Total	Passed	Failed	Total	Duration	Status
MatchAcceptance	150	0	0	0	0	150	30	0	30	0.000	Passed

Feature Report