It’s been a while, but I’ve finally
gotten off my arsefound some time to revisit this series. As promised last time, I’m going to rewrite the queries from the Adjacency List “solutions” using a View. Indeed, there will be two versions of the view - one which is a
MATERIALIZED VIEW. There will also be discussion of when the two different types of view might be best to use.
One of the reasons this post took so long to write was that I was sidetracked by writing an SVG generator that would allow for graphically seeing what the different operations discussed in this series look like in terms of an actual tree. That didn’t eventuate.
We will start by defining what our tree view will actually look like. You’ll notice is it rather like the CTE that we saw in the previous post.
CREATE TABLE nodes ( node_id SERIAL PRIMARY KEY, parent_id INTEGER REFERENCES nodes(node_id) ); CREATE RECURSIVE VIEW tree (node_id, ancestors) AS ( SELECT node_id, ARRAY::integer AS ancestors FROM nodes WHERE parent_id IS NULL UNION ALL SELECT nodes.node_id, tree.ancestors || nodes.parent_id FROM nodes, tree WHERE nodes.parent_id = tree.node_id ); INSERT INTO nodes VALUES (1, NULL), (2, 1), (3, 1), (4, 2), (5, 2), (6, 3), (7, 3), (8, 4), (9, 8), (10, NULL), (11, 10), (12, 11), (13, 11), (14, 12), (15, 12), (16, 12);
All of the insertions do not require access to the tree view, since the beauty of an Adjacency List model is that you only ever need to operate on the immediate parent-child.
Similarly, we will skip over the simple operations: those don’t require access to any more of the tree than just the parent-child relationship. It’s not until we need to remove a subtree that it becomes interesting.
DELETE FROM nodes WHERE node_id IN ( SELECT node_id FROM tree WHERE 2 = ANY(ancestors) ) OR node_id = 2;
If you are paying attention, you will notice that this is virtually identical to the CTE version, except that we no longer need to redeclare the CTE each time. The full tree deletion is the same, as is removing all decscendants:
DELETE FROM nodes WHERE node_id IN ( SELECT node_id FROM tree WHERE 2 = ANY(ancestors) );
Again, the operations that don’t require the actual tree are unchanged: this is where the Adjacency List really shines.
Since we are starting with the “full” tree, we should be able to use it for all of the queries. It is possible that these queries (unlike those we have seen before) may be slightly slower than the CTE version (specifically, those where the CTE is customised for that operation).
Let’s get all of node 10’s descendants:
SELECT node_id FROM tree WHERE 10 = ANY(ancestors);
This query is far less complicated than the CTE version, as expected. However, when dealing with very large datasets, it performs far worse. I have a data set with 221000 nodes, in 1001 different trees. Performing this query takes around 5 seconds, but the customised CTE version takes about 750ms.
Turning this view into a materialised view:
CREATE MATERIALIZED VIEW tree_mat AS SELECT node_id, ancestors FROM tree;
and then querying that turns this into around 75ms.
To limit the query to nodes to a given depth requires slightly more work.
SELECT node_id, ancestors FROM tree WHERE ARRAY_POSITION(ancestors, 10) < ARRAY_LENGTH(ancestors, 1) - 2;
Fetching ancestors of a node is again trivial:
SELECT unnest(ancestors) FROM tree WHERE node_id = 15;
And the count of ancestors:
SELECT ARRAY_LENGTH(ancestors, 1) FROM tree WHERE node_id=15;
Getting a set of ancestors to a given depth is actually a little tricky: because we can’t just reverse the end that we add the parent node to the ancestors array, we can’t use that trick. We’ll have to enumerate the rows, and then extract those we care about. You can’t use OFFSET with a variable, otherwise that would be a nice trick.
WITH ancestors AS ( SELECT unnest(ancestors) AS node_id FROM tree WHERE node_id = 15 ), enumerated AS ( SELECT row_number() OVER () AS row, count(*) OVER () AS ancestor_count, node_id FROM ancestors ) SELECT node_id FROM enumerated WHERE "row" > ancestor_count - 2;
Ugh. That’s way worse than the CTE version.
None of the special queries access the tree in any way, so can be omitted for now.
So how does using a view stack up to the ad-hoc CTE queries?
Mostly pretty well. In the case where you have only small data sets, then the view that builds up the complete tree each time is not that much of a problem (I ran some tests with tens of thousands of items, and it still performed relatively well). When it moves up to hundreds of thousands, then the ad-hoc CTE versions can greatly outperform the full tree view.
However, using a materialised view changes everything. It now becomes just as fast as querying a table: indeed, that’s just what it is. You could have triggers based on changes to the nodes table causing a
REFRESH MATERIALIZED VIEW, but it is worth keeping in mind that this will take some time: in my case, a full refresh of 221000 rows took upwards of 4.5 seconds.
Using a materialised view gets us most of the way to (and leads nicely into the next method), storing a materialised path. The similarity of the names here should be a trigger, but now I’m just making foreshadowing jokes.