Aufheben der Verschachtelung in PostgreSQL

1. PostgreSQL unnest () Funktionalität
2. Verwendung von PostgreSQL unnest()

In diesem Artikel beschreiben wir das Schlüsselwort unnest() und seine Verwendung in PostgreSQL anhand mehrerer Beispiele.

PostgreSQL unnest () Funktionalität

In PostgreSQL können Sie ein Array als Datentyp verwenden. Es gibt auch mehrere Funktionen, die sich auf die Verbesserung der Benutzerfreundlichkeit von Arrays in der Sprache beziehen.

Die Funktion unnest() ist eine der vielen Array-Funktionalitäten, die wir heute erklären werden. Die grundlegende Funktionalität ist jedoch aus dem Wort unnest() selbst klar ersichtlich: Es erweitert Arrays in Zeilen.

Es ist wichtig, wenn Sie versuchen, die Arrays in tabellarischer Form anzuzeigen. PostgreSQL ermöglicht es dieser Funktionalität, Arrays in eine Reihe von einzelnen Werten zu erweitern, die wir in tabellarischer Form als Zeilen darstellen können.

In älteren Versionen von PostgreSQL gab es langsamere und kompliziertere Methoden, um eine Erweiterung von Arrays zu erreichen, die durch diese unnest()-Funktionalität ersetzt wurden, die wir auch mit anderen PostgreSQL-Funktionalitäten verwenden können.

Die Verwendung mit anderen PostgreSQL-Funktionalitäten eröffnet umfangreiche Möglichkeiten für einfachere und schnellere Operationen.

Verwendung von PostgreSQL unnest()

Wir beginnen mit der Grundfunktionalität und bewegen uns dann langsam zu komplizierteren Anwendungsfällen. Die Syntax ist unnest(array).

Es nimmt einfach alle einzelnen Werte des Arrays und fügt sie in einen Satz ein, der in Form von Zeilen in der Tabelle angezeigt wird.

Hinweis: Muss das Schlüsselwort unnest() mit einem Array versehen. Zum Beispiel: unnest (array_to_expand).

Kommen wir nun zu den Beispielen für jede wesentliche Funktion.

Verwenden der PostgreSQL-Funktion unnest () für ein einfaches eindimensionales Array

Es sei eine Reihe natürlicher Zahlen bis 5. Der einfache Weg, sie zu erweitern und als Zeilen in einer Tabelle anzuzeigen, besteht darin, sie zu entschachteln.

SELECT unnest (ARRAY[1,2,3,4,5]);

Es liefert eine Ausgabe mit allen 5 Ziffern in tabellarischer Form (5 Zeilen):

Versuchen wir es jetzt genau mit Wörtern anstelle von Zahlen, um zu sehen, ob sich etwas geändert hat.

SELECT unnest (ARRAY['apple', 'oranges', 'mango']);

Es liefert eine Ausgabe mit allen 3 Wörtern in tabellarischer Form (3 Zeilen):

Wie wir sehen können, funktioniert es sowohl für Ganzzahlen als auch für Text perfekt.

Verwenden Sie die PostgreSQL-Funktion unnest () für ein einfaches mehrdimensionales Array

Wir haben oben erklärt, wie man die Funktion unnest () auf ein 1D-Array anwendet. Das folgende Beispiel zeigt, wie es auf 2D-Arrays verwendet wird.

SELECT unnest (array[array[1, 2], array[2, 3], array[4,5]]);

Es werden insgesamt 6 Zeilen mit allen 6 Ziffern in tabellarischer Form angezeigt.

Verwenden Sie die PostgreSQL-Funktion unnest () für mehrere Arrays gleichzeitig

In diesem Abschnitt wird die Verwendung der Funktion unnest () für mehrere Arrays gleichzeitig demonstriert. Die Arrays können auch von unterschiedlichen Datentypen sein.

Nach der Verwendung der Funktion unnest () erscheint jedes Array als Spalte in der Tabelle mit den Werten der Arrays als Zeilen.

Wir können es als unnest (array1, array2, array3…) schreiben. Das folgende Beispiel soll helfen, das Konzept zu verdeutlichen.

