RedisGraph SNB interactive benchmark support

README.md

@@ -24,6 +24,7 @@ To get started with the LDBC SNB benchmarks, check out our introductory presenta
 We provide two reference implementations:
 
 * [Neo4j (Cypher) implementation](cypher/README.md)
+* [RedisGraph (Cypher) implementation](postgres/README.md)
 * [PostgreSQL (SQL) implementation](postgres/README.md)
 
 There are additional implementations are avaiable but these are less well-tested:

build_redisgraph.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+mvn clean package -DskipTests -Pcypher,redisgraph

cypher/driver/create-validation-parameters.properties

@@ -4,7 +4,7 @@ password=admin
 queryDir=queries/
 
 printQueryNames=true
-printQueryStrings=false
+printQueryStrings=true
 printQueryResults=false
 
 status=1
@@ -69,7 +69,7 @@ ldbc.snb.interactive.LdbcQuery10_enable=true
 ldbc.snb.interactive.LdbcQuery11_enable=true
 ldbc.snb.interactive.LdbcQuery12_enable=true
 ldbc.snb.interactive.LdbcQuery13_enable=true
-ldbc.snb.interactive.LdbcQuery14_enable=true
+ldbc.snb.interactive.LdbcQuery14_enable=false
 
 ldbc.snb.interactive.LdbcShortQuery1PersonProfile_enable=true
 ldbc.snb.interactive.LdbcShortQuery2PersonPosts_enable=true
@@ -87,3 +87,4 @@ ldbc.snb.interactive.LdbcUpdate5AddForumMembership_enable=true
 ldbc.snb.interactive.LdbcUpdate6AddPost_enable=true
 ldbc.snb.interactive.LdbcUpdate7AddComment_enable=true
 ldbc.snb.interactive.LdbcUpdate8AddFriendship_enable=true
+ldbc.snb.interactive.LdbcDelete1RemovePerson_enable=true

cypher/driver/validate.properties

@@ -60,11 +60,11 @@ ldbc.snb.interactive.LdbcQuery9_enable=true
 ldbc.snb.interactive.LdbcQuery10_enable=true
 ldbc.snb.interactive.LdbcQuery11_enable=true
 ldbc.snb.interactive.LdbcQuery12_enable=true
-ldbc.snb.interactive.LdbcQuery13_enable=true
-ldbc.snb.interactive.LdbcQuery14_enable=true
+ldbc.snb.interactive.LdbcQuery13_enable=false
+ldbc.snb.interactive.LdbcQuery14_enable=false
 
 ldbc.snb.interactive.LdbcShortQuery1PersonProfile_enable=true
-ldbc.snb.interactive.LdbcShortQuery2PersonPosts_enable=true
+ldbc.snb.interactive.LdbcShortQuery2PersonPosts_enable=false
 ldbc.snb.interactive.LdbcShortQuery3PersonFriends_enable=true
 ldbc.snb.interactive.LdbcShortQuery4MessageContent_enable=true
 ldbc.snb.interactive.LdbcShortQuery5MessageCreator_enable=true
@@ -79,3 +79,4 @@ ldbc.snb.interactive.LdbcUpdate5AddForumMembership_enable=true
 ldbc.snb.interactive.LdbcUpdate6AddPost_enable=true
 ldbc.snb.interactive.LdbcUpdate7AddComment_enable=true
 ldbc.snb.interactive.LdbcUpdate8AddFriendship_enable=true
+ldbc.snb.interactive.LdbcDelete1RemovePerson_enable=true

cypher/queries/check-feature.sh

@@ -2,7 +2,7 @@
 
 FEATURE=$1
 
-for i in `seq 1 25`; do
+for i in $(seq 1 25); do
   if grep -q "$FEATURE" bi-$i.cypher; then
     echo x
   else

cypher/queries/interactive-complex-1.cypher

