def populate_graph(self):
global redis_graph
nodes = []
# Create nodes
for n in node_names:
node = Node(label="node", properties={"name": n})
redis_graph.add_node(node)
nodes.append(node)
# Create edges
for i in range(len(nodes) - 1):
edge = Edge(nodes[i], "knows", nodes[i+1], properties={"connects": node_names[i] + node_names[i+1]})
redis_graph.add_edge(edge)
redis_graph.commit()
def test00_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 (n)-[:R]->(:L) RETURN n"
result_set = redis_graph.query(query)
expected_results = [[node0]]
query_info = QueryInfo(query=query,
description="Tests simple path filter",
expected_result=expected_results)
self._assert_resultset_equals_expected(result_set, query_info)
def populate_graph(self):
if redis_con.exists(GRAPH_ID):
return
edge = Edge(node1, 'goWellWith', node5)
redis_graph.add_node(node1)
redis_graph.add_node(node2)
redis_graph.add_node(node3)
redis_graph.add_node(node4)
redis_graph.add_node(node5)
redis_graph.add_edge(edge)
redis_graph.commit()
# Create full-text index.
redis_graph.call_procedure("db.idx.fulltext.createNodeIndex", 'fruit',
'name')
def populate_graph(self):
nodes = {}
# Create entities
for p in people:
node = Node(label="person", properties={"name": p})
self.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])
self.graph.add_edge(edge)
self.graph.commit()
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 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)
graph.commit()
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_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 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 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 test05_test_level_2_nesting_logical_operators_over_path_and_property_filters(
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 (n.x=1 AND (n.x = 2 OR NOT (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 populate_dense_graph(self, graph_name):
dense_graph = Graph(graph_name, redis_con)
# return early if graph exists
if redis_con.exists(graph_name):
return dense_graph
nodes = []
for i in range(10):
node = Node(label="n", properties={"val": i})
dense_graph.add_node(node)
nodes.append(node)
for n_idx, n in enumerate(nodes):
for m_idx, m in enumerate(nodes[:n_idx]):
dense_graph.add_edge(Edge(n, "connected", m))
dense_graph.flush()
return dense_graph
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 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 populate_graph(cls):
global redis_graph
nodes = {}
# Create entities
people = ["Roi", "Alon", "Ailon", "Boaz", "Tal", "Omri", "Ori"]
for p in people:
node = Node(label="person", properties={"name": p})
redis_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])
redis_graph.add_edge(edge)
redis_graph.commit()
def test13_delete_path_elements(self):
self.env.flush()
redis_con = self.env.getConnection()
redis_graph = Graph("delete_test", redis_con)
src = Node()
dest = Node()
edge = Edge(src, "R", dest)
redis_graph.add_node(src)
redis_graph.add_node(dest)
redis_graph.add_edge(edge)
redis_graph.flush()
# Delete projected
# Unwind path nodes.
query = """MATCH p = (src)-[e]->(dest) WITH nodes(p)[0] AS node, relationships(p)[0] as edge DELETE node, edge"""
actual_result = redis_graph.query(query)
self.env.assertEquals(actual_result.nodes_deleted, 1)
self.env.assertEquals(actual_result.relationships_deleted, 1)
def populate_graph(cls):
global redis_graph
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)")
def test_graph_creation(self):
redis_graph = Graph('social', self.r)
john = Node(label='person',
properties={
'name': 'John Doe',
'age': 33,
'gender': 'male',
'status': 'single'
})
redis_graph.add_node(john)
japan = Node(label='country', properties={'name': 'Japan'})
redis_graph.add_node(japan)
edge = Edge(john, 'visited', japan, properties={'purpose': 'pleasure'})
redis_graph.add_edge(edge)
redis_graph.commit()
query = (
'MATCH (p:person)-[v:visited {purpose:"pleasure"}]->(c:country) '
'RETURN p, v, c')
result = redis_graph.query(query)
person = result.result_set[0][0]
visit = result.result_set[0][1]
country = result.result_set[0][2]
self.assertEqual(person, john)
self.assertEqual(visit.properties, edge.properties)
self.assertEqual(country, japan)
query = """RETURN [1, 2.3, "4", true, false, null]"""
result = redis_graph.query(query)
self.assertEqual([1, 2.3, "4", True, False, None],
result.result_set[0][0])
# All done, remove graph.
redis_graph.delete()
def test_path_property_access(self):
node0 = Node(node_id=0, label="L1", properties={'value': 1})
node1 = Node(node_id=1, label="L1", properties={'value': 2})
edge01 = Edge(node0, "R1", node1, edge_id=0)
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
# Test access of pre-existing properties along a path.
query = """MATCH p=()-[]->() RETURN nodes(p)[0].value, nodes(p)[1].value"""
result = redis_graph.query(query)
expected_result = [[1, 2]]
self.env.assertEqual(result.result_set, expected_result)
# Test access of properties introduced by the query.
query = """MATCH p=(a)-[]->() SET a.newval = 'new' RETURN nodes(p)[0].value, nodes(p)[0].newval"""
result = redis_graph.query(query)
expected_result = [[1, 'new']]
self.env.assertEqual(result.result_set, expected_result)
def test_v9_decode(self):
graph_name = "v9_rdb_restore"
# docker run -p 6379:6379 -it redislabs/redisgraph:2.4.10
# dump created with the following query (v9 supported property value: integer, double, boolean, string, null, array, point)
# graph.query g "CREATE (:L1 {val:1, strval: 'str', numval: 5.5, nullval: NULL, boolval: true, array: [1,2,3], point: POINT({latitude: 32, longitude: 34})})-[:E{val:2}]->(:L2{val:3})"
# graph.query g "CREATE INDEX ON :L1(val)"
# graph.query g "CREATE INDEX ON :L1(none_existsing)"
# graph.query g "CREATE (:L3)-[:E2]->(:L4)"
# graph.query g "MATCH (n1:L3)-[r:E2]->(n2:L4) DELETE n1, r, n2"
# dump g
v9_rdb = b"\a\x81\x82\xb6\xa9\x85\xd6\xadh\t\x05\x02g\x00\x02\x02\x02\x01\x02\x04\x02\x02\x02\x00\x02\x00\x02\x01\x02\x05\x02\x01\x02\x02\x02\x02\x02\x02\x02\x03\x02\x01\x02\x04\x02\x01\x02\x05\x02\x01\x02\x00\x02\x01\x02\x00\x02\x06\x02\x00\x02`\x00\x02\x01\x02\x01\x02H\x00\x05\x04str\x00\x02\x02\x02\x80\x00\x00@\x00\x04\x00\x00\x00\x00\x00\x00\x16@\x02\x04\x02P\x00\x02\x01\x02\x05\x02\b\x02\x03\x02`\x00\x02\x01\x02`\x00\x02\x02\x02`\x00\x02\x03\x02\x06\x02\x80\x00\x02\x00\x00\x04\x00\x00\x00\x00\x00\x00@@\x04\x00\x00\x00\x00\x00\x00A@\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x02`\x00\x02\x03\x02\x02\x02\x03\x02\x00\x02\x00\x02\x01\x02\x00\x02\x01\x02\x00\x02`\x00\x02\x02\x02\x01\x02\b\x05\x04val\x00\x05\astrval\x00\x05\anumval\x00\x05\bnullval\x00\x05\bboolval\x00\x05\x06array\x00\x05\x06point\x00\x05\x0fnone_existsing\x00\x02\x04\x02\x00\x05\x03L1\x00\x02\x02\x02\x01\x05\x04val\x00\x02\x01\x05\x0fnone_existsing\x00\x02\x01\x05\x03L2\x00\x02\x00\x02\x02\x05\x03L3\x00\x02\x00\x02\x03\x05\x03L4\x00\x02\x00\x02\x02\x02\x00\x05\x02E\x00\x02\x00\x02\x01\x05\x03E2\x00\x02\x00\x00\t\x00\xd7\xd0\x1cB;\xce\x1d>"
redis_con.restore(graph_name, 0, v9_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], 'point': {'latitude': 32, 'longitude': 34}})
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 populate_graph(cls):
redis_graph
nodes = {}
# Create entities
for m in male:
node = Node(label="male", properties={"name": m})
redis_graph.add_node(node)
nodes[m] = node
for f in female:
node = Node(label="female", properties={"name": f})
redis_graph.add_node(node)
nodes[f] = node
for n in nodes:
for m in nodes:
if n == m: continue
edge = Edge(nodes[n], "knows", nodes[m])
redis_graph.add_edge(edge)
redis_graph.commit()
def test11_unbound_path_filters(self):
# Build a graph with 2 nodes connected by 1 edge.
node0 = Node(node_id=0, label="L", properties={'x': 'a'})
node1 = Node(node_id=1, label="L", properties={'x': 'b'})
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()
# Emit a query that uses an AntiSemiApply op to return values.
query = "MATCH (n:L) WHERE NOT (:L)-[]->() RETURN n.x ORDER BY n.x"
result_set = redis_graph.query(query)
# The WHERE filter evaluates to false, no results should be returned.
expected_result = []
self.env.assertEquals(result_set.result_set, expected_result)
# Emit a query that uses a SemiApply op to return values.
query = "MATCH (n:L) WHERE (:L)-[]->() RETURN n.x ORDER BY n.x"
result_set = redis_graph.query(query)
# The WHERE filter evaluates to true, all results should be returned.
expected_result = [['a'], ['b']]
self.env.assertEquals(result_set.result_set, expected_result)
def test_optional_match(self):
redis_graph = Graph('optional', self.r)
# Build a graph of form (a)-[R]->(b)
node0 = Node(node_id=0, label="L1", properties={'value': 'a'})
node1 = Node(node_id=1, label="L1", properties={'value': 'b'})
edge01 = Edge(node0, "R", node1, edge_id=0)
redis_graph.add_node(node0)
redis_graph.add_node(node1)
redis_graph.add_edge(edge01)
redis_graph.flush()
# Issue a query that collects all outgoing edges from both nodes (the second has none).
query = """MATCH (a) OPTIONAL MATCH (a)-[e]->(b) RETURN a, e, b ORDER BY a.value"""
expected_results = [[node0, edge01, node1], [node1, None, None]]
result = redis_graph.query(query)
self.assertEqual(expected_results, result.result_set)
redis_graph.delete()
def test_path(self):
redis_graph = Graph('social', self.r)
node0 = Node(node_id=0, label="L1")
node1 = Node(node_id=1, label="L1")
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)-[:R1]->(:L1) RETURN p ORDER BY p"
result = redis_graph.query(query)
self.assertEqual(expected_results, result.result_set)
# All done, remove graph.
redis_graph.delete()
def test():
r = redis.Redis(host='localhost', port=6379)
redis_graph = Graph('social', r)
john = Node(label='person',
properties={
'name': 'John Doe',
'age': 33,
'gender': 'male',
'status': 'single'
})
redis_graph.add_node(john)
japan = Node(label='country', properties={'name': 'Japan'})
redis_graph.add_node(japan)
edge = Edge(john, 'visited', japan, properties={'purpose': 'pleasure'})
redis_graph.add_edge(edge)
redis_graph.commit()
query = """MATCH (p:person)-[v:visited {purpose:"pleasure"}]->(c:country)
RETURN p.name, p.age, v.purpose, c.name"""
result = redis_graph.query(query)
# Print resultset
result.pretty_print()
# Iterate through resultset, skip header row at position 0
for record in result.result_set[1:]:
person_name = record[0]
person_age = record[1]
visit_purpose = record[2]
country_name = record[3]
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_bi_directional_path_functions(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})
expected_results = [[[node0, node1, node0], [edge01, edge10], 2],
[[node0, node1, node2, node1],
[edge01, edge12, edge21], 3],
[[node0, node1, node2, node1, node0],
[edge01, edge12, edge21, edge10], 4],
[[node1, node2, node1], [edge12, edge21], 2],
[[node1, node2, node1, node0],
[edge12, edge21, edge10], 3]]
query = "MATCH p=(:L1)-[:R1*]->(:L1)<-[:R1*]-() RETURN nodes(p), relationships(p), length(p)"
query_info = QueryInfo(query = query, description="Tests path functions over bi directional variable length paths", \
expected_result = expected_results)
self._assert_resultset_and_expected_mutually_included(
redis_graph.query(query), query_info)
def test_CRUD_replication(self):
# create a simple graph
env = self.env
source_con = env.getConnection()
replica_con = env.getSlaveConnection()
# enable write commands on slave, required as all RedisGraph
# commands are registered as write commands
replica_con.config_set("slave-read-only", "no")
# perform CRUD operations
# create a simple graph
graph = Graph(GRAPH_ID, source_con)
replica = Graph(GRAPH_ID, replica_con)
s = Node(label='L', properties={'id': 0, 'name': 'abcd'})
t = Node(label='L', properties={'id': 1, 'name': 'efgh'})
e = Edge(s, 'R', t)
graph.add_node(s)
graph.add_node(t)
graph.add_edge(e)
graph.flush()
# create index
q = "CREATE INDEX ON :L(id)"
graph.query(q)
# create full-text index
q = "CALL db.idx.fulltext.createNodeIndex('L', 'name')"
graph.query(q)
# add fields to existing index
q = "CALL db.idx.fulltext.createNodeIndex('L', 'title', 'desc')"
graph.query(q)
# create full-text index with index config
q = "CALL db.idx.fulltext.createNodeIndex({label: 'L1', language: 'german', stopwords: ['a', 'b'] }, 'title', 'desc')"
graph.query(q)
# update entity
q = "MATCH (n:L {id:1}) SET n.id = 2"
graph.query(q)
# delete entity
q = "MATCH (n:L {id:0}) DELETE n"
graph.query(q)
# give replica some time to catch up
time.sleep(1)
# make sure index is available on replica
q = "MATCH (s:L {id:2}) RETURN s.name"
plan = graph.execution_plan(q)
replica_plan = replica.execution_plan(q)
env.assertIn("Index Scan", plan)
self.env.assertEquals(replica_plan, plan)
# issue query on both source and replica
# make sure results are the same
result = graph.query(q).result_set
replica_result = replica.query(q).result_set
self.env.assertEquals(replica_result, result)
# make sure node count on both primary and replica is the same
q = "MATCH (n) RETURN count(n)"
result = graph.query(q).result_set
replica_result = replica.query(q).result_set
self.env.assertEquals(replica_result, result)
# make sure nodes are in sync
q = "MATCH (n) RETURN n ORDER BY n"
result = graph.query(q).result_set
replica_result = replica.query(q).result_set
self.env.assertEquals(replica_result, result)
# make sure both primary and replica have the same set of indexes
q = "CALL db.indexes()"
result = graph.query(q).result_set
replica_result = replica.query(q).result_set
self.env.assertEquals(replica_result, result)
# drop fulltext index
q = "CALL db.idx.fulltext.drop('L')"
graph.query(q)
# give replica some time to catch up
time.sleep(1)
# make sure both primary and replica have the same set of indexes
q = "CALL db.indexes()"
result = graph.query(q).result_set
replica_result = replica.query(q).result_set
self.env.assertEquals(replica_result, result)
def populate_graph(redis_con, redis_graph):
# check if graph already exists
if redis_con.exists(graph_name):
return
# Load movies entities
print("Loading movies")
movies = {}
with open(
os.path.dirname(os.path.abspath(__file__)) +
'/resources/movies.csv', 'r') as f:
reader = csv.reader(f, delimiter=',')
for row in reader:
title = row[0]
genre = row[1]
votes = int(row[2])
rating = float(row[3])
year = int(row[4])
node = Node(label="movie",
properties={
'title': title,
'genre': genre,
'votes': votes,
'rating': rating,
'year': year
})
movies[title] = node
redis_graph.add_node(node)
print("Loaded %d movies" % len(movies))
# Load actors entities
print("Loading actors")
actors = {}
today = date.today()
with open(
os.path.dirname(os.path.abspath(__file__)) +
'/resources/actors.csv', 'r') as f:
reader = csv.reader(f, delimiter=',')
for row in reader:
name = row[0]
yearOfBirth = int(row[1])
movie = row[2]
age = today.year - yearOfBirth
if name not in actors:
node = Node(label="actor",
properties={
'name': name,
'age': age
})
actors[name] = node
redis_graph.add_node(node)
if movie in movies:
edge = Edge(actors[name], "act", movies[movie])
redis_graph.add_edge(edge)
print("Loaded %d actors" % len(actors))
redis_graph.commit()
return (actors, movies)
source_entity_id,
destination_entity_id),
'rank', 1)
source_node = Node(label='entity',
properties={
'id': source_entity_id,
'rank': 1,
'name': source_canonical_name
})
destination_node = Node(label='entity',
properties={
'id': destination_entity_id,
'rank': 1,
'name':
destination_canonical_name
})
redis_graph.add_node(source_node)
redis_graph.add_node(destination_node)
edge = Edge(source_node,
'related',
destination_node,
properties={'article': sentence_key})
redis_graph.add_edge(edge)
redis_graph.commit()
if num_sents % 100 == 0:
log(f"... {num_sents} sentences ")
num_sents += 1
log("Flushing graph for sentence %s " % sentence_key)
logger.info("Completed")
