delete_all_nodes

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

# Delete all nodes from the database.
from neo4j import GraphDatabase
import logging
from neo4j.exceptions import ServiceUnavailable
 
# Delete all previous nodes and links.
def delete_all_nodes(tx):
    statement = "MATCH (n) DETACH DELETE n"
    tx.run(statement)

This code starts with some import statements. It then defines the delete_all_nodes action method. The method takes a transaction object tx as a parameter and passes the string MATCH (n) DETACH DELETE n into the transaction's run method to make the database execute that command. Easy, right?

This is the basic pattern that all the action methods follow. They pass a database command into the transaction object's run method. The part that differentiates this action method from others is the database command.

The MATCH command is similar to a SQL query. It uses a pattern to match objects inside the database. Later parts of the command do things 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 before deleting 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.” (Now that you have the hang of it, the other action methods will go faster.)

make_node

The following code shows how the make_node method creates a new node:

# Use parameters to make a node.
def make_node(tx, id, title):
    statement = "CREATE (n:OrgNode { ID:<?b Start?>$id<?b End?>, Title:<?b Start?>$title<?b End?> })"
    parameters = {
        "id": id,
        "title": title
    }
    tx.run(statement, parameters)

This method creates a statement that uses the 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 EmployeeNode, ProductNode, CandyCaneNode, 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. The parts with the dollar signs (shown in bold) are placeholders. We'll provide values for the placeholders shortly.

Note that property names are case-sensitive in AuraDB, 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 make_node. The second entry associates the $title placeholder with the method's title parameter.

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

make_link

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

# Use parameters to create a link between an OrgNode and its parent.
def make_link(tx, id, boss):
    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)"
    )
    parameters = {
        "id": id,
        "boss": boss
    }
    tx.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.

execute_node_query

The following code shows the execute_node_query 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 a list of strings with the format "ID: Title".
def execute_node_query(tx, query):
    result = []
    for record in tx.run(query):
        node = record["n"]
        result.append(f"{node['ID']}: {node['Title']}")
    return result

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

Inside the loop, it uses record["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 of results.

find_path

The following code shows how the find_path 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 a list of strings with the format "ID: Title".
def find_path(tx, id1, id2):
    statement = (
        "MATCH"
        "    (start:OrgNode { ID:$id1 } ),"
        "    (end:OrgNode { ID:$id2 } ), "
        "    p = shortestPath((start)-[:REPORTS_TO *]-(end)) "
        "RETURN p"
    )
    parameters = {
        "id1": id1,
        "id2": id2
    }
 
    record = tx.run(statement, parameters).single()
    path = record["p"]
    result = []
    for node in path.nodes:
        result.append(f"{node['ID']}: {node['Title']}")
 
    return result

This code looks for two nodes that have the IDs id1 and id2 that were 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 in a variable named 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.

build_org_chart

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

# Build the org chart.
def build_org_chart(tx):
    # Make the nodes.
    make_node(tx, "A", "President")
    make_node(tx, "B", "VP Ambiguity")
    make_node(tx, "C", "VP Shtick")
    make_node(tx, "D", "Dir Puns and Knock-Knock Jokes")
    make_node(tx, "E", "Dir Riddles")
    make_node(tx, "F", "Mgr Pie and Food Gags")
    make_node(tx, "G", "Dir Physical Humor")
    make_node(tx, "H", "Mgr Pratfalls")
    make_node(tx, "I", "Dir Sight Gags")
 
    # Make the links.
    make_link(tx, "B", "A")
    make_link(tx, "C", "A")
    make_link(tx, "D", "B")
    make_link(tx, "E", "B")
    make_link(tx, "F", "C")
    make_link(tx, "G", "C")
    make_link(tx, "H", "G")
    make_link(tx, "I", "G")

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

Notice that each call to make_node and make_link includes the transaction object that build_org_chart received as a parameter.

query_org_chart

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

# Perform some queries on the org chart.
def query_org_chart(tx):
    # Get F.
    print("F:")
    result = execute_node_query(tx,
        "MATCH (n:OrgNode { ID:'F' }) " +
        "return n")
    print(f"    {result[0]}")
 
    # Who reports directly to B.
    print("
Reports directly to B:")
    result = execute_node_query(tx,
        "MATCH " +
        "    (n:OrgNode)-[:REPORTS_TO]->(a:OrgNode { ID:'B' }) " +
        "return n " +
        "ORDER BY n.ID")
    for s in result:
        print("    " + s)
 
    # Chain of command for H.
    print("
Chain of command for H:")
    result = find_path(tx, "H", "A")
    for s in result:
        print("    " + s)
 
    # All reports for C.
    print("
All reports for C:")
    result = execute_node_query(tx,
        "MATCH " +
        "    (n:OrgNode)-[:REPORTS_TO *]->(a:OrgNode { ID:'C' }) " +
        "return n " +
        "ORDER BY n.ID")
    for s in result:
        print("    " + s)

This method first calls the execute_node_query method to execute the following query.

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

This query finds the node with ID equal to F. The code prints the result.

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 find_path 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 of 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.