@@ -1,52 +1,53 @@
-// Q1. Transitive friends with certain name
-/*
-:param [{ personId, firstName }] => { RETURN
-  4398046511333 AS personId,
-  "Jose" AS firstName
-}
-*/
-MATCH (p:Person {id: $personId}), (friend:Person {firstName: $firstName})
-       WHERE NOT p=friend
-       WITH p, friend
-       MATCH path = shortestPath((p)-[:KNOWS*1..3]-(friend))
-       WITH min(length(path)) AS distance, friend
-ORDER BY
-    distance ASC,
-    friend.lastName ASC,
-    toInteger(friend.id) ASC
-LIMIT 20
-
+MATCH path=(person:Person {id: $personId})-[:KNOWS*1..3]-(friend:Person)
+  WHERE friend.firstName = $firstName
+  AND person <> friend
+WITH friend, min(length(path)) AS distance
+  ORDER BY distance ASC, friend.lastName ASC, friend.id ASC
+  LIMIT 20
 MATCH (friend)-[:IS_LOCATED_IN]->(friendCity:City)
 OPTIONAL MATCH (friend)-[studyAt:STUDY_AT]->(uni:University)-[:IS_LOCATED_IN]->(uniCity:City)
 WITH friend, collect(
     CASE uni.name
-        WHEN null THEN null
-        ELSE [uni.name, studyAt.classYear, uniCity.name]
-    END ) AS unis, friendCity, distance
-
-OPTIONAL MATCH (friend)-[workAt:WORK_AT]->(company:Company)-[:IS_LOCATED_IN]->(companyCountry:Country)
-WITH friend, collect(
-    CASE company.name
-        WHEN null THEN null
-        ELSE [company.name, workAt.workFrom, companyCountry.name]
-    END ) AS companies, unis, friendCity, distance
-
+      WHEN NULL THEN NULL
+      ELSE [uni.name, studyAt.classYear, uniCity.name]
+      END
+  ) AS unis,
+  friendCity,
+  distance
+OPTIONAL MATCH (friend)-[workAt:WORK_AT]->(company:Organisation)-[:IS_LOCATED_IN]->(companyCountry:Country)
+WITH
+  friend,
+  company.name AS companyName,
+  companyCountry.name AS companyCountryName,
+  workAt.workFrom AS workFrom,
+  unis,
+  friendCity,
+  distance
+  ORDER BY company.name
+WITH
+  friend,
+  collect(
+    CASE companyName
+      WHEN NULL THEN NULL
+      ELSE [companyName, workFrom, companyCountryName]
+      END
+  ) AS companies,
+  unis,
+  friendCity,
+  distance
 RETURN
-    friend.id AS friendId,
-    friend.lastName AS friendLastName,
-    distance AS distanceFromPerson,
-    friend.birthday AS friendBirthday,
-    friend.creationDate AS friendCreationDate,
-    friend.gender AS friendGender,
-    friend.browserUsed AS friendBrowserUsed,
-    friend.locationIP AS friendLocationIp,
-    friend.email AS friendEmails,
-    friend.speaks AS friendLanguages,
-    friendCity.name AS friendCityName,
-    unis AS friendUniversities,
-    companies AS friendCompanies
-ORDER BY
-    distanceFromPerson ASC,
-    friendLastName ASC,
-    toInteger(friendId) ASC
-LIMIT 20
+  friend.id AS friendId,
+  friend.lastName AS friendLastName,
+  distance AS distanceFromPerson,
+  friend.birthday AS friendBirthday,
+  friend.creationDate AS friendCreationDate,
+  friend.gender AS friendGender,
+  friend.browserUsed AS friendBrowserUsed,
+  friend.locationIP AS friendLocationIp,
+  friend.email AS friendEmails,
+  friend.speaks AS friendLanguages,
+  friendCity.name AS friendCityName,
+  unis AS friendUniversities,
+  companies AS friendCompanies
+  ORDER BY distance ASC, friend.lastName ASC, friend.id ASC
+  LIMIT 20

cypher/queries/interactive-complex-10-without-list-comprehension.cypher

