Understand relationship aggregation

What is Relationship Aggregation?

Relationship aggregation combines multiple relationships between the same pair of nodes into a single relationship with a single weight to represent all of them.

This is useful for a number of use-cases, not least:

Example 1: In a graph tracking logistics operations, you may create a new relationship for every shipment between two locations.

Instead of projecting all of these relationships separately, you can aggregate them to a single relType with a weight to represent the number of relationships in the original graph.

Example 2: Throughout this course, you have been using a collaboration network of actor to actor relationships, turning this:

Into this:

However, the connections made, are often not so simple as that. Consider for example, Robert De Niro and Joe Pesci.

When you create your projection, De Niro and Pesci will not be connected by a single, bidirectional relationship:

Two actors who worked together on four different movies would have four bidirectional relationships in your projection, adding up to eight in total.

During projection, you can aggregate these into a single weighted relationship where the weight represents the collaboration count.

Why this matters:

Aggregation vs. Existing Properties

Take a look at your existing property projection from lesson 8.

MATCH (source:User)-[r:RATED]->(target:Movie)
WITH gds.graph.project(
  'user-movie',
  source,
  target,
  {
    relationshipProperties: r { .rating }
  },
  {}
) AS g
RETURN g.graphName

This projects one relationship per rating, using the existing rating property as the weight.

Now take a look at the projection you have been using to create your 'actor-network' projection:

MATCH (source:Actor)-[:ACTED_IN]->
  (:Movie)
    <-[:ACTED_IN]-(target:Actor)
WITH gds.graph.project(
  'actor-network',
  source,
  target,
  {},
  {
    undirectedRelationshipTypes: ['*'] //Optional
  }
) AS g
RETURN g.graphName

This query from earlier lessons has been allowing multiple relationships between two nodes.

Run it now, and check the number of relationships produced.

To create an aggregate version of it, we simply run the following modified version:

MATCH (source:Actor)-[r:ACTED_IN]->
  (:Movie)
    <-[:ACTED_IN]-(target:Actor)
WITH source, target, count(r) AS numberOfRels
WITH gds.graph.project(
  'actor-network-aggregated',
  source,
  target,
  {
    relationshipProperties: {rels: numberOfRels}
  },
  {
    undirectedRelationshipTypes: ['*'] //Optional
  }
) AS g
RETURN g.graphName AS graphName, g.relationshipCount

This projects one bidirectional relationship per actor pair, creating a weight from the count of duplicate relationships that were removed.

The key change is the count(r) AS numberOfRels aggregator at the top. When we add that to the Cypher statement, and include numberOfRels in relationshipProperties: it will automatically reduce parallel relationships to singletons.

Compare the relationship outputs from both, and you’ll see that the aggregator version has reduced the overall rel count.

How aggregation works

The key is using aggregation functions in a WITH clause before calling gds.graph.project().

Step 1: Match the pattern that creates parallel relationships

MATCH (source:Actor)-[r:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(target:Actor)

This finds all actor pairs who worked on movies together. For a source and target who worked on 4 movies together, this pattern matches 4 times.

Step 2: Aggregate with a function

WITH source, target, count(r) AS numberOfRels

The count(r) function collapses those 4 matches into a single row with collaborations = 4.

Step 3: Project with the aggregated value

WITH gds.graph.project(
  'actor-network-aggregated',
  source, target,
  {
    relationshipProperties: {rels: numberOfRels}
  },
  {
    undirectedRelationshipTypes: ['*']
  }
) AS g
RETURN g.graphName

The projection creates one relationship from source to target with rels: 4.

When to Use Relationship Aggregation

Use aggregated projections when:

Use non-aggregated projections when:

Example: Robert De Niro and Joe Pesci worked on 4 movies together. Without aggregation, you’d have 4 separate relationships in your projection. With aggregation, you have 1 relationship with rels: 4.

What’s Next

You now understand the concept of relationship aggregation and when to use it. You’ve seen how count(r) works in Cypher projections to collapse parallel relationships into single weighted relationships.

In the next lesson, you’ll practice aggregating relationships hands-on, building projections that count relationships between actors, directors, and other entities.