mysql rekursive selbst verbinden sich schneidende Spalten

Question

sagen, dass ich einen Start Tabelle haben (abgeleitet), die wie das ist ...

------------------------------------------------------- 
| UsergroupID | ParentID | PermissionIDs    | 
------------------------------------------------------- 
| 1   | 0  | 1       | 
| 1   | 0  | 2       | 
| 1   | 0  | 3       | 
| 1   | 0  | 4       | 
| 1   | 0  | 5       | 
| 1   | 0  | 6       | 
| 2   | 1  | 1       | 
| 2   | 1  | 8       | 
| 2   | 1  | 9       | 
| 3   | 1  | 3       | 
| 3   | 1  | 8       | 
| 3   | 1  | 2       | 
------------------------------------------------------- 

und ich suche eine End-Ergebnismenge zu erhalten, die

wie folgt aussieht

------------------------------------------------------- 
| UsergroupID | ParentID | PermissionID    | 
------------------------------------------------------- 
| 1   | 0  | 1       | 
| 1   | 0  | 2       | 
| 1   | 0  | 3       | 
| 1   | 0  | 4       | 
| 1   | 0  | 5       | 
| 1   | 0  | 6       | 
| 2   | 1  | 1       | 
| 3   | 1  | 3       | 
| 3   | 1  | 2       | 
------------------------------------------------------- 

, die im Grunde eine rekursive Suche auf der übergeordneten ID und dann schneiden (innere Verbindung) die Werte in der PermissionID Spalte. Ein Kind kann also nie mehr Berechtigungen als ein Elternteil haben.

Ich habe Sachen auf benutzerdefinierten Funktionen nachgeschlagen (ich denke, ich könnte ein PDF um eine Spalte wickeln und es rekursiv schneiden basierend auf einer Eltern-ID), aber das brachte mich nicht sehr weit. Das einzige, woran ich wirklich denken kann, ist, es nicht db-Seite zu tun, sondern mit serverseitigem Code.

Solarflare - Hier ist, was ich gerade mit Ihrem Skript versucht habe ... das hat funktioniert!

delimiter $$ 
CREATE PROCEDURE prcPermCleanup5() 
BEGIN 
DROP TABLE IF EXISTS table1; 
CREATE TABLE table1 (usergroupID INT, parentID INT, StoreID INT) ENGINE=MEMORY; 
INSERT INTO table1 VALUES 
(1,0,1), 
(1,0,2), 
(1,0,3), 
(1,0,4), 
(2,1,1), 
(2,1,2), 
(2,0,5), 
(3,2,2), 
(3,2,7), 
(4,1,1), 
(4,1,2), 
(5,4,1), 
(5,4,8), 
(6,2,1), 
(6,2,6); 
    REPEAT 
    DELETE entry.* 
    FROM table1 entry 
    LEFT JOIN table1 parent 
    ON entry.parentID = parent.usergroupID 
    AND entry.`StoreID` = parent.StoreID 
    WHERE parent.usergroupID IS NULL 
    AND NOT entry.parentID = 0; 
    UNTIL row_count() = 0 END REPEAT; 
    SELECT * FROM table1; 
END $$ 
delimiter ; 

Answer 1

Es ist nicht möglich, dass in einer einzigen Abfrage zu tun (es sei denn, vielleicht unter bestimmten besonderen Bedingungen), aber man kann nur eine Bereinigungs Abfrage wiederholt eine Rekursion, so zu tun.

Wenn Ihre Bereinigung ist eine einmalige Sache, kann man einfach nicht mehr die folgende Abfrage mehrmals, bis sich nichts ändert laufen (man braucht höchstens depth of tree - 1 Läufe):

delete entry.* 
from table1 entry 
left join table1 parent 
on entry.parentID = parent.usergroupID 
and entry.permissionIDs = parent.permissionIDs 
where parent.usergroupID is null 
and not entry.parentID = 0; 

Sie, dass die Wiederholung in eine automatisieren Verfahren, z