@@ -0,0 +1,33 @@
+MATCH (person:Person {id: $personId})-[:KNOWS*2..2]-(friend:Person)-[:IS_LOCATED_IN]->(city:Place)
+  WHERE
+  ((friend.birthday / 100 % 100 = $month AND friend.birthday % 100 >= 21) OR
+  (friend.birthday / 100 % 100 = $nextMonth AND friend.birthday % 100 < 22))
+  AND NOT(friend = person)
+  AND NOT((friend)-[:KNOWS]-(person))
+WITH DISTINCT friend, city, person
+OPTIONAL MATCH (friend)<-[:HAS_CREATOR]-(post:Post)
+WITH friend, city, collect(post) + [null] AS posts, count(post) AS postCount, person
+UNWIND posts AS commonPostCandidate
+WITH
+  friend,
+  city,
+  commonPostCandidate,
+  postCount,
+  person
+  WHERE (commonPostCandidate)-[:HAS_TAG]->(:Tag)<-[:HAS_INTEREST]-(person) OR commonPostCandidate IS NULL
+WITH
+  friend,
+  city,
+  postCount,
+  count(commonPostCandidate) AS commonPostCount
+RETURN
+  friend.id AS personId,
+  friend.firstName AS personFirstName,
+  friend.lastName AS personLastName,
+  commonPostCount - (postCount- commonPostCount) AS commonInterestScore,
+commonPostCount,
+postCount,
+friend.gender AS personGender,
+city.name AS personCityName
+ORDER BY commonInterestScore DESC, toInteger(personId) ASC
+LIMIT 10

cypher/queries/interactive-complex-10.cypher

@@ -1,29 +1,24 @@
-// Q10. Friend recommendation
-/*
-:param [{ personId, month }] => { RETURN
-  4398046511333 AS personId,
-  5 AS month
-}
-*/
-MATCH (person:Person {id: $personId})-[:KNOWS*2..2]-(friend),
-       (friend)-[:IS_LOCATED_IN]->(city:City)
-WHERE NOT friend=person AND
-      NOT (friend)-[:KNOWS]-(person)
-WITH person, city, friend, datetime({epochMillis: friend.birthday}) as birthday
-WHERE  (birthday.month=$month AND birthday.day>=21) OR
-        (birthday.month=($month%12)+1 AND birthday.day<22)
+MATCH (person:Person {id: $personId})-[:KNOWS*2..2]-(friend:Person)-[:IS_LOCATED_IN]->(city:Place)
+  WHERE
+  ((friend.birthday / 100 % 100 = $month AND friend.birthday % 100 >= 21) OR
+  (friend.birthday / 100 % 100 = $month % 12 + 1 AND friend.birthday % 100 < 22))
+  AND NOT(friend = person)
+  AND NOT((friend)-[:KNOWS]-(person))
 WITH DISTINCT friend, city, person
 OPTIONAL MATCH (friend)<-[:HAS_CREATOR]-(post:Post)
-WITH friend, city, collect(post) AS posts, person
-WITH friend,
-     city,
-     size(posts) AS postCount,
-     size([p IN posts WHERE (p)-[:HAS_TAG]->()<-[:HAS_INTEREST]-(person)]) AS commonPostCount
-RETURN friend.id AS personId,
-       friend.firstName AS personFirstName,
-       friend.lastName AS personLastName,
-       commonPostCount - (postCount - commonPostCount) AS commonInterestScore,
-       friend.gender AS personGender,
-       city.name AS personCityName
-ORDER BY commonInterestScore DESC, personId ASC
+OPTIONAL MATCH (post)-[:HAS_TAG]->(commonPost:Tag)<-[:HAS_INTEREST]-(person)
+WITH friend, city, collect(post) AS posts, person, count(commonPost) AS commonPostCount
+WITH
+  friend,
+  city,
+  size(posts) AS postCount,
+  commonPostCount
+RETURN
+  friend.id AS personId,
+  friend.firstName AS personFirstName,
+  friend.lastName AS personLastName,
+  commonPostCount - (postCount- commonPostCount) AS commonInterestScore,
+friend.gender AS personGender,
+city.name AS personCityName
+ORDER BY commonInterestScore DESC, toInteger(personId) ASC
 LIMIT 10