SELECT * FROM
unnest
(
    array [1, 2, 3],
    array ['HP', 'AMD', 'APPLE']
)
AS data(ID, Company);

Es wird eine Tabelle mit jedem Array als Spalte und den darin enthaltenen Werten als Zeilen dieser Spalten angezeigt.

Nehmen wir ein weiteres Beispiel, bei dem die beiden Arrays eine ungleiche Anzahl von Elementen haben.

SELECT * FROM
unnest
(
    array [1, 2, 3],
    array ['HP', 'AMD', 'APPLE', 'DELL']
)
AS data(ID, Company);

In diesem Beispiel gibt es eine Firma mehr als die IDs. In diesem Fall wird die kürzere zum Ausgleich mit NULLS aufgefüllt und eine fehlerfreie Tabelle angezeigt.

Verwenden Sie die PostgreSQL-Funktion unnest () mit der ORDER BY-Klausel

Neben der Klausel ORDER BY kann auch die PostgreSQL-Funktion unnest () verwendet werden. Wir werden es anhand von Beispielen veranschaulichen.

Eine der Möglichkeiten, die ORDER BY-Klausel zu verwenden, besteht darin, die Reihenfolge von Arrays zu verwenden. Das Ergebnis wird in diesem Fall nach der zweiten Spalte (Firma) sortiert.

SELECT * FROM
unnest
(
    array [1, 2, 3],
    array ['HP', 'AMD', 'APPLE']
)
AS data(ID, Company) ORDER BY 2;

Eine andere Möglichkeit, die ORDER BY-Klausel zu verwenden, besteht darin, dem Array mit AS einen Namen zuzuweisen. Das Ergebnis wird in diesem Fall nach der zweiten Spalte (Ranking) sortiert.

SELECT * FROM
unnest
(
    array['HP', 'AMD', 'APPLE'],
    array[23,14,1]
)
AS data(Company, Ranking) ORDER BY Ranking;

Verwenden Sie die PostgreSQL-Funktion unnest () mit der LIMIT-Klausel

PostgreSQL ermöglicht Ihnen die Verwendung der Funktion unnest () mit der Klausel LIMIT.

In diesem Fall wird die resultierende Tabelle (nach Erweiterung von Arrays) auf die in der Klausel LIMIT beschriebene Bedingung beschränkt. Die folgenden Beispiele sollen die Idee verdeutlichen.

SELECT unnest (array[1,2,3,4,5,6])
LIMIT 3;

Es werden nur die ersten 3 Werte des Arrays als Zeilen angezeigt.

Sie können den Befehl OFFSET auch mit LIMIT verwenden.

SELECT unnest (array[1,2,3,4,5,6])
LIMIT 3 OFFSET 3;

Es überspringt die ersten 3 Werte und zeigt nur die letzten 3 Werte (4,5,6) als Zeilen in der resultierenden Tabelle an.

Verwenden Sie die PostgreSQL-Funktion unnest () mit der DISTINCT -Klausel

Die Klausel DISTINCT wird in mehreren Datenbanksprachen verwendet, um Duplikate zu entfernen.

In PostgreSQL kann es alle Duplikate jeder Art von Daten entfernen, ob Integer, String usw., aber es hat eine Einschränkung, dass es nur Duplikate in den Daten in tabellarischer Form entfernen kann.

Diese Einschränkung erschwert das Entfernen von Duplikaten aus Arrays. Die unnest ()-Funktionalität löst dieses Problem jedoch schnell.

Mit dem Befehl unnest () können wir die Werte eines Arrays zunächst in Tabellenform umwandeln. Dann kann die DISTINCT-Klausel einfach angewendet werden, um Duplikate zu entfernen.

Diese Idee wird im folgenden Beispiel zu Ihrem Verständnis veranschaulicht.

SELECT DISTINCT unnest (array['HP', 'DELL', 'APPLE','AMD', 'HP']);

In diesem Beispiel wird das Array zunächst mit unnest () in Tabellenform umgewandelt. Dann wird die DISTINCT-Klausel angewendet, um Duplikate zu entfernen. Infolgedessen enthält die resultierende Tabelle nur einmal HP.