Unnest-array durch eine Ebene

Möchte ich ein array von n Abmessungen und Rückgabe eingestellt mit den Zeilen des arrays von n-1 Dimensionen. Zum Beispiel, nehmen Sie die array ARRAY[[1,2,3], [4,5,6], [7,8,9]] und zurückgeben eines Satzes {1,2,3}, {4,5,6}, {7,8,9}. Mit unnest gibt den Satz 1,2,3,4,5,6,7,8,9.

Ich habe versucht, greifen die unnest-Funktion von PostgreSQL-8.4, die scheint, wie Sie tun würde, was ich Suche:

CREATE OR REPLACE FUNCTION tstng.unnest2(anyarray)
    RETURNS SETOF anyelement
    LANGUAGE plpgsql
    IMMUTABLE
    AS $$
    BEGIN
            RETURN QUERY SELECT $1[i]
                FROM generate_series(array_lower($1,1), array_upper($1,1)) i;
        END;
    $$;

Jedoch SELECT tstng.unnest2(ARRAY[[1,2,3], [4,5,6], [7,8,9]]); gibt den Satz , , (d.h.: 3 null Zeilen).

Habe ich auch herausgefunden, dass SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[0]; null zurück, und ich glaube, dass die Wurzel meines Problems.

InformationsquelleAutor Matt | 2011-11-15

14

Erklären
```
SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[0]
```
wieder die gleichen wie
```
SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[17]
```
NULL. Ich zitiere die docs über diese Angelegenheit:

Standardmäßig die untere Schranke index-Wert eines array-Dimensionen ist
auf eins gesetzt.

0 hat keine spezielle Bedeutung hier.
Auch mit einem zwei-dimensionale arrays, die Sie benötigen, zwei Indizes um ein Basis-element. Wie diese:
```
SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[1][2]
```
Ergebnis:
```
2
```
Den ersten Teil deiner Nachricht ist ein wenig unklar.
```
SELECT array_dims(ARRAY[[1,2,3], [4,5,6], [7,8,9]])
```
Ergebnis:
```
[1:3][1:3]
```
Dass zwei Dimensionen mit 3 Elementen (1 bis 3) jedes (9 Basis-Elemente).

Wenn Sie möchten n-1 Dimensionen, dann ist dies ein korrektes Ergebnis:
```
SELECT ARRAY (SELECT unnest('{{1,2,3}, {4,5,6}, {7,8,9}}'::int[]))
```
Ergebnis:
```
{1,2,3,4,5,6,7,8,9}
```
Dass eine dimension. unnest() erzeugt immer eine base element pro Zeile. Ich bin mir nicht sicher, was für ein Ergebnis Sie sich wünschen genau . Dein Beispiel ist nur ein weiteres 2-dimenstional array mit einem fehlenden Satz von geschweiften Klammern ... ?
```
{1,2,3}, {4,5,6}, {7,8,9}
```
Wenn Sie möchten, eine Scheibe array, versuchen Sie diese Schreibweise:
```
SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[1:2]
```
Ergebnis:
```
{{1,2,3},{4,5,6}}
```
Oder so:
```
SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[2:2][1:2]
```
Ergebnis:
```
{{4,5}}
```
Zu glätten das Ergebnis (Holen Sie sich ein 1D-array):
- So wählen Sie 1d-Arrays aus 2d-Arrays von postgresql
Lesen Sie mehr in der Anleitung hier.

Funktion

Späterer test ergab, dass diese plpgsql-Funktion ist viel schneller. Erfordert Postgres 9.1 oder höher:
```
CREATE OR REPLACE FUNCTION unnest_2d_1d(ANYARRAY, OUT a ANYARRAY)
  RETURNS SETOF ANYARRAY AS
$func$
BEGIN
   FOREACH a SLICE 1 IN ARRAY $1 LOOP
      RETURN NEXT;
   END LOOP;
END
$func$  LANGUAGE plpgsql IMMUTABLE;
```
Finden Sie unter:
- Wie unnest ein 2d-array in ein 1d-array schnell in PostgreSQL?
Dies ist eine verbesserte und vereinfachte version des die Funktion von Lukas geschrieben:
```
CREATE OR REPLACE FUNCTION unnest_2d_1d(anyarray)
  RETURNS SETOF anyarray AS
$func$
SELECT array_agg($1[d1][d2])
FROM   generate_subscripts($1,1) d1
    ,  generate_subscripts($1,2) d2
GROUP  BY d1
ORDER  BY d1
$func$  LANGUAGE sql IMMUTABLE;
```
Für Postgres-Versionen < 8.4, array_agg() ist nicht standardmäßig installiert. Erstellen Sie zuerst:
```
CREATE AGGREGATE array_agg(anyelement) (
 SFUNC=array_append,
 STYPE=anyarray,
 INITCOND='{}'
);
```
Auch, generate_subscripts() ist nicht geboren, noch nicht. Verwenden Sie stattdessen:
```
...
FROM   generate_series(array_lower($1,1), array_upper($1,1)) d1
    ,  generate_series(array_lower($1,2), array_upper($1,2)) d2
...
```
Nennen:
```
SELECT unnest_2d_1d(ARRAY[[1,2], [3,4], [5,6]]);
```
Ergebnis
```
{1,2}
{3,4}
{5,6}
```
SQL Fiddle.
- Ich war in der Lage, von 0-keine Besondere Bedeutung, ich danke Ihnen.
- Wenn ich SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[1][2] bekomme ich 2 nicht 1. Und 2 ist genau das, was ich erwartet hatte. Warum 1? Ist es ein Fehler? Oder bin ich etwas fehlt? Gleiche mit SELECT (ARRAY[[1,2,3], [4,5,6], [7,8,9]])[2:2][3]; nachgeben {{4,5,6}}, nicht {{4,5}} (Und durch die Weg, den docs empfehlen die Verwendung des full [2:2][1:3] notation, um Sie ausdrücklich zu, und ich Stimme zu!)
- Danke, du hast Recht in allen Punkten. Behoben die Fehler und aktualisiert die Funktion, da dies einfacher, seit 2011.
- Hi, in nowdays, mit pg10, keine news? Es gibt keine build-in oder effiziente Abhilfe zu tun unnest_2d_1d()?
- Ich wünschte, es gäbe eine Funktion in Postgres erlaubt unnesting beliebiges n-dimensionales array für 1 level. Es ist so ärgerlich, dass es keine einfache Möglichkeit, dies zu tun.
InformationsquelleAutor Erwin Brandstetter

