DeleteAllNodes

The following code shows how the DeleteAllNodes method deletes all the nodes in the database:

using Neo4j.Driver;
…
// Delete all previous nodes and links.
static void DeleteAllNodes(IDriver driver)
{
    using (ISession session = driver.Session())
    {
        string statement = "MATCH (n) DETACH DELETE n";
        session.Run(statement);
    }
}

The module includes the statement using Neo4j.Driver to make it easier to use the driver.

The DeleteAllNodes method takes a driver object as a parameter, uses it to create a session object, and then uses the session object's Run method to execute the database command MATCH (n) DETACH DELETE n.

Notice that the session object is created in a using block, so it is automatically disposed of when we're done with it. The other methods in this example use a similar approach. Alternatively, you could create a single session and pass it around to all the methods.

The MATCH command is similar to a SQL query. It uses a pattern to match objects inside the database. Then later parts of the command do something with any objects that match.

In this case, the pattern (n) matches any node. In general, expressions inside parentheses () match nodes and expressions surrounded by square brackets [] match relationships.

Note that you cannot delete a node if it is involved in any relationships. (This is kind of like a graph database version of a foreign key constraint.) You can either delete the relationships first or include the DETACH keyword to tell the database to delete those relationships automatically with the node.

The last part of the command is DELETE n, which deletes the node n. Here, n is a node that was matched by the MATCH (n) part of the command.

To summarize, this statement says, “Match all nodes, detach their relationships, and then delete them.”

MakeNode

The following code shows the MakeNode method:

// Use parameters to make a node.
static void MakeNode(IDriver driver, string id, string title)
{
    using (ISession session = driver.Session())
    {
        string statement = "CREATE (n:OrgNode { ID:$id, Title:$title })";
        Dictionary<string, object> parameters =
            new Dictionary<string, object>()
            {
                {"id", id},
                {"title", title},
            };
        session.Run(statement, parameters);
    }
}

This method creates a session and then composes a CREATE command to add a node to the database. The n:OrgNode part tells the database that this node's type is OrgNode. That's just a name that I made up for this kind of node. You could create CustomerNode, RecipeNode, SaberToothDuckNode, or any node types that make sense for your application. You also don't need to include the word Node; I just decided that it would make the queries easier to understand.

The part of the statement that's inside the curly brackets tells the database to give the node two properties, ID and Title. We'll provide values for the placeholders with the dollar signs shortly.

Note that property names are case-sensitive, so if you create a Title property and later search for a title value, you won't get any matches. (And you'll waste a lot of time wondering why not.)

The code then makes a dictionary that uses the placeholder names as keys and supplies values for them. The first dictionary entry associates the $id placeholder with the parameter id that was passed into MakeNode. The second entry associates the $title placeholder with the method's title parameter.

The code finishes by calling the session object's Run method, passing it the command string and the parameters dictionary.

MakeLink

The following code shows how the MakeLink method creates a relationship between two nodes:

// Use parameters to create a link between an OrgNode and its parent.
static void MakeLink(IDriver driver, string id, string boss)
{
    using (ISession session = driver.Session())
    {
        string statement =
            "MATCH" +
            "    (a:OrgNode)," +
            "    (b:OrgNode) " +
            "WHERE" +
            "    a.ID = $id AND " +
            "    b.ID = $boss " +
            "CREATE (a)-[r:REPORTS_TO { Name:a.ID + '->' + b.ID }]->(b) ";
        Dictionary<string, object> parameters =
            new Dictionary<string, object>()
            {
                {"id", id},
                {"boss", boss},
            };
        session.Run(statement, parameters);
    }
}

This method creates a REPORTS_TO link for the org chart. The MATCH statement looks for two OrgNode objects, a and b, where a.ID matches the id parameter passed into the method and b.ID matches the boss parameter.

After the MATCH statement finds those two nodes, the CREATE command makes a new REPORTS_TO relationship leading from node a to node b. It gives the relationship a Name property that contains the two IDs separated by ->. For example, if the nodes' IDs are A and B, then this relationship's Name is A->B.

ExecuteNodeQuery

The following code shows the ExecuteNodeQuery method, which executes a query that matches nodes that are named n in the query. This method returns a list of the query's results:

// Execute a query that returns zero or more nodes
// identified by the name "n".
// Return the nodes in the format "ID: Title".
static List<string> ExecuteNodeQuery(IDriver driver, string query)
{
    List<string> result = new List<string>();
    using (ISession session = driver.Session())
    {
        foreach (IRecord record in session.Run(query))
        {
            INode node = (INode)record.Values["n"];
            result.Add($"{node["ID"]}: {node["Title"]}");
        }
    }
    return result;
}

The method first creates a list to hold results. It then runs the query and loops through the records that it returns.

