I recently started working with Neo4j/cypher and have been able to successfully build most basic queries that come to mind but the solution to this one escapes me.

The nodes have a very simple relationship model: Books are grouped into Categories

The books will be unique and can be related to multiple categories.

My base query collects the categories, resulting in a set of books with their associated categories:

match (c:Category)-[:contains]-(b:Book)

return b as book, collect(distinct c) as categories

I can then collect the books, resulting in a set of related books and categories:

match (c:Category)-[:contains]-(b:Book)

with b, collect(distinct c) as categories

return collect(distinct b) as books, categories

This seems to be going in the right direction but there are many duplicate books and categories throughout. Here is a pseudo example:

Books                         Categories

-----------------------------------------------

[Easy Home Updates]           [Home and Garden]

-----------------------------------------------

[Gardening Today,             [Outdoors,

 Gardening for Kids,           Hobbies,

 Green Thumb Made Easy]        Gardening]

-----------------------------------------------

[Conversational Spanish,      [Spanish,

 Spanish for Travelers,        Travel,

 Advanced Spanish]             Language]

-----------------------------------------------

[Gardening Today,             [Gardening,

 Gardening for Kids]           Kids]

-----------------------------------------------

[Home Improvement,            [Home Improvement,

 Easy Home Updates,            Home and Garden,

 Family Home Projects]         Family]

-----------------------------------------------

[Gardening Today]             [Gardening]

-----------------------------------------------

[Conversational Spanish,      [Language,

 Advanced Spanish]             Spanish]

I cannot seem to find a way to aggregate the duplicates either in the initial match with filtering or the reduce and apoc functions.

The desired result would be to reduce both the book and category collections. Something like this:

Books                         Categories

----------------------------------------------

[Gardening Today,             [Gardening,

 Gardening for Kids,           Outdoors,

 Green Thumb Made Easy]        Hobbies,

                               Kids,

                               Family]

----------------------------------------------

[Conversational Spanish,      [Spanish,

 Spanish for Travelers,        Language,

 Advanced Spanish]             Travel,

                               Education]

----------------------------------------------

[Home Improvement,            [Home and Garden,

 Easy Home Updates,            Home Improvement,

 Family Home Projects]         Construction]

Or maybe my approach is completely off and there is a better, more efficient way to group the related nodes.

Any help you can provide to point me in the right direction would be greatly appreciated. Please let me know if you need any further clarification.

Creating your model

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

CREATE

  (categoryHome:Category {name: 'Home and Garden'}),

  (categoryOutdoor:Category {name: 'Outdoors'}),

  (categoryHobby:Category {name: 'Hobbies'}),

  (categoryGarden:Category {name: 'Gardening'}),

  (categorySpanish:Category {name: 'Spanish'}),

  (categoryTravel:Category {name: 'Travel'}),

  (categoryLanguage:Category {name: 'Language'}),

  (categoryKids:Category {name: 'Kids'}),

  (categoryImprovement:Category {name: 'Home Improvement'}),

  (categoryFamily:Category {name: 'Family'}),

  (book1:Book {name: 'Easy Home Updates'}),

  (book2:Book {name: 'Gardening Today'}),

  (book3:Book {name: 'Gardening for Kids'}),

  (book4:Book {name: 'Green Thumb Made Easy'}),

  (book5:Book {name: 'Conversational Spanish'}),

  (book6:Book {name: 'Spanish for Travelers'}),

  (book7:Book {name: 'Advanced Spanish'}),

  (book8:Book {name: 'Home Improvement'}),

  (book9:Book {name: 'Easy Home Updates'}),

  (book10:Book {name: 'Family Home Projects'}),

  (categoryHome)-[:CONTAINS]->(book1),

  (categoryHome)-[:CONTAINS]->(book8),

  (categoryHome)-[:CONTAINS]->(book9),

  (categoryHome)-[:CONTAINS]->(book10),

  (categoryOutdoor)-[:CONTAINS]->(book2),

  (categoryOutdoor)-[:CONTAINS]->(book3),

  (categoryOutdoor)-[:CONTAINS]->(book4),

  (categoryHobby)-[:CONTAINS]->(book2),

  (categoryHobby)-[:CONTAINS]->(book3),

  (categoryHobby)-[:CONTAINS]->(book4),

  (categoryGarden)-[:CONTAINS]->(book2),

  (categoryGarden)-[:CONTAINS]->(book3),

  (categoryGarden)-[:CONTAINS]->(book4),

  (categorySpanish)-[:CONTAINS]->(book5),

  (categorySpanish)-[:CONTAINS]->(book6),

  (categorySpanish)-[:CONTAINS]->(book7),

  (categoryTravel)-[:CONTAINS]->(book5),

  (categoryTravel)-[:CONTAINS]->(book6),

  (categoryTravel)-[:CONTAINS]->(book7),

  (categoryLanguage)-[:CONTAINS]->(book5),

  (categoryLanguage)-[:CONTAINS]->(book6),

  (categoryLanguage)-[:CONTAINS]->(book7),

  (categoryKids)-[:CONTAINS]->(book2),

  (categoryKids)-[:CONTAINS]->(book3),

  (categoryImprovement)-[:CONTAINS]->(book8),

  (categoryImprovement)-[:CONTAINS]->(book9),

  (categoryImprovement)-[:CONTAINS]->(book10),

  (categoryFamily)-[:CONTAINS]->(book8),

  (categoryFamily)-[:CONTAINS]->(book9),

  (categoryFamily)-[:CONTAINS]->(book10);

