Recursively walking a DAG in an SQL table - sql

Question

I have a graph which consists of two types of nodes Task and Subtask. Lists of these are stored along with metadata (for now, we can just assume a single metadata string column called "name") in two tables TaskTable and SubTaskTable. Tasks will have subtasks under them which will be connected in the form of a DAG. A Task A might have 5 subtasks st1, st2, st3, st4, and st5 which are connected like so
This is represented in the database like so in a dependencies table.
| for_task | from_subtask | to_subtask |
|----------+--------------+------------|
| A | 1 | 2 |
| A | 1 | 3 |
| A | 2 | 4 |
| A | 3 | 4 |
| A | 4 | 5 |
So far so, good. However, now, there is a possibility that another task B will have a similar DAG for its own subtasks which is okay too.
The third requirement is that a Task should be able to have another Task as a dependency and there should be some way to "expand" the subtask tree when I take the top level task. For example,
And B itself has subtasks like so
I've changed my dependencies table to hold this information as well like so
| for_task | from_task | from_subtask | to_task | to_subtask |
|----------+-----------+--------------+---------+------------|
| A | | 1 | | 2 |
| A | | 1 | | 3 |
| A | | 2 | | 4 |
| A | | 3 | | 4 |
| A | | 4 | | 5 |
| A | | 1 | B | |
| B | | 6 | | 7 |
| B | | 6 | | 8 |
| B | | 7 | | 8 |
| B | | 8 | | 9 |
I have two questions
Is this a good way to store this kind of information?
How would I construct a query that will give "expand" the task B when I get all the tasks for task A and give me the whole list of subtasks.
For 2, I'd expect something like this
| from_task | to_task |
|-----------+---------|
| 1 | 2 |
| 1 | 3 |
| 2 | 4 |
| 3 | 4 |
| 4 | 5 |
| 1 | 6 |The subtask here is directly linked to the subtask of B
| 6 | 7 |
| 6 | 8 |
| 7 | 8 |
| 8 | 9 |
No more tasks. Just a tree of subtasks.
This is using postgreSQL if that's relevant.

Answer 1

Instinctively, I would create a first table task which describes every tasks independently (also including maybe the subtasks to be decided) :
CREATE TABLE task
( name text PRIMARY KEY -- can add hereafter any kind of task attributes as new columns
) ;
Then I would keep your first table dependencies renamed as subtask_dependency with only 3 columns and add a foreign key to task :
CREATE TABLE subtask_dependency
( for_task text
, from_subtask text
, to_subtask text
, CONSTRAINT pk_subtask PRIMARY KEY (for_task, from_subtask, to_subtask)
, CONSTRAINT fk_task FOREIGN KEY (for_task) REFERENCES task (name)
MATCH SIMPLE ON UPDATE CASCADE ON DELETE RESTRICT
) ;
and I would create a second table task_dependency the same way :
CREATE TABLE task_dependency
( from_task text
, from_subtask text
, to_task text
, to_subtask text -- this column is not mandatory but it is helpful to store the root subtask of to_task
, CONSTRAINT pk_task PRIMARY KEY (from_task, from_subtask, to_task)
, CONSTRAINT fk_fromtask FOREIGN KEY (from_task) REFERENCES task (name)
MATCH SIMPLE ON UPDATE CASCADE ON DELETE RESTRICT
, CONSTRAINT fk_totask FOREIGN KEY (to_task) REFERENCES task (name)
MATCH SIMPLE ON UPDATE CASCADE ON DELETE RESTRICT
) ;
Then the query to get your expected result with only one level of nested task :
SELECT from_subtask, to_subtask
FROM subtask_dependency AS s
WHERE for_task = 'A'
UNION ALL
SELECT from_subtask, to_subtask
FROM task_dependency
WHERE from_task = 'A'
UNION ALL
SELECT s.from_subtask, s.to_subtask
FROM subtask_dependency AS s
LEFT JOIN task_dependency AS t
ON t.to_task = s.for_task
WHERE t.from_task = 'A'
And more generally, the query to get your expected result with multi level nested tasks :
WITH RECURSIVE list (from_task, from_subtask, to_task, to_subtask) AS
( SELECT NULL, NULL, from_task, from_subtask
FROM task_dependency
WHERE from_task = 'A'
UNION ALL
SELECT t.from_task, t.from_subtask, t.to_task, t.to_subtask
FROM list AS l
INNER JOIN task_dependency AS t
ON t.from_task = l.to_task
AND t.from_subtask = l.to_subtask
)
SELECT s.from_subtask, s.to_subtask
FROM list AS l
INNER JOIN subtask_dependency AS s
ON s.for_task = l.to_task
UNION ALL
SELECT l.from_subtask, l.to_subtask
FROM list AS l
WHERE l.from_subtask IS NOT NULL
ORDER BY 1, 2
see dbfiddle