fetching data from same table in multiple join hierarchy - sql

Question

I have a project with users, placed in some kind of hierarchy tree. a user can have multiple children and multiple parents. the organization chart looks like this :
this hierarchy uses 2 tables in database, user and position. here is the SQL to reproduce the tables with few fixtures to reproduce the organization image provided below:
-- phpMyAdmin SQL Dump
-- version 4.8.0
-- https://www.phpmyadmin.net/
--
-- Hôte : db
-- Généré le : jeu. 24 mai 2018 à 07:39
-- Version du serveur : 10.2.14-MariaDB-10.2.14+maria~jessie
-- Version de PHP : 7.2.4
SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
SET AUTOCOMMIT = 0;
START TRANSACTION;
SET time_zone = "+00:00";
CREATE DATABASE IF NOT EXISTS `hierarchy` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
USE `hierarchy`;
DROP TABLE IF EXISTS `position`;
CREATE TABLE `position` (
`id` int(11) NOT NULL,
`user_id` int(11) NOT NULL,
`parent_id` int(11) DEFAULT NULL,
`uuid` char(36) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '(DC2Type:guid)',
`type` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
INSERT INTO `position` (`id`, `user_id`, `parent_id`, `uuid`, `type`) VALUES
(2, 3, NULL, '7db54d6a-6a89-3fe2-87ba-c0dd96d4f664', 'TYPE_HR_PLUS'),
(3, 4, 3, 'adadab97-c0b8-3f89-a245-4edb077a4579', 'TYPE_HR_PLUS'),
(4, 5, 3, '4efec484-8a1f-3c27-a48f-a8c8412e18db', 'TYPE_HR_PLUS'),
(5, 6, 4, '8027b0cb-3e34-357a-8bff-80e4abbf60ef', 'TYPE_HR_PLUS'),
(6, 7, 4, 'e588ec20-9b0e-3ec6-8164-bdfafdf4b440', 'TYPE_HR'),
(7, 8, 5, '61e537d7-5ed6-36b3-8969-1913cdacb42b', 'TYPE_HR'),
(8, 9, 5, '6c241f8f-1a0a-34dc-8042-591352a764ea', 'TYPE_HR_PLUS'),
(9, 9, 3, 'e03998c4-d95a-3410-9727-099f0c83b3d5', 'TYPE_COLLABORATOR'),
(10, 10, 6, '67de2883-a7b0-3260-bb2a-67d3ffa3dc40', 'TYPE_HR'),
(11, 11, 7, '07d37612-01bf-3eec-b249-41c20d756144', 'TYPE_COLLABORATOR'),
(12, 11, 5, '09f7f6f1-59e2-37c0-a2e4-ae9b58ba6c93', 'TYPE_HR'),
(13, 12, 9, '724b8185-b6eb-3d35-b71f-1d076b3020ed', 'TYPE_HR'),
(14, 13, 9, '97d90e5c-7872-3e1e-be65-0f6b5329f54c', 'TYPE_HR_PLUS'),
(15, 14, 10, '3c357b9d-e162-316b-921c-25157d523e70', 'TYPE_COLLABORATOR'),
(16, 14, 3, '542235c6-462c-4922-a629-303430701000', 'TYPE_COLLABORATOR'),
(17, 15, 10, '2d208936-a7e9-32c1-963f-0df7f57ae463', 'TYPE_COLLABORATOR'),
(18, 16, 11, '00b678a2-54cd-3f37-9381-0cd92acea079', 'TYPE_COLLABORATOR'),
(19, 17, 8, 'ec4b8cad-fbce-3692-8d4c-f48f7ffa6452', 'TYPE_COLLABORATOR'),
(20, 18, 12, '48f0c85c-3801-3275-8978-5b2573fd7e0b', 'TYPE_COLLABORATOR'),
(21, 18, 10, 'd6129dec-8823-3304-8dfe-819118073d1f', 'TYPE_COLLABORATOR'),
(22, 19, 13, '1ec9c202-97d7-3311-9119-f6e9f55d058b', 'TYPE_COLLABORATOR'),
(23, 20, 9, '3ab32120-520b-3d41-80f0-56fd3876eecb', 'TYPE_COLLABORATOR');
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int(11) NOT NULL,
`uuid` char(36) COLLATE utf8mb4_unicode_ci NOT NULL COMMENT '(DC2Type:guid)',
`first_name` varchar(60) COLLATE utf8mb4_unicode_ci NOT NULL,
`last_name` varchar(60) COLLATE utf8mb4_unicode_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
INSERT INTO `user` (`id`, `uuid`, `first_name`, `last_name`) VALUES
(3, 'fb7304f6-5ade-4c06-83e5-36827a4d7904', 'Albus', 'Dumbledore'),
(4, '60af55ca-e9cd-3d8a-bc8a-c9f7ec99baa1', 'Minerva', 'McGonagall'),
(5, 'a422b364-b68f-324b-8836-d38ca62001f5', 'Severus', 'Rogue'),
(6, 'cbdf94a8-f4e3-360b-ba7f-10ea7e59b85d', 'Filius', 'Flitwick'),
(7, '9bce88c9-7b7d-3db3-8780-b6397bb1263d', 'Remus', 'Lupin'),
(8, 'b9d85cfa-3c46-33c1-8750-53be1c281111', 'Pomona', 'Chourave'),
(9, 'c07d10d7-333f-327a-ab32-201209127b7a', 'Rolanda', 'Bibine'),
(10, '8a7b76a1-5f0c-31ff-a93a-ca478598682b', 'Gilderoy', 'Lockhart'),
(11, '7302700a-0bc5-3ed0-84fc-857e975a5771', 'Alastor', 'Maugrey'),
(12, '7b8722f3-1570-3351-864a-ede9ee3a90e6', 'Sybille', 'Trelawney'),
(13, '12a7683a-00da-46a6-b7fd-a6eae5b10e3c', 'Dolores', 'Ombrage'),
(14, 'f054bdeb-a8b8-41e5-be78-b00d1b9377f3', 'Harry', 'Potter'),
(15, 'b1f696ad-cfa3-3830-8685-c45ff4a4ffda', 'Ronald', 'Weasley'),
(16, '8b2a64e9-ed28-363d-a731-3e15e255cd1d', 'Hermione', 'Granger'),
(17, 'f6aa74f9-2a4a-346d-bf75-3f8b02614c19', 'Neville', 'Londubat'),
(18, '8fbbc431-2555-3718-8055-ad8637260732', 'Drago', 'Malefoy'),
(19, '78a58546-8ae1-330d-9426-c23c74b71e78', 'Luna', 'Lovegood'),
(20, '4739a44b-d1b7-3390-9bbb-cbd2e39b4ec0', 'Ginny', 'Weasley');
ALTER TABLE `position`
ADD PRIMARY KEY (`id`),
ADD UNIQUE KEY `uuid_idx` (`uuid`),
ADD KEY `IDX_462CE4F5727ACA70` (`parent_id`),
ADD KEY `IDX_462CE4F5A76ED395` (`user_id`);
ALTER TABLE `user`
ADD PRIMARY KEY (`id`),
ADD UNIQUE KEY `uuid_idx` (`uuid`);
ALTER TABLE `position`
MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=1024;
ALTER TABLE `user`
MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=1027;
ALTER TABLE `position`
ADD CONSTRAINT `FK_462CE4F5727ACA70` FOREIGN KEY (`parent_id`) REFERENCES `user` (`id`),
ADD CONSTRAINT `FK_462CE4F5A76ED395` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`);
COMMIT;
One important thing to notice is the position table represents a relation between a user and its parent, and it also stores a string defining the relation type (actually it represents the user type of the child in this relation).
EDIT : one really important thing I didn't mention yet is there is no recursivity in this tree, there can be only a maximum number of 5 levels, as shown in the organization image: 1 HR_PLUS Head of Department, followed by maximum 3 levels of HR_PLUS or HR, followed by 1 level of COLLAB
What I'm trying to accomplish is the following:
For a given position uuid, i'd like to fetch every child user below this relation.
For example, the relation between Minerva McGonagall and Albus Dumbledore is the position #3 with uuid adadab97-c0b8-3f89-a245-4edb077a4579. Given this uuid, i'd like to fetch every user below Minerva McGonagall:
+---------------------------------------+
| id | first_name | last_name |
+---------------------------------------+
| 6 | Filius | Flitwick |
| 7 | Remus | Lupin |
| 10 | Gilderoy | Lockhart |
| 11 | Alastor | Maugrey |
| 14 | Harry | Potter |
| 15 | Ronald | Weasley |
| 16 | Hermione | Granger |
| 18 | Drago | Malefoy |
+---------------------------------------+
The query I wrote so far is the following:
SELECT u2.id, u2.first_name, u2.last_name
FROM `user` u1
JOIN position p1 ON p1.user_id = u1.id
JOIN position p2 ON p2.parent_id = p1.user_id
JOIN user u2 ON u2.id = p2.user_id
WHERE p1.uuid = 'adadab97-c0b8-3f89-a245-4edb077a4579'
AND p1.type IN ('TYPE_HR', 'TYPE_HR_PLUS')
I added a filter on type property because I don't want the query to return anything if type is not HR or HR_PLUS.
Right now, the query returns the users directly below Minerva McGonagall (Filius and Remus). And I can't figure how to return the rest of the users below them.
any help would be greatly appreciated.
I just succeed in fetch the expected data using a UNION, as this is not a recursive tree:
SELECT u2.id, u2.first_name, u2.last_name
FROM `user` u1
JOIN position p1 ON p1.user_id = u1.id
JOIN position p2 ON p2.parent_id = p1.user_id
JOIN user u2 ON u2.id = p2.user_id
WHERE p1.uuid = 'adadab97-c0b8-3f89-a245-4edb077a4579'
AND p1.type IN ('TYPE_HR', 'TYPE_HR_PLUS')
UNION
SELECT u2.id, u2.first_name, u2.last_name
FROM `user` u1
JOIN position p1 ON p1.user_id = u1.id
JOIN position p2 ON p2.parent_id = p1.user_id
JOIN position p3 ON p3.parent_id = p2.user_id
JOIN user u2 ON u2.id = p3.user_id
WHERE p1.uuid = 'adadab97-c0b8-3f89-a245-4edb077a4579'
AND p1.type IN ('TYPE_HR', 'TYPE_HR_PLUS')
UNION
SELECT u2.id, u2.first_name, u2.last_name
FROM `user` u1
JOIN position p1 ON p1.user_id = u1.id
JOIN position p2 ON p2.parent_id = p1.user_id
JOIN position p3 ON p3.parent_id = p2.user_id
JOIN position p4 ON p4.parent_id = p3.user_id
JOIN user u2 ON u2.id = p4.user_id
WHERE p1.uuid = 'adadab97-c0b8-3f89-a245-4edb077a4579'
AND p1.type IN ('TYPE_HR', 'TYPE_HR_PLUS')
but this looks very heavy , and i'm pretty sure there is a simpler way to do it.

Answer 1

Since you have already found the union solution, here's an alternative using a loop (And pseudocode):
Create a table to hold your results, lets call it r.
Insert into r the results of your first query, along with a field named level with a value of 1.
set i=2
while (at least a line of r exists where level=i-1) do the following:
insert into r (level=i)
a modification of your select based on selecting positions from r
where level=i-1

Answer 2

Is this what you're looking for? DB Fiddle
with recursive cte as (
select `user_id` as `ancestor_id`
/* , 0 as `degreesOfSeperation` */
, `user_id`
from `position`
union all
select c.`ancestor_id`
/* , c.`degreesOfSeperation` + 1 */
, p.`user_id`
from `cte` as c
inner join `position` as p
on p.`parent_id` = c.`user_id`
)
select u.id, u.first_name, u.last_name
from cte c
inner join `user` a on a.`id` = c.`ancestor_id`
inner join `position` p on p.`user_id` = a.`id`
inner join `user` u on u.`id` = c.`user_id`
/* WHERE c.`degreesOfSeperation` > 0 */
WHERE c.`user_id` != c.`ancestor_id`
AND p.`uuid` = 'adadab97-c0b8-3f89-a245-4edb077a4579'
AND p.`type` IN ('TYPE_HR', 'TYPE_HR_PLUS')
order by c.`degreesOfSeperation`
;
Output
id first_name last_name
Id | First_Name | Last_Name
---+------------+----------
6 | Filius | Flitwick
7 | Remus | Lupin
10 | Gilderoy | Lockhart
11 | Alastor | Maugrey
18 | Drago | Malefoy
14 | Harry | Potter
15 | Ronald | Weasley
16 | Hermione | Granger
Most of this is likely already already familiar to you.
The logic to deal with the hierarchical structure is the recursive cte.
This has 2 parts:
Part 1
select user_id as ancestor_id
, 0 as degreesOfSeperation
, user_id
from position
This gets all users from the position table, setting their record as the ancestor record; i.e. the root from which we'll grow our tree. We set degreesOfSeperation to 0 to state that this is the root record; i.e. the one where the user and the ancestor are one and the same.
Part 2
select c.`ancestor_id`
, c.`degreesOfSeperation` + 1
, p.`user_id`
from `cte` as c
inner join `position` as p
on p.`parent_id` = c.`user_id`
This is the recursive part; for each user added to the tree already (i.e. from the root statement; or from the last iteration of populating the cte table) we now fetch any other positions for which the position's parents match the previous iteration's user. We add one to the degreesOfSeparation so we can tell how far away from the root ancestor this record is.
DegressOfSeparation is not actually required (in fact, in the above statement I've commented this out); but I tend to include it since it's useful for debugging / seeing what's going on. Here's what the cte looks like without any filters, to help you understand what's going on:
With recursive cte as (
select `user_id` as `ancestor_id`
, 0 as `degreesOfSeperation`
, `user_id`
from `position`
union all
select c.`ancestor_id`
, c.`degreesOfSeperation` + 1
, p.`user_id`
from `cte` as c
inner join `position` as p
on p.`parent_id` = c.`user_id`
)
select *
from cte c
order by c.`ancestor_id`
, c.`degreesOfSeperation`
, c.`user_id`
;
Results here