Inside the loop, it uses record.Values["n"] to get the result named n from the current record. That result will be a node selected by the MATCH statement. (You'll see that kind of MATCH statement a bit later.) The code copies the node's ID and Title properties into a string and adds the string to the result list.

After it finishes looping through the records, the method returns the list.

FindPath

The following code shows how the FindPath method finds a path between two nodes in the org chart:

// Execute a query that returns a path from node id1 to node id2.
// Return the nodes in the format "ID: Title".
static List<string> FindPath(IDriver driver, string id1, string id2)
{
    List<string> result = new List<string>();
    using (ISession session = driver.Session())
    {
        string statement =
            "MATCH" +
            "    (start:OrgNode { ID:$id1 } )," +
            "    (end:OrgNode { ID:$id2 } ), " +
            "    p = shortestPath((start)-[:REPORTS_TO *]-(end)) " +
            "RETURN p";
        Dictionary<string, object> parameters =
            new Dictionary<string, object>()
            {
                {"id1", id1},
                {"id2", id2},
            };
 
        // Get one path.
        IRecord record = session.Run(statement, parameters).Single();
        IPath path = (IPath)record.Values["p"];
 
        foreach (INode node in path.Nodes)
        {
            result.Add($"{node["ID"]}: {node["Title"]}");
        }
    }
    return result;
}

This code looks for two nodes that have the IDs passed into the method as parameters. It names the matched nodes start and end.

It then calls the database's shortestPath method to find a shortest path from start to end following REPORTS_TO relationships. The * means the path can have any length. The statement saves the path that it found with the name p.

Note that the shortestPath method only counts the number of relationships that it crosses; it doesn't consider costs or weights on the relationships. In other words, it looks for a path with the fewest steps, not necessarily the shortest total cost as you would like in a street network, for example. Some AuraDB databases can perform the least total cost calculation and execute other graph algorithms, but the free version cannot.

After it composes the database command, the method executes it, passing in the necessary parameters. It calls the result's single method to get the first returned result.

It then looks at that result's p property, which holds the path. (Remember that the statement saved the path with the name p.)

The code loops through the path's nodes and adds each one's ID and Title values to a result list. The method finishes by returning that list.

BuildOrgChart

The following code shows how the BuildOrgChart method builds the org chart:

// Build the org chart.
static void BuildOrgChart(IDriver driver)
{
    // Make the nodes.
    MakeNode(driver, "A", "President");
    MakeNode(driver, "B", "VP Ambiguity");
    MakeNode(driver, "C", "VP Shtick");
    MakeNode(driver, "D", "Dir Puns and Knock-Knock Jokes");
    MakeNode(driver, "E", "Dir Riddles");
    MakeNode(driver, "F", "Mgr Pie and Food Gags");
    MakeNode(driver, "G", "Dir Physical Humor");
    MakeNode(driver, "H", "Mgr Pratfalls");
    MakeNode(driver, "I", "Dir Sight Gags");
 
    // Make the links.
    MakeLink(driver, "B", "A");
    MakeLink(driver, "C", "A");
    MakeLink(driver, "D", "B");
    MakeLink(driver, "E", "B");
    MakeLink(driver, "F", "C");
    MakeLink(driver, "G", "C");
    MakeLink(driver, "H", "G");
    MakeLink(driver, "I", "G");
}

This method calls the MakeNode method repeatedly to make the org chart's nodes. It then calls the MakeLink method several times to make the org chart's relationships.

Notice that each call to MakeNode and MakeLink includes the transaction object that BuildOrgChart received as a parameter.

QueryOrgChart

The following code shows how the QueryOrgChart method performs some queries on the finished org chart:

// Perform some queries on the org chart.
static void QueryOrgChart(IDriver driver)
{
    List<string> result;
 
    // Get F.
    Console.WriteLine("F:");
    result = ExecuteNodeQuery(driver,
        "MATCH (n:OrgNode { ID:'F' }) " +
        "return n");
    Console.WriteLine($"    {result[0]}");
 
    // Who reports directly to B.
    Console.WriteLine("
Reports directly to B:");
    result = ExecuteNodeQuery(driver,
        "MATCH " +
        "    (n:OrgNode)-[:REPORTS_TO]->(a:OrgNode { ID:'B' }) " +
        "return n " +
        "ORDER BY n.ID");
    foreach (string s in result)
        Console.WriteLine("    " + s);
 
    // Chain of command for H.
    Console.WriteLine("
Chain of command for H:");
    result = FindPath(driver, "H", "A");
    foreach (string s in result)
        Console.WriteLine("    " + s);
 
    // All reports for C.
    Console.WriteLine("
All reports for C:");
    result = ExecuteNodeQuery(driver,
        "MATCH " +
        "    (n:OrgNode)-[:REPORTS_TO *]->(a:OrgNode { ID:'C' }) " +
        "return n " +
        "ORDER BY n.ID");
    foreach (string s in result)
        Console.WriteLine("    " + s);
}

This method first calls the ExecuteNodeQuery method to execute the following query:

MATCH (n:OrgNode { ID:'F' }) return n

This simply finds the node with ID equal to F. The code prints it.

Next, the method looks for nodes that have the REPORTS_TO relationship ending with node B. That returns all of the nodes that report directly to node B. The code loops through the results displaying them.

The method then uses the FindPath method to find a path from node H to node A. Node A is at the top of the org chart, so this includes all the nodes in the chain of command from node H to the top.

The last query the method performs matches the following:

(n:OrgNode)-[:REPORTS_TO *]->(a:OrgNode { ID:'C' })

This finds nodes n that are related via any number (*) of REPORTS_TO relationships to node C. That includes all the nodes that report directly or indirectly to node C. Graphically, those are the nodes that lie below node C in the org chart.