Project Number Date
cypher-for-gremlin 1.0.4 05 Nov 2019, 16:13

Feature Report

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 MatchAcceptance
0.000
Given an empty graph 0.000

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

And having executed: 0.000
CREATE (:Label1)<-[:TYPE]-(:Label2)

16:12:00.367 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE (:Label1)<-[:TYPE]-(:Label2)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.367 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:Label1)<-[:TYPE]-(:Label2) 16:12:00.369 [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
MATCH p = (a:Label1)<--(:Label2)
RETURN p

16:12:00.400 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.400 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a:Label1)<--(:Label2) RETURN p 16:12:00.403 [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

16:12:00.404 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.405 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.407 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:00.407 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.407 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:00.411 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:00.412 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.412 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:00.415 [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() 16:12:00.431 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.435 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

And having executed: 0.000
CREATE (:Label1)<-[:T1]-(:Label2)-[:T2]->(:Label3)

16:12:00.440 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.440 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:Label1)<-[:T1]-(:Label2)-[:T2]->(:Label3) 16:12:00.444 [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
MATCH p = (a:Label1)<--(:Label2)--()
RETURN p

16:12:00.471 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.471 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a:Label1)<--(:Label2)--() RETURN p 16:12:00.476 [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

16:12:00.479 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.479 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.482 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:00.482 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.482 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:00.485 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:00.485 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.485 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:00.488 [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() 16:12:00.488 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.493 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

And having executed: 0.000
CREATE ({value: 1}),
  ({value: 2}),
  ({value: 3})

16:12:00.500 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.500 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({value: 1}), ({value: 2}), ({value: 3}) 16:12:00.503 [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
MATCH (n), (m)
RETURN n.value AS n, m.value AS m

16:12:00.529 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.529 [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 16:12:00.532 [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

16:12:00.534 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.534 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.536 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:00.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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.537 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:00.540 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:00.544 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.544 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:00.548 [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() 16:12:00.551 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:00.558 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.559 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:A)-[:T {foo: 'bar'}]->(:B {name: 'me'}) 16:12:00.562 [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
MATCH (a)-[r]->(b)
WHERE r.foo = $param
RETURN b

16:12:00.592 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.592 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r]->(b) WHERE r.foo = $param RETURN b 16:12:00.601 [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

16:12:00.603 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.607 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.613 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:00.615 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.615 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:00.620 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:00.620 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.621 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:00.627 [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() 16:12:00.629 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.633 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:00.636 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.636 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({name: 'Someone'})<-[:X]-()-[:X]->({name: 'Andres'}) 16:12:00.649 [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
MATCH ()-[rel:X]-(a)
WHERE a.name = 'Andres'
RETURN a

16:12:00.724 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.724 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[rel:X]-(a) WHERE a.name = 'Andres' RETURN a 16:12:00.748 [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

16:12:00.749 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.751 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.756 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:00.757 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.757 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:00.765 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:00.766 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.766 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:00.769 [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() 16:12:00.773 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.785 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

And having executed: 0.000
CREATE ({name: 'Someone'})

16:12:00.799 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({name: 'Someone'}) 16:12:00.800 [Test worker] DEBUG o.a.t.g.driver.Client - CREATE ({name: 'Someone'})}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.803 [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
MATCH (a)
WITH a.name AS a
RETURN a

16:12:00.857 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a) WITH a.name AS a RETURN a 16:12:00.868 [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()) 16:12:00.868 [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:34669, hostUri=ws://localhost:34669/gremlin}}

Then the result should be: 0.000
a
'Someone'
And no side effects 0.000

16:12:00.869 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.873 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:00.873 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.874 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:00.876 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.882 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:00.887 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.889 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:00.895 [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() 16:12:00.900 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.901 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:00.914 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.917 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (:A)<-[:KNOWS {name: 'monkey'}]-()-[:KNOWS {name: 'woot'}]->(:B) 16:12:00.936 [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
MATCH (node)-[r:KNOWS]->(a)
WHERE r.name = 'monkey'
RETURN a

16:12:00.985 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.985 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (node)-[r:KNOWS]->(a) WHERE r.name = 'monkey' RETURN a 16:12:00.992 [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

16:12:00.994 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:00.995 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:00.998 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.000 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.001 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.006 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.008 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.010 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.016 [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() 16:12:01.017 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.030 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.034 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.035 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE ({value: 1, name: 'King Kong'}), ({value: 2, name: 'Ann Darrow'}) 16:12:01.038 [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
MATCH (n)
WITH n.name AS n
RETURN n

16:12:01.082 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) WITH n.name AS n RETURN n 16:12:01.088 [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()) 16:12:01.088 [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:34669, hostUri=ws://localhost:34669/gremlin}}

Then the result should be: 0.000
n
'Ann Darrow'
'King Kong'
And no side effects 0.000

16:12:01.089 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.095 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.095 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.096 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.096 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.101 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.111 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.115 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.118 [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() 16:12:01.126 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.129 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.139 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.139 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {value: 1})-[:KNOWS]->(b:B {value: 2}) 16:12:01.144 [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
MATCH (n1)-[rel:KNOWS]->(n2)
RETURN n1, n2

16:12:01.174 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.174 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n1)-[rel:KNOWS]->(n2) RETURN n1, n2 16:12:01.179 [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

16:12:01.181 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.181 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.184 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.184 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.184 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.187 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.188 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.188 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.190 [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() 16:12:01.191 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.193 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.200 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.200 [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}) 16:12:01.204 [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
MATCH ()-[rel:KNOWS]->(x)
RETURN x

16:12:01.238 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.239 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[rel:KNOWS]->(x) RETURN x 16:12:01.242 [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

16:12:01.245 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.245 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.249 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.249 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.249 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.252 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.256 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.257 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.261 [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() 16:12:01.262 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.263 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.270 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.270 [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}) 16:12:01.272 [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
MATCH (n)-->(a)-->(b)
RETURN b

16:12:01.299 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.300 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n)-->(a)-->(b) RETURN b 16:12:01.303 [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

16:12:01.304 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.304 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.307 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.308 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.308 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.313 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.314 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.315 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.318 [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() 16:12:01.318 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.319 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

And having executed: 0.000
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)

16:12:01.326 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.328 [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) 16:12:01.334 [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
MATCH (n)-[rel]->(x)
WHERE n.animal = x.animal
RETURN n, x

16:12:01.360 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.361 [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 16:12:01.367 [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

16:12:01.368 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.368 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.371 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.371 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.371 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.374 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.374 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.374 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.378 [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() 16:12:01.379 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.381 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.388 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.388 [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}) 16:12:01.391 [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
MATCH (a)-[r {name: 'r'}]-(b)
RETURN a, b

16:12:01.408 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.408 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r {name: 'r'}]-(b) RETURN a, b 16:12:01.418 [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

16:12:01.420 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.420 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.425 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.426 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.426 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.436 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.438 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.439 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.445 [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() 16:12:01.447 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.448 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.454 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.455 [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}) 16:12:01.460 [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
MATCH (a)-[r {name: 'r1'}]-(b)
OPTIONAL MATCH (b)-[r2]-(c)
WHERE r <> r2
RETURN a, b, c

16:12:01.491 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.491 [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 16:12:01.508 [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

16:12:01.514 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.516 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.520 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.521 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.521 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.528 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.533 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.535 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.540 [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() 16:12:01.541 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.544 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.550 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.550 [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) 16:12:01.554 [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
MATCH (n {name: 'A'})-[r]->(x)
WHERE type(r) = 'KNOWS'
RETURN x

16:12:01.620 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.620 [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 16:12:01.628 [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

16:12:01.630 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.632 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.637 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.637 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.637 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.644 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.645 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.645 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.648 [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() 16:12:01.649 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.650 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.656 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.656 [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) 16:12:01.661 [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
MATCH (n)-[r]->(x)
WHERE type(r) = 'KNOWS' OR type(r) = 'HATES'
RETURN r

16:12:01.686 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.687 [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 16:12:01.702 [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

16:12:01.703 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.704 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.706 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.710 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.712 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.716 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.717 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.717 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.720 [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() 16:12:01.727 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.729 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.738 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.738 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {p1: 12}), (b:B {p2: 13}), (c:C) 16:12:01.742 [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
MATCH (n)
WHERE n.p1 = 12 OR n.p2 = 13
RETURN n

16:12:01.773 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.773 [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 16:12:01.780 [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

16:12:01.784 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.785 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.788 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.790 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.790 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.798 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.803 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.803 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.808 [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() 16:12:01.808 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.812 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.823 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'}) 16:12:01.828 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.830 [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
MATCH p = (a {name: 'A'})-->(b)
RETURN p

16:12:01.865 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.865 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a {name: 'A'})-->(b) RETURN p 16:12:01.871 [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

16:12:01.874 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.875 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.882 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.883 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.884 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.887 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.888 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.889 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.895 [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() 16:12:01.897 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.898 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.907 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.907 [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'}) 16:12:01.918 [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
MATCH p = (a {name: 'A'})-[rel1]->(b)-[rel2]->(c)
RETURN p

16:12:01.953 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.953 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a {name: 'A'})-[rel1]->(b)-[rel2]->(c) RETURN p 16:12:01.958 [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

16:12:01.964 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.965 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:01.967 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:01.968 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.968 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:01.972 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:01.972 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.973 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:01.976 [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() 16:12:01.978 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.980 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:01.989 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:01.989 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'}) 16:12:01.992 [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
MATCH p = (n)-->(x)
WHERE length(p) = 10
RETURN x

16:12:02.025 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.025 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (n)-->(x) WHERE length(p) = 10 RETURN x 16:12:02.035 [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

16:12:02.042 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.051 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.054 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.055 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.055 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.058 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.061 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.062 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.065 [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() 16:12:02.066 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.068 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.075 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.075 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A {name: 'A'})-[:KNOWS]->(b:B {name: 'B'}) 16:12:02.082 [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
MATCH p = (n)-->(x)
WHERE length(p) = 1
RETURN x

16:12:02.108 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.108 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (n)-->(x) WHERE length(p) = 1 RETURN x 16:12:02.117 [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

16:12:02.118 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.119 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.121 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.122 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.122 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.126 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.128 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.129 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.133 [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() 16:12:02.135 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.136 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.147 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.147 [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) 16:12:02.152 [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
MATCH p = (a)-[:REL*2..2]->(b:End)
RETURN relationships(p)

16:12:02.175 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.175 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a)-[:REL*2..2]->(b:End) RETURN relationships(p) 16:12:02.182 [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

16:12:02.189 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.189 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.191 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.192 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.192 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.197 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.197 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.198 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.201 [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() 16:12:02.201 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.205 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.207 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.207 [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) 16:12:02.212 [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
MATCH p = (a:Start)-[:REL*2..2]->(b)
RETURN relationships(p)

16:12:02.235 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.236 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (a:Start)-[:REL*2..2]->(b) RETURN relationships(p) 16:12:02.240 [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

16:12:02.241 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.241 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.245 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.246 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.246 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.251 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.251 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.251 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.255 [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() 16:12:02.256 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.260 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.263 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.263 [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) 16:12:02.268 [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
MATCH (a)-[r:REL*2..2]->(b:End)
RETURN r

16:12:02.292 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.292 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r:REL*2..2]->(b:End) RETURN r 16:12:02.307 [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

16:12:02.311 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.311 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.316 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.317 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.318 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.321 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.322 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.322 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.325 [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() 16:12:02.325 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.330 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.335 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.335 [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) 16:12:02.339 [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
MATCH (a)-[r:REL*2..2]-(b:End)
RETURN r

16:12:02.368 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a)-[r:REL*2..2]-(b:End) RETURN r 16:12:02.368 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.372 [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

16:12:02.374 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.374 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.381 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.383 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.384 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.387 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.387 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.388 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.390 [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() 16:12:02.391 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.400 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.403 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.403 [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) 16:12:02.406 [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
MATCH (a:Start)-[r:REL*2..2]-(b)
RETURN r

16:12:02.431 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (a:Start)-[r:REL*2..2]-(b) RETURN r 16:12:02.436 [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())) 16:12:02.436 [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:34669, hostUri=ws://localhost:34669/gremlin}}

Then the result should be: 0.000
r
[[:REL {value: 1}], [:REL {value: 2}]]
And no side effects 0.000

16:12:02.440 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.441 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.444 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.448 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.448 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.452 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.452 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.452 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.455 [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() 16:12:02.455 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.464 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.466 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.466 [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'}) 16:12:02.469 [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
MATCH p = (n {name: 'A'})-[:KNOWS*1..2]->(x)
RETURN p

16:12:02.486 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.486 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH p = (n {name: 'A'})-[:KNOWS*1..2]->(x) RETURN p 16:12:02.490 [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

16:12:02.492 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.492 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.497 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.498 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.499 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.502 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.502 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.502 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.505 [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() 16:12:02.505 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.506 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

And having executed: 0.000
CREATE (a:A)-[:REL]->(b:B)

16:12:02.508 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.508 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: CREATE (a:A)-[:REL]->(b:B) 16:12:02.511 [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
MATCH p = (a)-[*0..1]->(b)
RETURN a, b, length(p) AS l

16:12:02.539 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.540 [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 16:12:02.547 [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())

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

16:12:02.551 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.551 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.553 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.554 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.554 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.557 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.557 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.558 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.564 [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() 16:12:02.565 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.572 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given an empty graph 0.000

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

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

16:12:02.581 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.582 [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'}) 16:12:02.585 [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
MATCH p = (a {name: 'A'})-[:KNOWS*0..1]->(b)-[:FRIEND*0..1]->(c)
RETURN p

16:12:02.616 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.616 [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 16:12:02.622 [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

16:12:02.624 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.624 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.628 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.629 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH ()-[r]->() RETURN id(r)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.629 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.633 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.634 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.635 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.638 [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() 16:12:02.639 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.640 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0

0.000
Given any graph 0.000

16:12:02.649 [Test worker] DEBUG o.a.t.g.driver.Client - g.V().drop()}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.651 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.651 [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); 16:12:02.669 [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
MATCH (n)
WHERE 1 = 0
RETURN n SKIP 0

16:12:02.704 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.704 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) WHERE 1 = 0 RETURN n SKIP 0 16:12:02.708 [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

16:12:02.712 [Test worker] DEBUG o.a.t.g.driver.Client - MATCH (n) RETURN id(n)}} to - Connection{host=Host{address=localhost/127.0.0.1:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.713 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) RETURN id(n) 16:12:02.715 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.V().project('id(n)').by(__.id()) 16:12:02.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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.716 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH ()-[r]->() RETURN id(r) 16:12:02.718 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Gremlin: g.E().project('id(r)').by(__.id()) 16:12:02.718 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.718 [gremlin-server-worker-1] INFO o.o.g.s.o.c.CypherOpProcessor - Cypher: MATCH (n) UNWIND labels(n) AS label RETURN DISTINCT label 16:12:02.721 [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() 16:12:02.721 [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:34669, hostUri=ws://localhost:34669/gremlin}} 16:12:02.722 [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:34669, hostUri=ws://localhost:34669/gremlin}} -labels: 0 +labels: 0 +nodes: 0 -nodes: 0 -properties: 0 +properties: 0 -relationships: 0 +relationships: 0