I've got a model that looks like this

I want to for a player to recommend a quest that would allow to complete his set of armor. I am doing this cypher query to return relationship quest -> boots.

MATCH (w:Armor)<-[:WEARS]-(p:Player)

MATCH (w)-[:PART_OF]->(set:ArmorSet)

MATCH (missing)-[:PART_OF]->(set)

MATCH (missing)<--(anything)

WHERE NOT (p)-[:WEARS]->(missing)

RETURN missing, anything

But how to adjust this query to return the NPC that gives the quest if boots is the reward of the quest? Basically I want to check that if the node is of quest type, then I should return npc that gives that quest.

How to achieve that in Neo4j?

Original answer

Creating your graph

For the ease of possible further answers and solutions I note my graph creating statement:

CREATE

  (player:Player {name: 'Player'}),

  (shield:Armor {name: 'Shield'}),

  (armor:Armor {name: 'Armor'}),

  (gauntlets:Armor {name: 'Gauntlets'}),

  (boots:Armor {name: 'Boots'}),

  (helmet:Armor {name: 'Helmet'}),

  (dragonSet:ArmorSet {name: 'Dragon Set'}),

  (quest1:Quest {name: 'Quest I'}),

  (quest2:Quest {name: 'Quest II'}),

  (npc1:Npc {name: 'NPC I'}),

  (npc2:Npc {name: 'NPC II'}),

  (player)-[:WEARS]->(shield)-[:PART_OF]->(dragonSet),

  (player)-[:WEARS]->(armor)-[:PART_OF]->(dragonSet),

  (player)-[:WEARS]->(gauntlets)-[:PART_OF]->(dragonSet),

  (npc1)-[:PROVIDES]->(quest1)-[:REWARDS]->(boots)-[:PART_OF]->(dragonSet),

  (npc2)-[:PROVIDES]->(quest2)-[:REWARDS]->(helmet)-[:PART_OF]->(dragonSet);

Line 2 to 12 creates the nodes, whereas line 13 to 17 establishes the relationships between them.

Solution

MATCH

  (player:Player)-[:WEARS]->(armor:Armor)-[:PART_OF]->(dragonSet:ArmorSet),

  (missing)-[:PART_OF]->(dragonSet)

  WHERE NOT (player)-[:WEARS]->(missing:Armor)

WITH DISTINCT missing

MATCH (npc:Npc)-[:PROVIDES]->(quest:Quest)-[:REWARDS]->(missing)

RETURN npc.name AS npcName, quest.name AS questName, missing.name AS missingArmorName;

Explanation

• Line 2 defines the pattern "A Player wears an Armor, which is part of an ArmorSet".


• Line 3 introduces the variable missing that is necessary for the exclusion "Player wears a missing Armor" in line 4

"The WITH clause allows query parts to be chained together, piping the results from one to be used as starting points or criteria in the next." (Taken from Neo4j developers manual, WITH clauses chapter)

• Line 6 for the identified missing Armors retrieve the Quest providing Npcs


• Line 7 render the desired output

Result

╒═════════╤═══════════╤══════════════════╕

│"npcName"│"questName"│"missingArmorName"│

╞═════════╪═══════════╪══════════════════╡

│"NPC II" │"Quest II" │"Helmet"          │

├─────────┼───────────┼──────────────────┤

│"NPC I"  │"Quest I"  │"Boots"           │

└─────────┴───────────┴──────────────────┘

Extension regarding your comment

If it is important to identify Armors that can be retrieved by Quests only, we have to enhance your model by a label Monster with an according relationship RANDOM_DROPS.

Creating your graph

CREATE

  (player:Player {name: 'Player'}),

  (shield:Armor {name: 'Shield'}),

  (armor:Armor {name: 'Armor'}),

  (gauntlets:Armor {name: 'Gauntlets'}),

  (boots:Armor {name: 'Boots'}),

  (helmet:Armor {name: 'Helmet'}),

  (dragonSet:ArmorSet {name: 'Dragon Set'}),

  (quest1:Quest {name: 'Quest I'}),

  (quest2:Quest {name: 'Quest II'}),

  (npc1:Npc {name: 'NPC I'}),

  (npc2:Npc {name: 'NPC II'}),

  (monster1:Monster {name: 'Monster I'}),

  (monster2:Monster {name: 'Monster II'}),

  (player)-[:WEARS]->(shield)-[:PART_OF]->(dragonSet),

  (player)-[:WEARS]->(armor)-[:PART_OF]->(dragonSet),

  (player)-[:WEARS]->(gauntlets)-[:PART_OF]->(dragonSet),

  (npc1)-[:PROVIDES]->(quest1)-[:REWARDS]->(boots)-[:PART_OF]->(dragonSet),

  (npc2)-[:PROVIDES]->(quest2)-[:REWARDS]->(helmet)-[:PART_OF]->(dragonSet),

  (monster2)-[:RANDOM_DROPS]->(boots),

  (monster1)-[:RANDOM_DROPS]->(gauntlets),

  (monster1)-[:RANDOM_DROPS]->(shield),

  (monster1)-[:RANDOM_DROPS]->(armor);

Solution

MATCH

  (player:Player)-[:WEARS]->(armor:Armor)-[:PART_OF]->(dragonSet:ArmorSet),

  (missing)-[:PART_OF]->(dragonSet)

  WHERE NOT (player)-[:WEARS]->(missing:Armor)

WITH DISTINCT missing

MATCH (npc:Npc)-[:PROVIDES]->(quest:Quest)-[:REWARDS]->(missing)

  WHERE NOT (:Monster)-[:RANDOM_DROPS]->(missing)

RETURN npc.name AS npcName, quest.name AS questName, missing.name AS missingArmorName;

Result

╒═════════╤═══════════╤══════════════════╕

│"npcName"│"questName"│"missingArmorName"│

╞═════════╪═══════════╪══════════════════╡

│"NPC II" │"Quest II" │"Helmet"          │

└─────────┴───────────┴──────────────────┘

The coalesce function in Neo4j can be used to compress multiple variables to use the most relevant, non-null value.

MATCH (w:Armor)<-[:WEARS]-(p:Player)

MATCH (w)-[:PART_OF]->(set:ArmorSet)

MATCH (missing)-[:PART_OF]->(set)

MATCH (missing)<--(anything)

WHERE NOT (p)-[:WEARS]->(missing)

OPTIONAL MATCH (anything)<-[:GIVES]-(source)

RETURN missing, coalesce(source, anything) as source

So in this example, coalesce will return the value of source if their is one, otherwise it will move to the next one and repeat. If all values are null, it will return null.