Scheiben von einer multi-dimensionalen zurückgegeben werden, als multi-dimensionale arrays. Dies ist eine modifizierte version von unnest, der eine 2-dimensionale array und zurückgeben eines Satzes von 1-dimensionalen arrays.

update: modifiziert zur Nutzung der built-in array_agg Aggregatfunktion, wurde standardmäßig als 8.4. (http://www.postgresql.org/docs/9.2/static/functions-aggregate.html)

Vorsichtsmaßnahmen:

Es funktioniert nur für 2-dimensionale arrays (sollte ich wohl umbenennen, die Funktion zu reflektieren, - Einschränkung).
Wenn Sie auf 8.3 (und nicht aktualisieren), müssen Sie die array_accum Aggregat definiert und ändern Sie alle Referenzen in den Funktionen, die unten aus array_agg zu array_accum. http://www.postgresql.org/docs/8.3/static/xaggr.html

code:

CREATE OR REPLACE FUNCTION unnest_multidim(anyarray)
RETURNS SETOF anyarray AS
$BODY$
  SELECT array_agg($1[series2.i][series2.x]) FROM
    (SELECT generate_series(array_lower($1,2),array_upper($1,2)) as x, series1.i
     FROM 
     (SELECT generate_series(array_lower($1,1),array_upper($1,1)) as i) series1 
    ) series2
GROUP BY series2.i
$BODY$
LANGUAGE sql IMMUTABLE;

Ergebnis:

select unnest_multidim(array[[1,2,3],[4,5,6],[7,8,9]]);
unnest_multidim
----------------------
{1,2,3}
{4,5,6}
{7,8,9}
(3 rows)

Nun, sagen wir mal aus irgendeinem Grund Sie wollen einen einfachen Zugang zu nur einem dieser arrays zurückgegeben wird. Die folgende Funktion fügt eine optionale index-parameter auf, wird wieder das verschachtelte array der index, den Sie bieten, oder, wenn Sie null ist, wird die Ausgabe der vollständigen Reihe von "unnested" arrays.

CREATE OR REPLACE FUNCTION unnest_multidim(anyarray, integer)
  RETURNS SETOF anyarray AS
$BODY$
SELECT array_agg($1[series2.i][series2.x]) FROM
  (SELECT generate_series(array_lower($1,2),array_upper($1,2)) as x, series1.i
  FROM 
    (SELECT CASE WHEN $2  IS NULL THEN
      generate_series(array_lower($1,1),array_upper($1,1)) 
      ELSE $2
      END as i) series1
  ) series2
GROUP BY series2.i
$BODY$
LANGUAGE sql IMMUTABLE;

Ergebnisse:

db=> select unnest_multidim(array[[1,2,3],[4,5,6],[7,8,9]],2);
 unnest_multidim 
-----------------
 {4,5,6}
(1 row)

db=> select unnest_multidim(array[[1,2,3],[4,5,6],[7,8,9]],NULL);
 unnest_multidim 
-----------------
 {1,2,3}
 {4,5,6}
 {7,8,9}
(3 rows)

PotsgreSQL 8.4 eingeführt array_agg() Funktion das ist der standard-name für array_accum.

InformationsquelleAutor Lukas Eklund

0

Ein Wort der Vorsicht: bei der Verwendung von array_agg auf postgres <9 Reihenfolge ändern kann
PostgreSQL array_agg bestellen
Wenn Sie planen, verwenden Sie die unnested-array sagen für die Suche nach argmax, dadurch werden Ihre Daten beschädigt.

InformationsquelleAutor AlonG

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Erklären

Funktion