FilesExpand file tree

 master

/

test_multi_pattern.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

77 lines (65 loc) · 3.57 KB

 master

/

test_multi_pattern.py

Copy path

Top

File metadata and controls

• Code
• Blame

77 lines (65 loc) · 3.57 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

from common import *

redis_graph = None

people = ["Roi", "Alon", "Ailon", "Boaz", "Tal", "Omri", "Ori"]

class testGraphMultiPatternQueryFlow(FlowTestsBase):

def __init__(self):

self.env = Env(decodeResponses=True)

global redis_graph

redis_con = self.env.getConnection()

redis_graph = Graph(redis_con, "G")

self.populate_graph()

def populate_graph(self):

global redis_graph

nodes = {}

# Create entities

for p in people:

node = Node(label="person", properties={"name": p})

redis_graph.add_node(node)

nodes[p] = node

redis_graph.commit()

# Connect a single node to all other nodes.

def test01_connect_node_to_rest(self):

query = """MATCH(r:person {name:"Roi"}), (f:person) WHERE f.name <> r.name CREATE (r)-[:friend]->(f) RETURN count(f)"""

actual_result = redis_graph.query(query)

friend_count = actual_result.result_set[0][0]

self.env.assertEquals(friend_count, 6)

self.env.assertEquals(actual_result.relationships_created, 6)

def test02_verify_cartesian_product_streams_reset(self):

# See https://github.com/RedisGraph/RedisGraph/issues/249

# Forevery outgoing edge, we expect len(people) to be matched.

expected_resultset_size = 6 * len(people)

queries = ["""MATCH (r:person {name:"Roi"})-[]->(f), (x) RETURN f, x""",

"""MATCH (r:person {name:"Roi"})-[]->(f), (x) RETURN f, x""",

"""MATCH (x), (r:person {name:"Roi"})-[]->(f) RETURN f, x""",

"""MATCH (r:person {name:"Roi"})-[]->(f) MATCH (x) RETURN f, x""",

"""MATCH (x) MATCH (r:person {name:"Roi"})-[]->(f) RETURN f, x"""]

for q in queries:

actual_result = redis_graph.query(q)

records_count = len(actual_result.result_set)

self.env.assertEquals(records_count, expected_resultset_size)

# Connect every node to every node.

def test03_create_fully_connected_graph(self):

query = """MATCH(a:person), (b:person) WHERE a.name <> b.name CREATE (a)-[f:friend]->(b) RETURN count(f)"""

actual_result = redis_graph.query(query)

friend_count = actual_result.result_set[0][0]

self.env.assertEquals(friend_count, 42)

self.env.assertEquals(actual_result.relationships_created, 42)

# Perform a cartesian product of 3 sets.

def test04_cartesian_product(self):

queries = ["""MATCH (a), (b), (c) RETURN count(a)""",

"""MATCH (a) MATCH (b), (c) RETURN count(a)""",

"""MATCH (a), (b) MATCH (c) RETURN count(a)""",

"""MATCH (a) MATCH (b) MATCH (c) RETURN count(a)"""]

for q in queries:

actual_result = redis_graph.query(q)

friend_count = actual_result.result_set[0][0]

self.env.assertEquals(friend_count, 343)

def test06_multiple_create_clauses(self):

queries = ["""CREATE (:a {v:1}), (:b {v:2, z:3}), (:c), (:a)-[:r0 {k:9}]->(:b), (:c)-[:r1]->(:d)""",

"""CREATE (:a {v:1}) CREATE (:b {v:2, z:3}) CREATE (:c) CREATE (:a)-[:r0 {k:9}]->(:b) CREATE (:c)-[:r1]->(:d)""",

"""CREATE (:a {v:1}), (:b {v:2, z:3}) CREATE (:c), (:a)-[:r0 {k:9}]->(:b) CREATE (:c)-[:r1]->(:d)"""]

for q in queries:

actual_result = redis_graph.query(q)

self.env.assertEquals(actual_result.relationships_created, 2)

self.env.assertEquals(actual_result.properties_set, 4)

self.env.assertEquals(actual_result.nodes_created, 7)