delimiter $$ 
create procedure prcPermCleanup() 
begin 
    repeat 
    delete entry.* 
    from table1 entry 
    left join table1 parent 
    on entry.parentID = parent.usergroupID 
    and entry.permissionIDs = parent.permissionIDs 
    where parent.usergroupID is null 
    and not entry.parentID = 0; 
    until row_count() = 0 end repeat; 
end $$ 
delimiter ; 

call prcPermCleanup; 

Als Randbemerkung:

Sie möchten Ihre Daten normalisieren, z.B. eine separate Tabelle für Ihre Berechtigungen verfügen:

table permissions: usergroupID | permissionID 

table tree: usergroupID | parentID 

In Ihrer aktuellen Tabelle, haben Sie die gleichen Informationen (die Informationen, die parentID die Eltern ein usergroupID sind) mehrmals in der Tabelle, auch bekannt als denormalized. Eine praktische Konsequenz davon wäre, dass Sie zwei verschiedene parentID für denselben usergroupID haben könnten, die normalerweise in einem Baum undefiniert wären.

Answer 2

Ok, also ist das nicht unbedingt die Antwort ... aber im folgenden Setup finde ich, dass ich die richtigen Tabelleninformationen zurückbekomme. Dieses Beispiel funktioniert unter der Annahme, dass ich weiß (und kann eine maximale Tiefe und Gruppierung Beziehungen (die ich glaube, ich kann, obwohl die Gruppierung Beziehungen ein Problem sein kann, wenn ich dies tatsächlich mit "echten" Daten). das ist, was ich

DROP TABLE IF EXISTS joshTestTable; 
CREATE TABLE joshTestTable (id INT, parent INT, store INT) ENGINE=MEMORY; 
INSERT INTO joshTestTable VALUES 
(1,0,1), 
(1,0,2), 
(1,0,3), 
(1,0,4), 
(2,1,1), 
(2,1,2), 
(2,0,5), 
(3,2,2), 
(3,2,7), 
(4,1,1), 
(4,1,2), 
(5,4,1), 
(5,4,8), 
(6,2,1), 
(6,2,6); 


SELECT * FROM (
    SELECT * FROM joshTestTable p 
    WHERE p.parent = 0 
    UNION ALL 
    SELECT c.* FROM joshTestTable p 
    LEFT JOIN joshTestTable c 
    ON p.id = c.parent 
    AND p.store = c.store 
    AND c.parent=1 
    UNION ALL 
    SELECT c.* FROM joshTestTable p 
    LEFT JOIN joshTestTable c 
    ON p.id = c.parent 
    AND p.store = c.store 
    AND c.parent IN (2,4)) outter WHERE id IS NOT NULL; 

ich bin immer noch nicht super heiß auf diesem als Lösung wegen all der bekannten Sachen habe ich auf eine gespeicherte Prozedur in übergeben müssen würde, dies zu automatisieren. ich wirklich in der Nähe von wenn ich nur links mache, komme ich in die Baumtiefe, aber in diesem Fall bekomme ich eine Tabelle mit einer Reihe von Spaltensätzen, die ich irgendwie pivotieren muss, zB

SELECT * FROM joshTestTable p 
LEFT JOIN joshTestTable c 
ON p.id = c.parent 
AND p.store = c.store 
LEFT JOIN joshTestTable gc 
ON c.id = gc.parent 
AND c.store = gc.store 
WHERE p.parent = 0; 

Dieses Ende gibt mir alle Informationen, aber es ist nur in einem Format, das ich nicht verwenden kann. Es gibt mir einen Tisch wie diesen ...

id parent store id parent store id parent store 
1  0 1  2  1  1  6  2 1 
1  0 1  4  1  1  5  4 1 
1  0 2  2  1  2  3  2 2 
1  0 2  4  1  2  NULL NULL NULL 
1  0 3  NULL NULL NULL NULL NULL NULL 
1  0 4  NULL NULL NULL NULL NULL NULL 
2  0 5  NULL NULL NULL NULL NULL NULL 

und am Ende dafür suche ich (das ist, was meine erste Abfrage mir nicht geben) ...

id parent store 
1 0  1 
1 0  2 
1 0  3 
1 0  4 
2 0  5 
2 1  1 
2 1  2 
3 2  2 
4 1  1 
4 1  2 
5 4  1 
6 2  1