Bringen Sie Ihnen bei, wie Sie die rekursive Methode von MySQL8 verwenden

Ich habe zuvor einen Artikel über rekursive Abfragen von Baumstrukturen in MySQL mithilfe benutzerdefinierter Funktionen geschrieben. Seit MySQL 8.0 wird die rekursive Abfragesyntax endlich unterstützt.

WAK

Lassen Sie uns zunächst verstehen, was CTE ist. Der vollständige Name lautet Common Table Expressions

MIT
 cte1 AS (SELECT a, b FROM table1),
 cte2 AS (AUSWÄHLEN c, d AUS Tabelle2)
WÄHLEN Sie b, d VON cte1 JOIN cte2
WO cte1.a = cte2.c;

cte1, cte2 sind die von uns definierten CTEs, auf die in der aktuellen Abfrage verwiesen werden kann

Es ist ersichtlich, dass CTE ein temporärer Ergebnissatz ist, ähnlich einer abgeleiteten Tabelle. Der Unterschied zwischen den beiden wird hier nicht im Detail erklärt. Sie können auf die MySQL-Entwicklungsdokumentation verweisen: https://dev.mysql.com/doc/refman/8.0/en/with.html#common-table-expressions-recursive-examples

Rekursive Abfrage

Sehen wir uns zunächst die Syntax rekursiver Abfragen an.

MIT RECURSIVEM cte_name AS
(
  SELECT ... – gibt den anfänglichen Zeilensatz zurück
  UNION ALL / UNION DISTINCT
  SELECT ... – gibt zusätzliche Zeilensätze zurück
)
WÄHLEN SIE * VON cte;

• Definieren Sie einen CTE, dessen endgültiger Ergebnissatz die gewünschte „rekursive Baumstruktur“ ist. RECURSIVE bedeutet, dass der aktuelle CTE rekursiv ist.
• Das erste SELECT ist der „anfängliche Ergebnissatz“
• Der zweite SELECT-Teil ist der rekursive Teil, der den „anfänglichen Ergebnissatz/von der letzten Rekursion zurückgegebenen Ergebnissatz“ verwendet, um den „neuen Ergebnissatz“ abzufragen und abzurufen.
• Die Abfrage endet, wenn der rekursive Ergebnissatz null zurückgibt.
• Schließlich kombiniert UNION ALL alle Ergebnismengen der obigen Schritte (UNION DISTINCT entfernt Duplikate) und ruft dann alle Ergebnismengen über SELECT * FROM cte ab.

Der rekursive Teil darf nicht enthalten:

• Aggregatfunktionen wie SUM()
• GRUPPELN NACH
• BESTELLEN BIS
• LIMIT
• UNTERSCHEIDBAR

Die obige Erklärung ist möglicherweise etwas abstrakt, also wollen wir sie langsam anhand von Beispielen verstehen.

WITH RECURSIVE cte (n) AS -- Das hier definierte n entspricht dem Spaltennamen des Ergebnissatzes, der auch in der folgenden Abfrage definiert werden kann (
 WÄHLEN SIE 1
 UNION ALLE
 Wählen Sie n + 1 aus Tabelle, wobei n < 5 ist.
)
WÄHLEN SIE * VON cte;


--Ergebnis
+------+
| n |
+------+
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
+------+

• Der anfängliche Ergebnissatz ist n = 1
• Schauen wir uns nun den rekursiven Teil an. Beim ersten Ausführen des CTE ist das Ergebnis n = 1. Da die Bedingung n < 5 nicht erfüllt ist, wird n + 1 zurückgegeben.
• Der rekursive Teil wird zum zweiten Mal ausgeführt und der CTE-Ergebnissatz ist n = 2. Rekursion ... bis die Bedingung nicht mehr erfüllt ist
• Abschließend führen Sie den Ergebnissatz zusammen

BEISPIEL

Schauen wir uns abschließend ein Beispiel für eine Baumstruktur an.

Tabelle „c_tree“ erstellen (
 `id` int(11) NICHT NULL AUTO_INCREMENT,
 `cname` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,
 `parent_id` int(11) DEFAULT NULL,
 PRIMÄRSCHLÜSSEL (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

mysql> wähle * aus c_tree;
+----+---------+-----------+
| ID | CName | übergeordnete_ID |
+----+---------+-----------+
| 1 | 1 | 0 |
| 2 | 2 | 0 |
| 3 | 3 | 0 |
| 4 | 1-1 | 1 |
| 5 | 1-2 | 1 |
| 6 | 2-1 | 2 |
| 7 | 2-2 | 2 |
| 8 | 3-1 | 3 |
| 9 | 3-1-1 | 8 |
| 10 | 3-1-2 | 8 |
| 11 | 3-1-1-1 | 9 |
| 12 | 3-2 | 3 |
+----+---------+-----------+

MySQL> 
MIT REKURSIVEM tree_cte als
(
  Wählen Sie * aus c_tree, wobei parent_id = 3 ist.
  UNION ALLE
  wähle t.* aus c_tree t inner join tree_cte tcte auf t.parent_id = tcte.id
)
WÄHLEN SIE * AUS tree_cte;
+----+---------+-----------+
| ID | CName | übergeordnete_ID |
+----+---------+-----------+
| 8 | 3-1 | 3 |
| 12 | 3-2 | 3 |
| 9 | 3-1-1 | 8 |
| 10 | 3-1-2 | 8 |
| 11 | 3-1-1-1 | 9 |
+----+---------+-----------+

• Anfänglicher Ergebnissatz R0 = select * from c_tree where parent_id = 3
• Im rekursiven Teil wird der erste innere Join von R0 und c_tree verwendet, um R1 zu erhalten
• R1 wird dann mit c_tree innerlich verbunden, um R2 zu erhalten.
• ...
• Alle Ergebnismengen R0 + ... + Ri zusammenführen

Weitere Informationen

https://dev.mysql.com/doc/refman/8.0/en/with.html

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.