Explanation

In my eyes, your technical implementation is right, but your requirements from a professional point of view are not consistent.
Let us choose an example. You expect the following record:

BOOKS:                        CATEGORIES:

Gardening Today,              Gardening,

Gardening for Kids,           Outdoors,

Green Thumb Made Easy         Hobbies,

                              Kids,

                              Family

By executing the following Cypher query, the Family entry is not a valid category for the book Gardening Today.

MATCH (book:Book {name: 'Gardening Today'})<-[:CONTAINS]-(category:Category)

RETURN DISTINCT book.name, collect(category.name);



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

│"book.name"      │"collect(category.name)"                 │

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

│"Gardening Today"│["Kids","Gardening","Hobbies","Outdoors"]│

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

Doing the cross check confirms category Family contains completly other books.

MATCH (category:Category {name: 'Family'})-[:CONTAINS]->(book:Book)

RETURN DISTINCT category.name, collect(book.name);

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

│"category.name"│"collect(book.name)"                                           │

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

│"Family"       │["Family Home Projects","Easy Home Updates","Home Improvement"]│

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

This procedure continues to propagate. That's the reason why you get differently sliced result sets as expected. So your already implemented approach is correct:

MATCH path = (category:Category)-[:CONTAINS]->(book:Book)

WITH collect(category.name) AS categoryGroup, book.name AS bookName

RETURN categoryGroup, collect(bookName);



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

│"categoryGroup"                                                  │"collect(bookName)"                                                  │

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

│["Spanish","Travel","Language"]                                  │["Spanish for Travelers","Advanced Spanish","Conversational Spanish"]│

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

│["Home Improvement","Family","Home and Garden","Home and Garden"]│["Easy Home Updates"]                                                │

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

│["Hobbies","Gardening","Kids","Outdoors"]                        │["Gardening Today","Gardening for Kids"]                             │

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

│["Hobbies","Gardening","Outdoors"]                               │["Green Thumb Made Easy"]                                            │

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

│["Home Improvement","Family","Home and Garden"]                  │["Home Improvement","Family Home Projects"]                          │

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

Extension

Underlying Idea

Because the requested mapping violates the assignment rules (set theory), we can not use the usual pattern matching. Instead, we can achieve our goal through a trick by finding all connected nodes for a given book and preparing them afterwards.

Please ensure you have installed the Neo4j APOC library.

Solution

MATCH (selectedBook:Book)

  WHERE selectedBook.name = 'Gardening for Kids'

CALL apoc.path.subgraphNodes(selectedBook, {uniqueness: 'NODE_GLOBAL'}) YIELD node

WITH collect(DISTINCT node) AS subgraphNodes

WITH

  filter (node IN subgraphNodes

    WHERE node:Category) AS categories,

  filter (node IN subgraphNodes

    WHERE node:Book) AS books

WITH categories, books

UNWIND categories AS category

UNWIND books AS book

RETURN collect(DISTINCT category.name) AS categoryNames, collect(DISTINCT book.name) AS bookNames;

Explanation

• lines 1-2: selecting the book under inspection


• line 3: using the APOC procedure apoc.path.subgraphNodes for locating all connected nodes


• lines 6-9: sorting the identified nodes by label Category and Book


• lines 10-13: result preparation

Results

Easy Home Updates:

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

│"categoryNames"                                │"bookNames"                                                    │

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

│["Home and Garden","Family","Home Improvement"]│["Easy Home Updates","Family Home Projects","Home Improvement"]│

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

Gardening for Kids:

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

│"categoryNames"                         │"bookNames"                             │

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

│["Kids","Gardening","Hobbies","Outdoors"│["Gardening for Kids","Gardening Today",│

│]                                       │"Green Thumb Made Easy"]                │

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