The following will load the graph, run the algorithm, and stream results: 

CALL algo.unionFind.stream('User', 'LINK')
YIELD nodeId, setId
RETURN algo.asNode(nodeId).name AS Name, setId AS ComponentId
ORDER BY ComponentId, Name

To instead write the component ID to a node property in the Neo4j graph, use this query:

The following will load the graph with weights, run the algorithm, and write back results: 

CALL algo.unionFind('User', 'LINK', {
  write: true,
  writeProperty: 'componentId'
})
YIELD nodes AS Nodes, setCount AS NbrOfComponents, writeProperty AS PropertyName;

As we can see from the results, the nodes connected to one another are calculated by the algorithm as belonging to the same connected component.

By configuring the algorithm to use a weight we can increase granularity in the way the algorithm calculates component assignment. We do this by specifying the property key with the weightProperty configuration parameter. Additionally, we can specify a threshold for the weight value in such a way that only weighs greater than the threshold value will be considered by the algorithm. We do this by specifying the threshold value with the threshold configuration parameter.

If a relationship does not have a weight property, a default weight is used. The default is zero, and can be configured to another value using the defaultValue configuration parameter.

The following will load the graph with weights, run the algorithm, and stream results: 

CALL algo.unionFind.stream('User', 'LINK', {
  weightProperty: 'weight',
  threshold: 1.0
})
YIELD nodeId, setId

RETURN algo.asNode(nodeId).name AS Name, setId AS ComponentId
ORDER BY ComponentId, Name

The following will load the graph with weights, run the algorithm, and write back results: 

CALL algo.unionFind('User', 'LINK', {
  write: true,
  writeProperty: "componentId",
  weightProperty: 'weight',
  threshold: 1.0
})
YIELD nodes AS Nodes, setCount AS NbrOfComponents, writeProperty AS PropertyName;

As we can see from the results, the node named 'Bridget' is now in its own component, due to its relationship weight being less than the configured threshold and thus ignored.

It is possible to define preliminary component IDs for nodes using the seedProperty configuration parameter. This is helpful if we want to retain components from a previous run and it is known that no components have been split by removing relationships. The property value needs to be a number.

The algorithm first checks if there is a seeded component ID assigned to the node. If there is one, that component ID is used. Otherwise, a new unique component ID is assigned to the node.

Once every node belongs to a component, the algorithm merges components of connected nodes. When components are merged, the resulting component is always the one with the lower component ID.

To show this in practice, we will run the algorithm, then add another node to our graph, then run the algorithm again with the seedProperty configuration parameter. We will use the weighted variant of WCC.

The following will load the graph, run the algorithm, and write back results: 

CALL algo.unionFind('User', 'LINK', {
  write: true,
  writeProperty: 'componentId',
  weightProperty: 'weight',
  threshold: 1.0
})
YIELD nodes AS Nodes, setCount AS NbrOfComponents, writeProperty AS PropertyName;

The following will create a new node in the Neo4j graph, with no component ID: 

MATCH (b:User {name: 'Bridget'})
CREATE (b)-[:LINK {weight: 2.0}]->(new:User {name: 'Mats'})

The following will load the graph, run the algorithm, and stream results: 

CALL algo.unionFind.stream('User', 'LINK', {
  seedProperty: 'componentId',
  weightProperty: 'weight',
  threshold: 1.0
})
YIELD nodeId, setId

RETURN algo.asNode(nodeId).name AS Name, setId AS ComponentId
ORDER BY ComponentId, Name

The following will load the graph, run the algorithm, and write back results: 

CALL algo.unionFind('User', 'LINK', {
  seedProperty: 'componentId',
  weightProperty: 'weight',
  threshold: 1.0,
  write: true,
  writeProperty: 'componentId'
})
YIELD nodes AS Nodes, setCount AS NbrOfComponents, writeProperty AS PropertyName;

In the examples above, we have relied on the implicit loading of graphs for the algorithm computation. However, like other algorithms WCC also accepts named graphs and Cypher projections as inputs. See Projected Graph Model for more details.

Using a named graph: 

CALL algo.graph.load('myGraph', 'User', 'LINK');

CALL algo.unionFind.stream(null, null, {graph: 'myGraph'})
YIELD nodeId, setId
RETURN algo.asNode(nodeId).name AS Name, setId AS ComponentId
ORDER BY ComponentId, Name;

As we can see, the results are identical to the results in the Section 6.3.3.1, “Unweighted” example.

Using a Cypher projection: 

CALL algo.unionFind.stream(
  'MATCH (u:User) RETURN id(u) AS id',
  'MATCH (u1:User)-[:LINK]->(u2:User)
   RETURN id(u1) AS source, id(u2) AS target',
   {graph:'cypher'}
)
YIELD nodeId, setId
RETURN algo.asNode(nodeId).name AS Name, setId AS ComponentId
ORDER BY ComponentId, Name

Again, results are identical, as the Cypher projection we use mimics the behaviour of the default loading configuration. Of course, the Cypher projection feature enables more advanced control over which exact parts of the graph to compute over; please see Section 2.2, “Cypher projection” for more details.