def create_friends(r: Redis):
g = Graph('friends', r)
adam = Node(label='User', properties={'name': 'Adam', 'mail': 'f****r'})
pernilla = Node(label='User', properties={'name': 'Pernilla'})
david = Node(label='User', properties={'name': 'David'})
g.add_node(adam)
g.add_node(pernilla)
g.add_node(david)
g.add_edge(Edge(adam, 'FRIEND', pernilla))
g.add_edge(Edge(pernilla, 'FRIEND', david))
g.commit()
return g
def generate_redisgraph_integration_data(client):
"""Create Redisgraph test DB from the standard integration data."""
vertex_values, edge_values, _ = get_integration_data()
client.query("create (n)")
client.query("match (n) delete n")
uuid_to_node = {}
for vertex_name, vertices in six.iteritems(vertex_values):
for vertex_props in vertices:
# NOTE(bojanserafimov): Dates and datetimes are not supported in redisgraph,
# so we just omit them from the dataset.
uuid_to_node[vertex_props["uuid"]] = Node(
label=vertex_name,
properties={
key: value
for key, value in six.iteritems(vertex_props)
if not isinstance(value, (datetime.date, datetime.datetime))
},
)
client.add_node(uuid_to_node[vertex_props["uuid"]])
for edge_name, edges in six.iteritems(edge_values):
for edge_spec in edges:
client.add_edge(
Edge(
uuid_to_node[edge_spec["from_uuid"]],
edge_name,
uuid_to_node[edge_spec["to_uuid"]],
)
)
client.commit()
def new_node(self):
return Node(label = labels[node_ctr % 2],
properties = {'unique': node_ctr,
'group': random.choice(groups),
'doubleval': round(random.uniform(-1, 1), 2),
'intval': random.randint(1, 10000),
'stringval': ''.join(random.choice(string.lowercase) for x in range(6))})
def populate_graph(self):
global graph
nodes = {}
# Create entities
for idx, p in enumerate(people):
node = Node(label="person", properties={"name": p, "val": idx})
graph.add_node(node)
nodes[p] = node
# Fully connected graph
for src in nodes:
for dest in nodes:
if src != dest:
edge = Edge(nodes[src], "know", nodes[dest])
graph.add_edge(edge)
for src in nodes:
for dest in nodes:
if src != dest:
edge = Edge(nodes[src], "works_with", nodes[dest])
graph.add_edge(edge)
graph.commit()
query = """MATCH (a)-[:know]->(b) CREATE (a)-[:know]->(b)"""
graph.query(query)
def test06_replace_property_map(self):
empty_node = Node()
result = graph.query("MATCH (n) SET n = {} RETURN n")
expected_result = [[empty_node]]
# The node originally had 2 properties, 'name' and 'city_name'
self.env.assertEqual(result.properties_set, 2)
self.env.assertEqual(result.result_set, expected_result)
def populate_graph(self):
global redis_graph
# Construct a graph with the form:
# (v1)-[e1]->(v2)-[e2]->(v3)
node_props = ['v1', 'v2', 'v3']
nodes = []
for idx, v in enumerate(node_props):
node = Node(label="L", properties={"val": v})
nodes.append(node)
redis_graph.add_node(node)
edge = Edge(nodes[0],
"E",
nodes[1],
properties={"edge_val": ['v1', 'v2']})
redis_graph.add_edge(edge)
edge = Edge(nodes[1],
"E",
nodes[2],
properties={"edge_val": ['v2', 'v3']})
redis_graph.add_edge(edge)
redis_graph.commit()
def populate_graph(self):
# Construct a graph with the form:
# (v1)-[:E]->(v2)-[:E]->(v3)-[:E]->(v4), (v1)-[:E]->(v5)-[:E2]->(v4)
global nodes
for v in range(1, 6):
node = Node(label="L", properties={"v": v})
nodes.append(node)
redis_graph.add_node(node)
edge = Edge(nodes[0], "E", nodes[1])
redis_graph.add_edge(edge)
edge = Edge(nodes[1], "E", nodes[2])
redis_graph.add_edge(edge)
edge = Edge(nodes[2], "E", nodes[3])
redis_graph.add_edge(edge)
edge = Edge(nodes[0], "E", nodes[4])
redis_graph.add_edge(edge)
edge = Edge(nodes[4], "E2", nodes[3])
redis_graph.add_edge(edge)
redis_graph.commit()
def test08_multiple_updates_to_property_map(self):
node = Node(properties={"v": 1, "v2": 2, "v4": 4})
result = graph.query(
"MATCH (n) SET n.v3 = 3, n = {v: 1}, n += {v2: 2}, n.v4 = 4 RETURN n"
)
expected_result = [[node]]
self.env.assertEqual(result.result_set, expected_result)
def test01_negated_simple_path_filter(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH(n:L) WHERE NOT (n)-[:R]->(:L) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node1]]
query_info = QueryInfo(query=query,
description="Tests simple negated path filter",
expected_result=expected_results)
self._assert_resultset_equals_expected(result_set, query_info)
def test_array_functions(self):
redis_graph = Graph('social', self.r)
query = """CREATE (p:person{name:'a',age:32, array:[0,1,2]})"""
redis_graph.query(query)
query = """WITH [0,1,2] as x return x"""
result = redis_graph.query(query)
self.assertEqual([0, 1, 2], result.result_set[0][0])
query = """MATCH(n) return collect(n)"""
result = redis_graph.query(query)
a = Node(node_id=0,
label='person',
properties={
'name': 'a',
'age': 32,
'array': [0, 1, 2]
})
self.assertEqual([a], result.result_set[0][0])
# All done, remove graph.
redis_graph.delete()
def test14_post_deletion_traversal_directions(self):
self.env.flush()
redis_con = self.env.getConnection()
redis_graph = Graph("G", redis_con)
nodes = {}
# Create entities.
labels = ["Dest", "Src", "Src2"]
for idx, l in enumerate(labels):
node = Node(label=l, properties={"val": idx})
redis_graph.add_node(node)
nodes[l] = node
edge = Edge(nodes["Src"], "R", nodes["Dest"])
redis_graph.add_edge(edge)
edge = Edge(nodes["Src2"], "R", nodes["Dest"])
redis_graph.add_edge(edge)
redis_graph.commit()
# Delete a node.
query = """MATCH (n:Src2) DELETE n"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.nodes_deleted, 1)
self.env.assertEquals(actual_result.relationships_deleted, 1)
query = """MATCH (n1:Src)-[*]->(n2:Dest) RETURN COUNT(*)"""
actual_result = redis_graph.query(query)
expected_result = [[1]]
self.env.assertEquals(actual_result.result_set, expected_result)
# Perform the same traversal, this time traveling from destination to source.
query = """MATCH (n1:Src)-[*]->(n2:Dest {val: 0}) RETURN COUNT(*)"""
actual_result = redis_graph.query(query)
expected_result = [[1]]
self.env.assertEquals(actual_result.result_set, expected_result)
def populate_graph(self, graph_name):
people = ["Roi", "Alon", "Ailon", "Boaz", "Tal", "Omri", "Ori"]
countries = ["Israel", "USA", "Japan", "United Kingdom"]
visits = [("Roi", "USA"), ("Alon", "Israel"), ("Ailon", "Japan"),
("Boaz", "United Kingdom")]
redis_graph = Graph(graph_name, redis_con)
if not redis_con.exists(graph_name):
personNodes = {}
countryNodes = {}
# Create entities
for p in people:
person = Node(label="person", properties={"name": p})
redis_graph.add_node(person)
personNodes[p] = person
for p in countries:
country = Node(label="country", properties={"name": p})
redis_graph.add_node(country)
countryNodes[p] = country
for v in visits:
person = v[0]
country = v[1]
edge = Edge(personNodes[person],
'visit',
countryNodes[country],
properties={'purpose': 'pleasure'})
redis_graph.add_edge(edge)
redis_graph.commit()
# Delete nodes, to introduce deleted item within our datablock
query = """MATCH (n:person) WHERE n.name = 'Roi' or n.name = 'Ailon' DELETE n"""
redis_graph.query(query)
query = """MATCH (n:country) WHERE n.name = 'USA' DELETE n"""
redis_graph.query(query)
# Create index.
actual_result = redis_con.execute_command(
"GRAPH.QUERY", graph_name, "CREATE INDEX ON :person(name)")
actual_result = redis_con.execute_command(
"GRAPH.QUERY", graph_name, "CREATE INDEX ON :country(name)")
return redis_graph
def test00_test_data_valid_after_rename(self):
global graph
node0 = Node(node_id=0, label="L", properties={'name':'x', 'age':1})
graph.add_node(node0)
graph.flush()
redis_con.rename(GRAPH_ID, NEW_GRAPH_ID)
graph = Graph(NEW_GRAPH_ID, redis_con)
node1 = Node(node_id=0, label="L", properties={'name':'x', 'age':1})
graph.add_node(node1)
graph.flush()
query = "MATCH (n) return n"
expected_results = [[node0], [node1]]
query_info = QueryInfo(query = query, description="Tests data is valid after renaming", expected_result = expected_results)
self._assert_resultset_and_expected_mutually_included(graph.query(query), query_info)
def populate_graph(self):
global redis_graph
node_props = [(622, "Mo"), (819, "Bing"), (819, "Qiu")]
for idx, v in enumerate(node_props):
node = Node(label="Person", properties={"id": v[0], "name": v[1]})
redis_graph.add_node(node)
redis_graph.commit()
def test_v6_decode(self):
graph_name = "v6_rdb_restore"
# dump created with the following query (v6 supported property value: integer, double, boolean, string, null, array)
# graph.query g "CREATE (:L1 {val:1, strval: 'str', numval: 5.5, nullval: NULL, boolval: true, array: [1,2,3]})-[:E{val:2}]->(:L2{val:3})"
# graph.query g "CREATE INDEX ON :L1(val)"
# dump g
v6_rdb = b"\a\x81\x82\xb6\xa9\x85\xd6\xadh\x06\x05\x02g\x00\x02\x06\x05\x04val\x00\x05\astrval\x00\x05\anumval\x00\x05\bnullval\x00\x05\bboolval\x00\x05\x06array\x00\x02\x02\x02\x00\x05\x03L1\x00\x02\x01\x02\x00\x05\x04val\x00\x02\x01\x05\x03L2\x00\x02\x00\x02\x01\x02\x00\x05\x02E\x00\x02\x00\x02\x02\x02\x01\x02\x00\x02\x06\x05\x04val\x00\x02`\x00\x02\x01\x05\astrval\x00\x02H\x00\x05\x04str\x00\x05\anumval\x00\x02\x80\x00\x00@\x00\x04\x00\x00\x00\x00\x00\x00\x16@\x05\bnullval\x00\x02\x80\x00\x00\x80\x00\x05\bboolval\x00\x02P\x00\x02\x01\x05\x06array\x00\x02\b\x02\x03\x02`\x00\x02\x01\x02`\x00\x02\x02\x02`\x00\x02\x03\x02\x01\x02\x01\x02\x01\x05\x04val\x00\x02`\x00\x02\x03\x02\x01\x02\x00\x02\x01\x02\x00\x02\x01\x05\x04val\x00\x02`\x00\x02\x02\x00\t\x00\xd9\r\xb4c\xf2Z\xd9\xb3"
redis_con.restore(graph_name, 0, v6_rdb, True)
redis_graph = Graph(graph_name, redis_con)
node0 = Node(node_id=0, label='L1', properties={'val': 1, 'strval': 'str', 'numval': 5.5, 'boolval': True, 'array': [1,2,3]})
node1 = Node(node_id=1, label='L2', properties={'val': 3})
edge01 = Edge(src_node=0, relation='E', dest_node=1, edge_id=0, properties={'val':2})
results = redis_graph.query("MATCH (n)-[e]->(m) RETURN n, e, m")
self.env.assertEqual(results.result_set, [[node0, edge01, node1]])
plan = redis_graph.execution_plan("MATCH (n:L1 {val:1}) RETURN n")
self.env.assertIn("Index Scan", plan)
results = redis_graph.query("MATCH (n:L1 {val:1}) RETURN n")
self.env.assertEqual(results.result_set, [[node0]])
def test07_test_edge_filters(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L")
node2 = Node(node_id=2, label="L")
edge01 = Edge(src_node=node0, dest_node=node1, relation="R", properties={'x':1})
edge12 = Edge(src_node=node1, dest_node=node2, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R {x:1}]->() RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0]]
query_info = QueryInfo(query = query, description="Tests pattern filter edge conditions", expected_result = expected_results)
self._assert_resultset_and_expected_mutually_included(result_set, query_info)
def create_artist_node(self):
if self.current_artist_present():
return False
else:
artist_node = Node(label='artist',
properties={'name': self.artist})
self.graph.add_node(artist_node)
self.graph.commit()
return True
def populate_graph(self):
# Populate a graph with two labels, each containing the same property values but different keys.
# Each node pair is connected by an edge from label_a to label_b
a_nodes = []
for idx, v in enumerate(values):
node = Node(label="label_a", properties={"a_val": v, "a_idx": idx})
a_nodes.append(node)
redis_graph.add_node(node)
for idx, v in enumerate(values):
node = Node(label="label_b", properties={"b_val": v, "b_idx": idx})
redis_graph.add_node(node)
edge = Edge(a_nodes[idx],
'connects',
node,
properties={"edgeval": idx})
redis_graph.add_edge(edge)
redis_graph.commit()
def test_node_retrival(self):
p0 = Node(node_id=0, label="Person", properties={'name': 'a'})
p1 = Node(node_id=1, label="Person", properties={'name': 'b'})
p2 = Node(node_id=2, label="NoPerson", properties={'name': 'a'})
redis_graph.add_node(p0)
redis_graph.add_node(p1)
redis_graph.add_node(p2)
redis_graph.flush()
params = {'name': 'a'}
query = "MATCH (n :Person {name:$name}) RETURN n"
expected_results = [[p0]]
query_info = QueryInfo(query=query,
description="Tests expression on param",
expected_result=expected_results)
self._assert_resultset_equals_expected(
redis_graph.query(query, params), query_info)
def test_v4_decode(self):
graph_name = "v4_rdb_restore"
# dump created with the following query (v4 supported property value: integer, double, boolean, string)
# graph.query g "CREATE (:L1 {val:1, strval: 'str', doubleval: 5.5, boolval: true})-[:E{val:2}]->(:L2{val:3})"
# graph.query g "CREATE INDEX ON :L1(val)"
# dump g
v4_rdb = b"\a\x81\x82\xb6\xa9\x85\xd6\xadh\x04\x05\x02g\x00\x02\x02\x02\x81\xff\xff\xff\xff\xff\xff\xff\xff\x05\x04ALL\x00\x02\x04\x05\aboolval\x05\tdoubleval\x05\x06strval\x05\x03val\x02\x00\x05\x03L1\x00\x02\x04\x05\aboolval\x05\tdoubleval\x05\x06strval\x05\x03val\x02\x01\x05\x03L2\x00\x02\x01\x05\x03val\x02\x01\x02\x81\xff\xff\xff\xff\xff\xff\xff\xff\x05\x04ALL\x00\x02\x01\x05\x03val\x02\x00\x05\x02E\x00\x02\x01\x05\x03val\x02\x02\x02\x00\x02\x01\x02\x00\x02\x04\x05\bboolval\x00\x02\x10\x02\x01\x05\ndoubleval\x00\x02@@\x04\x00\x00\x00\x00\x00\x00\x16@\x05\astrval\x00\x02A\x00\x05\x04str\x00\x05\x04val\x00\x02\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x05\x04val\x00\x02\x04\x02\x03\x02\x01\x02\x00\x02\x00\x02\x01\x02\x00\x02\x01\x05\x04val\x00\x02\x04\x02\x02\x02\x01\x05\x03L1\x00\x05\x04val\x00\x00\t\x00\xb38\x87\x01U^\x8b\xe3"
redis_con.restore(graph_name, 0, v4_rdb, True)
redis_graph = Graph(graph_name, redis_con)
node0 = Node(node_id=0, label='L1', properties={'val':1, 'strval': 'str', 'doubleval': 5.5, 'boolval': True})
node1 = Node(node_id=1, label='L2', properties={'val':3})
edge01 = Edge(src_node=0, relation='E', dest_node=1, edge_id=0, properties={'val':2})
results = redis_graph.query("MATCH (n)-[e]->(m) RETURN n, e, m")
self.env.assertEqual(results.result_set, [[node0, edge01, node1]])
plan = redis_graph.execution_plan("MATCH (n:L1 {val:1}) RETURN n")
self.env.assertIn("Index Scan", plan)
results = redis_graph.query("MATCH (n:L1 {val:1}) RETURN n")
self.env.assertEqual(results.result_set, [[node0]])
def test06_test_level_2_nesting_logical_operators_over_path_filters(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x':1})
node2 = Node(node_id=2, label="L2")
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
edge12 = Edge(src_node=node1, dest_node=node2, relation="R2")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
query = "MATCH (n:L) WHERE (n)-[:R]->(:L) OR (n.x=1 AND ((n)-[:R2]->(:L2) OR (n)-[:R]->(:L))) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0],[node1]]
query_info = QueryInfo(query = query, description="Tests AND condition with simple filter and nested OR", expected_result = expected_results)
self._assert_resultset_and_expected_mutually_included(result_set, query_info)
def test03_path_filter_or_negated_path_filter(self):
node0 = Node(node_id=0, label="L")
node1 = Node(node_id=1, label="L", properties={'x': 1})
edge01 = Edge(src_node=node0, dest_node=node1, relation="R")
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
query = "MATCH(n:L) WHERE (n)-[:R]->(:L) OR NOT (n)-[:R]->(:L) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0], [node1]]
query_info = QueryInfo(
query=query,
description="Tests OR condition with path and negated path filters",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
result_set, query_info)
def model_to_node(self, instance: NodeModel, auto_add=False):
node = Node(alias=instance.get_alias(),
label=instance.get_labels()[0],
properties=instance.get_properties(),
node_id=instance.get_id())
self.model_to_node_dict[instance] = node
if auto_add and self.graph:
self.graph.add_node(node)
return node
def test_path_comparison(self):
node0 = Node(node_id=0, label="L1")
node1 = Node(node_id=1, label="L1")
node2 = Node(node_id=2, label="L1")
edge01 = Edge(node0, "R1", node1, edge_id=0, properties={'value': 1})
edge12 = Edge(node1, "R1", node2, edge_id=1, properties={'value': 2})
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
# Rewrite the edges with IDs instead of node values to match how they are returned.
edge01 = Edge(0, "R1", 1, edge_id=0, properties={'value': 1})
edge12 = Edge(1, "R1", 2, edge_id=1, properties={'value': 2})
path01 = Path.new_empty_path().add_node(node0).add_edge(
edge01).add_node(node1)
path12 = Path.new_empty_path().add_node(node1).add_edge(
edge12).add_node(node2)
# Test a path equality filter
query = "MATCH p1 = (:L1)-[:R1]->(:L1) MATCH p2 = (:L1)-[:R1]->(:L1) WHERE p1 = p2 RETURN p1"
expected_results = [[path01], [path12]]
query_info = QueryInfo(query=query,
description="Test path equality",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
redis_graph.query(query), query_info)
# Test a path inequality filter
query = "MATCH p1 = (:L1)-[:R1]->(:L1) MATCH p2 = (:L1)-[:R1]->(:L1) WHERE p1 <> p2 RETURN DISTINCT p1, p2"
expected_results = [[path01, path12], [path12, path01]]
query_info = QueryInfo(query=query,
description="Test path inequality",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
redis_graph.query(query), query_info)
def test_bi_directional_path(self):
node0 = Node(node_id=0, label="L1")
node1 = Node(node_id=1, label="L1")
node2 = Node(node_id=2, label="L1")
edge01 = Edge(node0, "R1", node1, edge_id=0, properties={'value': 1})
edge12 = Edge(node1, "R1", node2, edge_id=1, properties={'value': 2})
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_edge(edge01)
redis_graph.add_edge(edge12)
redis_graph.flush()
# Rewrite the edges with IDs instead of node values to match how they are returned.
edge01 = Edge(0, "R1", 1, edge_id=0, properties={'value': 1})
edge12 = Edge(1, "R1", 2, edge_id=1, properties={'value': 2})
# Reverse direction edges which are not part of the graph. Read only values.
edge10 = Edge(1, "R1", 0, edge_id=0, properties={'value': 1})
edge21 = Edge(2, "R1", 1, edge_id=1, properties={'value': 2})
path010 = Path.new_empty_path().add_node(node0).add_edge(
edge01).add_node(node1).add_edge(edge10).add_node(node0)
path0121 = Path.new_empty_path().add_node(node0).add_edge(edge01).add_node(node1).add_edge(edge12) \
.add_node(node2).add_edge(edge21).add_node(node1)
path01210 = Path.new_empty_path().add_node(node0).add_edge(edge01).add_node(node1).add_edge(edge12) \
.add_node(node2).add_edge(edge21).add_node(node1).add_edge(edge10).add_node(node0)
path121 = Path.new_empty_path().add_node(node1).add_edge(
edge12).add_node(node2).add_edge(edge21).add_node(node1)
path1210 = Path.new_empty_path().add_node(node1).add_edge(edge12).add_node(node2).add_edge(edge21) \
.add_node(node1).add_edge(edge10).add_node(node0)
expected_results = [[path010], [path0121], [path01210], [path121],
[path1210]]
query = "MATCH p=(:L1)-[:R1*]->(:L1)<-[:R1*]-() RETURN p"
query_info = QueryInfo(
query=query,
description="Tests bi directional variable length paths",
expected_result=expected_results)
self._assert_resultset_and_expected_mutually_included(
redis_graph.query(query), query_info)
def test_zero_length_path(self):
node0 = Node(node_id=0, label="L1")
node1 = Node(node_id=1, label="L2")
edge01 = Edge(node0, "R1", node1, edge_id=0, properties={'value': 1})
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
path01 = Path.new_empty_path().add_node(node0).add_edge(edge01).add_node(node1)
expected_results=[[path01]]
query = "MATCH p=(:L1)-[*0..]->()-[]->(:L2) RETURN p"
query_info = QueryInfo(query = query, description="Tests path with zero length variable length paths", \
expected_result = expected_results)
self._assert_resultset_and_expected_mutually_included(redis_graph.query(query), query_info)
def test_node(self):
pool = RedisPool(urls=("localhost", 6379))
graph = pool.graph("test")
john = Node(label='person',
properties={
'name': 'John Doe',
'age': 33,
'gender': 'male',
'status': 'single'
})
graph.add_node(john)
japan = Node(label='country', properties={'name': 'Japan'})
graph.add_node(japan)
edge = Edge(john, 'visited', japan, properties={'purpose': 'pleasure'})
graph.add_edge(edge)
graph.commit()
def populate_graph(self):
# Construct a graph with the form:
# (a:A)-[:E]->(b:B), (c:C)-[:E]->(b)
a = Node(label="A", properties={"v": 1})
graph.add_node(a)
b = Node(label="B", properties={"v": 2})
graph.add_node(b)
c = Node(label="C", properties={"v": 3})
graph.add_node(c)
edge = Edge(a, "E", b)
graph.add_edge(edge)
edge = Edge(c, "E", b)
graph.add_edge(edge)
graph.commit()
def test01_collect(self):
for i in range(10):
redis_graph.add_node(Node())
redis_graph.commit()
query = """MATCH (n) RETURN collect(n)"""
result = redis_graph.query(query)
result_set = result.result_set
self.env.assertEquals(len(result_set), 1)
self.env.assertTrue(all(isinstance(n, Node) for n in result_set[0][0]))
def dump_data(n_records):
r = redis.Redis(host='localhost', port=6379)
data = data_gen(n_records)
redis_graph = Graph('file_activity1', r)
nodes = {}
edges = {}
pprint(data)
for rec in data:
_node = Node(label='file',
properties={
'fid': rec['_id'],
'name': rec['name'],
'date_added': rec['date_added'],
'platform': rec['platform']
})
r.set(rec['_id'], _node.alias)
redis_graph.add_node(_node)
nodes[rec['_id']] = _node
for rec in data:
for fileid, time_stamp in rec['downloaded']:
edge = Edge(nodes[rec['_id']],
'DOWNLOADED',
nodes[fileid],
properties={
'time': time_stamp,
'activity': 'downloaded'
})
redis_graph.add_edge(edge)
for fileid, time_stamp in rec['executed']:
edge = Edge(nodes[rec['_id']],
'EXECUTED',
nodes[fileid],
properties={
'time': time_stamp,
'activity': 'executed'
})
redis_graph.add_edge(edge)
for fileid, time_stamp in rec['removed']:
edge = Edge(nodes[rec['_id']],
'REMOVED',
nodes[fileid],
properties={
'time': time_stamp,
'activity': 'removed'
})
redis_graph.add_edge(edge)
redis_graph.commit()
print("Graph created")
