async def _add_edge(self, edge):
"""Convenience function for generating crud traversals."""
props = mapper.map_props_to_db(edge, edge.__mapping__)
traversal = self._g.V(Binding('sid', edge.source.id))
traversal = traversal.addE(edge.__mapping__._label)
traversal = traversal.to(__.V(Binding('tid', edge.target.id)))
return await self._add_properties(traversal, props, edge)
async def test_unregistered_edge_desialization(self, app):
session = await app.session()
p1 = await session.g.addV('person').oneOrNone()
p2 = await session.g.addV('person').oneOrNone()
e1 = await session.g.V(Binding('p1_id', p1.id)).addE('unregistered').to(
session.g.V(Binding('p2_id', p2.id))).property('how_long', 1).oneOrNone()
assert isinstance(e1, element.GenericEdge)
assert e1.how_long == 1
assert e1.__label__ == 'unregistered'
await app.close()
async def test_edge_desialization(self, app, knows_class):
session = await app.session()
p1 = await session.g.addV('person').next()
p2 = await session.g.addV('person').next()
e1 = await session.g.V(Binding('p1_id', p1.id)).addE('knows').to(
session.g.V(Binding('p2_id', p2.id))).property(
knows_class.notes, 'somehow').property('how_long', 1).next()
assert isinstance(e1, knows_class)
assert e1.notes == 'somehow'
assert e1.how_long == 1
await app.close()
async def test_remove_vertex(self, app, person):
session = await app.session()
person.name = 'dave'
person.age = 35
await session.save(person)
result = await session.g.V(Binding('vid', person.id)).oneOrNone()
assert result is person
rid = result.id
await session.remove_vertex(person)
result = await session.g.V(Binding('rid', rid)).oneOrNone()
assert not result
await app.close()
async def _update_vertex_properties(self, vertex, traversal, props):
traversal, removals, metaprops = self._add_properties(traversal, props)
for k in removals:
await self._g.V(Binding('vid', vertex.id)).properties(k).drop().oneOrNone()
result = await self._simple_traversal(traversal, vertex)
if metaprops:
removals = await self._add_metaprops(result, metaprops)
for db_name, key, value in removals:
await self._g.V(Binding('vid', vertex.id)).properties(
db_name).has(key, value).drop().oneOrNone()
traversal = self._g.V(Binding('vid', vertex.id))
result = await self._simple_traversal(traversal, vertex)
return result
async def test_non_element_deserialization(self, app):
session = await app.session()
p1 = await session.g.addV('person').property(
'name', 'leif').oneOrNone()
one = await session.g.V(Binding('p1_id', p1.id)).count().oneOrNone()
assert one == 1
await app.close()
async def _update_edge_properties(self, edge, traversal, props):
traversal, removals, _ = self._add_properties(traversal, props)
eid = edge.id
if isinstance(eid, dict):
eid = Binding('eid', edge.id)
for k in removals:
await self._g.E(eid).properties(k).drop().oneOrNone()
return await self._simple_traversal(traversal, edge)
async def test_property_deserialization(self, app):
# In a future version this should deserialize to a goblin vert prop???
session = await app.session()
p1 = await session.g.addV('person').property('name', 'leif').next()
traversal = session.g.V(Binding('p1_id', p1.id)).properties('name')
name = await traversal.next()
assert name.value == 'leif'
assert name.label == 'name'
await app.close()
async def test_remove_edge(self, app, person_class, place_class,
lives_in_class):
session = await app.session()
jon = person_class()
jon.name = 'jonathan'
jon.age = 38
montreal = place_class()
montreal.name = 'Montreal'
lives_in = lives_in_class(jon, montreal)
session.add(jon, montreal, lives_in)
await session.flush()
result = await session.g.E(Binding('eid', lives_in.id)).next()
assert result is lives_in
rid = result.id
await session.remove_edge(lives_in)
result = await session.g.E(Binding('rid', rid)).next()
assert not result
await app.close()
async def test_remove_vertex_foreign_session(self, app, person):
session1 = await app.session()
session2 = await app.session()
person.name = 'dave'
person.age = 35
await session1.save(person)
result = await session1.g.V(Binding('vid', person.id)).next()
assert result is person
rid = result.id
await session2.remove_vertex(person)
result = await session2.g.V(Binding('rid', rid)).next()
assert not result
result = await session1.g.V(Binding('vid', person.id)).next()
assert result is None
# This is why we warn
assert rid in session1.current
assert person is session1.current[rid]
await app.close()
async def get_vertex(self, vertex):
"""
Get a vertex from the db. Vertex must have id.
:param goblin.element.Vertex element: Vertex to be retrieved
:returns: :py:class:`Vertex<goblin.element.Vertex>` | None
"""
return await self.g.V(Binding('vid', vertex.id)).next()
async def test_property_deserialization(self, app):
session = await app.session()
p1 = await session.g.addV('person').property(
'name', 'leif').oneOrNone()
traversal = session.g.V(Binding('p1_id', p1.id)).properties('name')
name = await traversal.oneOrNone()
assert name['value'] == 'leif'
assert name['label'] == 'name'
await app.close()
async def _update_vertex(self, vertex):
"""
Update a vertex, generally to change/remove property values.
:param goblin.element.Vertex vertex: Vertex to be updated
:returns: :py:class:`Vertex<goblin.element.Vertex>` object
"""
props = mapper.map_props_to_db(vertex, vertex.__mapping__)
traversal = self._g.V(Binding('vid', vertex.id))
return await self._update_vertex_properties(vertex, traversal, props)
async def _add_vertex(self, vertex):
"""Convenience function for generating crud traversals."""
props = mapper.map_props_to_db(vertex, vertex.__mapping__)
traversal = self._g.addV(vertex.__mapping__.label)
traversal, _, metaprops = self._add_properties(traversal, props)
result = await self._simple_traversal(traversal, vertex)
if metaprops:
await self._add_metaprops(result, metaprops)
traversal = self._g.V(Binding('vid', vertex.id))
result = await self._simple_traversal(traversal, vertex)
return result
async def test_submit_traversal(remote_graph, remote_connection):
g = remote_graph.traversal().withRemote(remote_connection)
resp = g.addV('person').property('name', 'leifur').valueMap(True)
leif = await resp.next()
assert leif['name'][0] == 'leifur'
assert leif[T.label] == 'person'
resp = g.V(Binding('vid', leif[T.id])).drop()
none = await resp.next()
assert none is None
await remote_connection.close()
async def remove_vertex(self, vertex):
"""
Remove a vertex from the db.
:param goblin.element.Vertex vertex: Vertex to be removed
"""
traversal = self._g.V(Binding('vid', vertex.id)).drop()
result = await self._simple_traversal(traversal, vertex)
hashable_id = self._get_hashable_id(vertex.id)
vertex = self.current.pop(hashable_id)
del vertex
return result
async def get_edge(self, edge):
"""
Get a edge from the db. Edge must have id.
:param goblin.element.Edge element: Edge to be retrieved
:returns: :py:class:`Edge<goblin.element.Edge>` | None
"""
eid = edge.id
if isinstance(eid, dict):
eid = Binding('eid', edge.id)
return await self.g.E(eid).next()
async def _add_metaprops(self, result, metaprops):
potential_removals = []
for metaprop in metaprops:
db_name, (binding, value), metaprops = metaprop
for key, val in metaprops.items():
if val:
traversal = self._g.V(Binding('vid', result.id)).properties(
db_name).hasValue(value).property(key, val)
await traversal.oneOrNone()
else:
potential_removals.append((db_name, key, value))
return potential_removals
async def test_remove_edge_foreign_session(self, app, person_class,
place_class, lives_in_class):
session1 = await app.session()
session2 = await app.session()
jon = person_class()
jon.name = 'jonathan'
jon.age = 38
montreal = place_class()
montreal.name = 'Montreal'
lives_in = lives_in_class(jon, montreal)
session1.add(jon, montreal, lives_in)
await session1.flush()
result = await session1.g.E(Binding('eid', lives_in.id)).next()
assert result is lives_in
rid = result.id
await session2.remove_edge(lives_in)
result = await session1.g.E(Binding('rid', rid)).next()
assert not result
# This is why whe warm
assert rid in session1.current
assert lives_in is session1.current[rid]
await app.close()
async def _update_edge(self, edge):
"""
Update an edge, generally to change/remove property values.
:param goblin.element.Edge edge: Edge to be updated
:returns: :py:class:`Edge<goblin.element.Edge>` object
"""
props = mapper.map_props_to_db(edge, edge.__mapping__)
eid = edge.id
if isinstance(eid, dict):
eid = Binding('eid', edge.id)
traversal = self._g.E(eid)
return await self._update_edge_properties(edge, traversal, props)
async def remove_edge(self, edge):
"""
Remove an edge from the db.
:param goblin.element.Edge edge: Element to be removed
"""
eid = edge.id
if isinstance(eid, dict):
eid = Binding('eid', edge.id)
traversal = self._g.E(eid).drop()
result = await self._simple_traversal(traversal, edge)
hashable_id = self._get_hashable_id(edge.id)
edge = self.current.pop(hashable_id)
del edge
return result
async def test_submit_traversal(event_loop, remote_graph, aliases, gremlin_host, gremlin_port):
cluster = await driver.Cluster.open(
event_loop, aliases=aliases, hosts=[gremlin_host], port=gremlin_port,
message_serializer=serializer.GraphSONMessageSerializer)
client = await cluster.connect()
g = remote_graph.traversal().withRemote(client)
resp = g.addV('person').property('name', 'leifur')
leif = await resp.next()
resp.traversers.close()
assert leif['properties']['name'][0]['value'] == 'leifur'
assert leif['label'] == 'person'
resp = g.V(Binding('vid', leif['id'])).drop()
none = await resp.next()
assert none is None
await cluster.close()
async def remove_vertex(self, vertex):
"""
Remove a vertex from the db.
:param goblin.element.Vertex vertex: Vertex to be removed
"""
traversal = self._g.V(Binding('vid', vertex.id)).drop()
result = await self._simple_traversal(traversal, vertex)
hashable_id = self._get_hashable_id(vertex.id)
if hashable_id in self.current:
vertex = self.current.pop(hashable_id)
else:
msg = 'Vertex {} does not belong to this session obj {}'.format(
vertex, self)
logger.warning(msg)
del vertex
return result
async def remove_edge(self, edge):
"""
Remove an edge from the db.
:param goblin.element.Edge edge: Element to be removed
"""
eid = edge.id
if isinstance(eid, dict):
eid = Binding('eid', edge.id)
traversal = self._g.E(eid).drop()
result = await self._simple_traversal(traversal, edge)
hashable_id = self._get_hashable_id(edge.id)
if hashable_id in self.current:
edge = self.current.pop(hashable_id)
else:
msg = 'Edge {} does not belong to this session obj {}'.format(
edge, self)
logger.warning(msg)
del edge
return result
def test_bytecode(self):
g = traversal().withGraph(Graph())
bytecode = g.V().out("created").bytecode
assert 0 == len(bytecode.bindings.keys())
assert 0 == len(bytecode.source_instructions)
assert 2 == len(bytecode.step_instructions)
assert "V" == bytecode.step_instructions[0][0]
assert "out" == bytecode.step_instructions[1][0]
assert "created" == bytecode.step_instructions[1][1]
assert 1 == len(bytecode.step_instructions[0])
assert 2 == len(bytecode.step_instructions[1])
##
bytecode = g.withSack(1).E().groupCount().by("weight").bytecode
assert 0 == len(bytecode.bindings.keys())
assert 1 == len(bytecode.source_instructions)
assert "withSack" == bytecode.source_instructions[0][0]
assert 1 == bytecode.source_instructions[0][1]
assert 3 == len(bytecode.step_instructions)
assert "E" == bytecode.step_instructions[0][0]
assert "groupCount" == bytecode.step_instructions[1][0]
assert "by" == bytecode.step_instructions[2][0]
assert "weight" == bytecode.step_instructions[2][1]
assert 1 == len(bytecode.step_instructions[0])
assert 1 == len(bytecode.step_instructions[1])
assert 2 == len(bytecode.step_instructions[2])
##
bytecode = g.V(Bindings.of('a', [1, 2, 3])) \
.out(Bindings.of('b', 'created')) \
.where(__.in_(Bindings.of('c', 'created'), Bindings.of('d', 'knows')) \
.count().is_(Bindings.of('e', P.gt(2)))).bytecode
assert 5 == len(bytecode.bindings.keys())
assert [1, 2, 3] == bytecode.bindings['a']
assert 'created' == bytecode.bindings['b']
assert 'created' == bytecode.bindings['c']
assert 'knows' == bytecode.bindings['d']
assert P.gt(2) == bytecode.bindings['e']
assert Binding('b', 'created') == bytecode.step_instructions[1][1]
assert 'binding[b=created]' == str(bytecode.step_instructions[1][1])
assert isinstance(hash(bytecode.step_instructions[1][1]), int)
def test_binding(self):
x = Binding("name", "marko")
output = self.graphbinary_reader.readObject(
self.graphbinary_writer.writeObject(x))
assert x == output
async def _check_edge(self, edge):
"""Used to check for existence, does not update session edge"""
eid = edge.id
if isinstance(eid, dict):
eid = Binding('eid', edge.id)
return await self._g.E(eid).next()
async def _check_vertex(self, vertex):
"""Used to check for existence, does not update session vertex"""
msg = await self._g.V(Binding('vid', vertex.id)).next()
return msg
def objectify(cls, buff, reader, nullable=True):
return cls.is_null(buff, reader, lambda b, r: Binding(r.toObject(b, DataType.string, False),
reader.readObject(b)), nullable)