cypher/queries/interactive-complex-11.cypher

@@ -1,24 +1,13 @@
-// Q11. Job referral
-/*
-:param [{ personId, countryName, workFromYear }] => { RETURN
-  10995116277918 AS personId,
-  "Hungary" AS countryName,
-  2011 AS workFromYear
-}
-*/
-MATCH (person:Person {id: $personId })-[:KNOWS*1..2]-(friend:Person)
-WHERE not(person=friend)
+MATCH (person:Person {id: $personId})-[:KNOWS*1..2]-(friend:Person)
+  WHERE NOT(person = friend)
 WITH DISTINCT friend
-MATCH (friend)-[workAt:WORK_AT]->(company:Company)-[:IS_LOCATED_IN]->(:Country {name: $countryName })
-WHERE workAt.workFrom < $workFromYear
+MATCH (friend)-[workAt:WORK_AT]->(company:Organisation)-[:IS_LOCATED_IN]->(:Place {name: $countryName})
+  WHERE workAt.workFrom < $workFromYear
 RETURN
-        friend.id AS personId,
-        friend.firstName AS personFirstName,
-        friend.lastName AS personLastName,
-        company.name AS organizationName,
-        workAt.workFrom AS organizationWorkFromYear
-ORDER BY
-        organizationWorkFromYear ASC,
-        toInteger(personId) ASC,
-        organizationName DESC
-LIMIT 10
+  friend.id,
+  friend.firstName AS personFirstName,
+  friend.lastName AS personLastName,
+  company.name AS organizationName,
+  workAt.workFrom AS organizationWorkFromYear
+  ORDER BY organizationWorkFromYear ASC, toInteger(friend.id) ASC, organizationName DESC
+  LIMIT 10

cypher/queries/interactive-complex-12.cypher

@@ -1,22 +1,14 @@
-// Q12. Expert search
-/*
-:param [{ personId, tagClassName }] => { RETURN
-  10995116278009 AS personId,
-  "Monarch" AS tagClassName
-}
-*/
-MATCH (tag:Tag)-[:HAS_TYPE|IS_SUBCLASS_OF*0..]->(baseTagClass:TagClass)
-WHERE tag.name = $tagClassName OR baseTagClass.name = $tagClassName
-WITH collect(tag.id) as tags
-MATCH (:Person {id: $personId })-[:KNOWS]-(friend:Person)<-[:HAS_CREATOR]-(comment:Comment)-[:REPLY_OF]->(:Post)-[:HAS_TAG]->(tag:Tag)
-WHERE tag.id in tags
+MATCH (p:Person {id: $personId})
+WITH p
+MATCH (p)-[:KNOWS]-(friend:Person)<-[:HAS_CREATOR]-(comment:Message)-[:REPLY_OF]->(:Message)
+       -[:HAS_TAG]->(tag:Tag),
+     (tag)-[:HAS_TYPE]->(tagClass:TagClass)-[:IS_SUBCLASS_OF*0..]->(baseTagClass:TagClass)
+  WHERE tagClass.name = $tagClassName OR baseTagClass.name = $tagClassName
 RETURN
-    friend.id AS personId,
-    friend.firstName AS personFirstName,
-    friend.lastName AS personLastName,
-    collect(DISTINCT tag.name) AS tagNames,
-    count(DISTINCT comment) AS replyCount
-ORDER BY
-    replyCount DESC,
-    toInteger(personId) ASC
-LIMIT 20
+  friend.id,
+  friend.firstName AS personFirstName,
+  friend.lastName AS personLastName,
+  collect(DISTINCT tag.name) AS tagNames,
+  count(DISTINCT comment) AS replyCount
+  ORDER BY replyCount DESC, friend.id ASC
+  LIMIT 20

