# The Graph Database You Did not Know You Had

*by*Phil Tadros

PostgreSQL (Postgres), is a strong relational database that may retailer a variety of knowledge sorts and information buildings. In the case of storing graph information buildings we’d attain for a database marketed for that use case like Neo4J or Dgraph. Maintain your horses! Whereas Postgres will not be usually considered when working with graph information buildings, it’s completely succesful to retailer and question graph information effectively.

## Understanding Graph Knowledge Constructions

Earlier than we introduce Postgres as a graph database we have to know what a graph information construction is. A graph, or a graph information construction, is a group of nodes and edges, the place every node represents an entity or *“factor”*, and every edge represents the connection between two nodes.

To consider graphs when it comes to code, we could write TypeScript that appears like this:

```
class Node {
edges: Edge[] = [];
information: string;
}
class Edge {
previousNode: Node;
nextNode?: Node;
}
```

Every node comprises an inventory of its edges, and every edge comprises a reference to the subsequent/earlier node. As we’ll see in SQL later, the nodes don’t at all times have to find out about their edges.

Fb is a well-liked social media platform that makes use of a graph to signify folks and their relationships. An individual can have pals, and people pals even have their checklist of pals. Every particular person is represented as a node, and every friendship can be represented as an edge. Graphs are used to mannequin loads of totally different purposes like your npm dependencies, workflows, transportation programs, manufacturing strains, and extra!

## Storing Graph Knowledge Constructions in Postgres

To retailer a graph in Postgres we solely have to create two tables: `nodes`

and `edges`

. The `nodes`

desk will retailer details about every entity, whereas the `edges`

desk will retailer details about the relationships between entities.

Let’s begin by making a `nodes`

desk:

```
CREATE TABLE nodes (
id SERIAL PRIMARY KEY,
information VARCHAR(255)
);
```

The `nodes`

desk we outlined right here has two columns: id and information. The id column is an auto-incrementing integer that serves as the first key for the desk. The information column is a string that shops any further information related to the node. For this instance, we’re preserving it easy and solely storing a string column, however in real-world purposes, this desk might be something and have any variety of columns.

Crucial desk when making a graph information construction is the `edges`

desk:

```
CREATE TABLE edges (
previous_node INTEGER REFERENCES nodes(id),
next_node INTEGER REFERENCES nodes(id),
PRIMARY KEY (previous_node, next_node)
);
```

Right here, we’re creating two columns, `previous_node`

and `next_node`

, that signify {our relationships} between nodes. Every of those columns represents a international key to a node. The vital take away is an `edges`

desk references two rows in the identical desk. An edge can solely have one `previous_node`

and `next_node`

pairing, so we’re utilizing a composite main key to make sure that every edge is exclusive and can’t reference itself.

With our tables created, we will now insert information into them.

```
INSERT INTO nodes (information) VALUES ('Bob');
INSERT INTO nodes (information) VALUES ('Hank');
INSERT INTO nodes (information) VALUES ('Jeff');
```

After which let’s join our nodes with edges:

```
INSERT INTO edges (previous_node, next_node) VALUES (1, 2);
INSERT INTO edges (previous_node, next_node) VALUES (1, 3);
```

nodes | |
---|---|

id | information |

1 | Bob |

2 | Hank |

3 | Jeff |

edges | |
---|---|

previous_node | next_node |

1 | 2 |

1 | 3 |

If we have been to visualise our graph at this level, it could seem like this:

## Querying Graph Knowledge Constructions in Postgres

With our graph information construction created, we will now question it utilizing SQL we all know and love!

Wish to know who Bob is pals with?

```
SELECT id, information
FROM nodes
JOIN edges ON nodes.id = edges.next_node
WHERE edges.previous_node = 1;
```

Discover all `nodes`

linked to the node with `id`

1 (Bob’s id).

Appears like Bob is common! However what if we wish to know who Bob’s pals are pals with?

Let’s insert a couple of extra nodes and edges to indicate this:

```
INSERT INTO nodes (information) VALUES ('Sally');
INSERT INTO nodes (information) VALUES ('Sue');
INSERT INTO nodes (information) VALUES ('Sam');
INSERT INTO edges (previous_node, next_node) VALUES (2, 4);
INSERT INTO edges (previous_node, next_node) VALUES (3, 4);
INSERT INTO edges (previous_node, next_node) VALUES (4, 5);
```

nodes | |
---|---|

id | information |

1 | Bob |

2 | Hank |

3 | Jeff |

4 | Sally |

5 | Sue |

6 | Sam |

edges | |
---|---|

previous_node | next_node |

1 | 2 |

1 | 3 |

2 | 4 |

3 | 4 |

4 | 5 |

To question for all Bob’s pals of pals we might prolong the earlier question to affix the `edges`

desk once more, however that may trigger a upkeep nightmare having to affix on every “degree” within the graph.

Postgres has a built-in function that enables us to question graph information with out having to know precisely what number of joins we want: recursive queries. Recursive queries permit us to traverse the graph ranging from a selected node and following its edges till some decided endpoint.

Writing a recursive question to search out all Bob’s pals and their pals we might write the next SQL:

```
WITH RECURSIVE friend_of_friend AS (
SELECT edges.next_node
FROM edges
WHERE edges.previous_node = 1
UNION
SELECT edges.next_node
FROM edges
JOIN friend_of_friend ON edges.previous_node = friend_of_friend.next_node
)
SELECT nodes.information
FROM nodes
JOIN friend_of_friend ON nodes.id = friend_of_friend.next_node;
```

This may be complicated at first look, so let’s break it down. A recursive question is made up of two elements: the bottom case and the recursive case. The bottom case is the place we wish to begin our question. The recursive case is the “loop” that can proceed to run till some endpoint is reached.

```
WITH RECURSIVE {identify} AS (
{base case}
UNION
{recursive case}
)
```

The fundamental SQL construction of a recursive question.

In our instance we wish to begin our question with Bob’s pals, so we discover the perimeters the place Bob (id: 1) is the `previous_node`

. Then within the recursive case we frequently be a part of the `edges`

desk to itself till we attain the tip of Bob’s graph (eg. after we attain `friend_of_friend.next_node = NULL`

). Lastly outdoors our recursive question we convey all of it collectively. We have to question the `nodes`

which are related to the perimeters from the recursive question so we will get every of Bob’s pals’ names.

## Conclusion

Through the use of options constructed into Postgres, we will retailer and question graph information buildings. We used an analogous method in my earlier job to dynamically generate work directions on a producing line. Based mostly on parameters given, and guidelines outlined on every edge, we might generate the proper doc by traversing a graph saved completely in Postgres. In case you are already utilizing Postgres in your relational information, you may combine graph information buildings into your current database with out including further programs!