cypher/queries/interactive-complex-13.cypher

@@ -1,16 +1,7 @@
-// Q13. Single shortest path
-/*
-:param [{ person1Id, person2Id }] => { RETURN
-  8796093022390 AS person1Id,
-  8796093022357 AS person2Id
-}
-*/
-MATCH
-    (person1:Person {id: $person1Id}),
-    (person2:Person {id: $person2Id}),
-    path = shortestPath((person1)-[:KNOWS*]-(person2))
+MATCH (person1:Person {id: $person1Id}), (person2:Person {id: $person2Id})
+WITH shortestPath((person1)-[:KNOWS*]->(person2)) AS path
 RETURN
-    CASE path IS NULL
-        WHEN true THEN -1
-        ELSE length(path)
-    END AS shortestPathLength
+  CASE path IS NULL
+    WHEN true THEN -1
+    ELSE length(path)
+    END AS shortestPathLength;

cypher/queries/interactive-complex-14.cypher

@@ -1,35 +1,10 @@
-// Q14. Trusted connection paths
-/*
-:param [{ person1Id, person2Id }] => { RETURN
-  8796093022357 AS person1Id,
-  8796093022390 AS person2Id
-}
-*/
-MATCH path = allShortestPaths((person1:Person { id: $person1Id })-[:KNOWS*0..]-(person2:Person { id: $person2Id }))
-WITH collect(path) as paths
-UNWIND paths as path
-WITH path, relationships(path) as rels_in_path
-WITH
-    [n in nodes(path) | n.id ] as personIdsInPath,
-    [r in rels_in_path |
-        reduce(w=0.0, v in [
-            (a:Person)<-[:HAS_CREATOR]-(:Comment)-[:REPLY_OF]->(:Post)-[:HAS_CREATOR]->(b:Person)
-            WHERE
-                (a.id = startNode(r).id and b.id=endNode(r).id) OR (a.id=endNode(r).id and b.id=startNode(r).id)
-            | 1.0] | w+v)
-    ] as weight1,
-    [r in rels_in_path |
-        reduce(w=0.0,v in [
-        (a:Person)<-[:HAS_CREATOR]-(:Comment)-[:REPLY_OF]->(:Comment)-[:HAS_CREATOR]->(b:Person)
-        WHERE
-                (a.id = startNode(r).id and b.id=endNode(r).id) OR (a.id=endNode(r).id and b.id=startNode(r).id)
-        | 0.5] | w+v)
-    ] as weight2
-WITH
-    personIdsInPath,
-    reduce(w=0.0,v in weight1| w+v) as w1,
-    reduce(w=0.0,v in weight2| w+v) as w2
+MATCH path = allShortestPaths((person1:Person {id: $person1Id})-[:KNOWS*..15]-(person2:Person {id: $person2Id}))
+WITH nodes(path) AS pathNodes
 RETURN
-    personIdsInPath,
-    (w1+w2) as pathWeight
-ORDER BY pathWeight desc
+  extract(n IN pathNodes | n.id) AS personIdsInPath,
+  reduce(weight = 0.0, idx IN range(1, size(pathNodes) - 1) | extract(prev IN [pathNodes[idx - 1]] | extract(curr IN [
+    pathNodes[idx]] | weight + length((curr)<-[:HAS_CREATOR]-(:Comment)-[:REPLY_OF]->(:Post)
+    -[:HAS_CREATOR]->(prev)) * 1.0 + length((prev)<-[:HAS_CREATOR]-(:Comment)-[:REPLY_OF]->(:Post)
+    -[:HAS_CREATOR]->(curr)) * 1.0 + length((prev)-[:HAS_CREATOR]-(:Comment)-[:REPLY_OF]-(:Comment)
+    -[:HAS_CREATOR]-(curr)) * 0.5))[0][0]) AS pathWight
+  ORDER BY pathWight DESC