Wie verwandle ich ein json Array in ein postgres Array?

Ich habe eine Spalte data, die ein jsonDokument ungefähr so ​​enthält:

{
    "name": "foo",
    "tags": ["foo", "bar"]
}

Ich möchte das verschachtelte tagsArray in eine verkettete Zeichenfolge ( foo, bar) verwandeln . Das wäre mit der array_to_string()Funktion in der Theorie leicht möglich . Diese Funktion wirkt sich jedoch nicht auf jsonArrays aus. Also frage ich mich, wie ich dieses jsonArray in ein Postgres verwandeln kann array?

Postgres 9.4 oder neuer

Postgres 9.4 wurde offensichtlich von diesem Beitrag inspiriert und fügte die fehlenden Funktionen hinzu:
_{Danke an Laurence Rowe für den Patch und Andrew Dunstan für das Commit!}

• json_array_elements_text(json)
• jsonb_array_elements_text(jsonb)

So entfernen Sie das JSON-Array. Verwenden Sie dann array_agg()oder einen ARRAY-Konstruktor , um ein Postgres- Array daraus zu erstellen . Oder string_agg()um einen text String zu bauen .

Aggregieren Sie nicht verschachtelte Elemente pro Zeile in einer LATERALoder einer korrelierten Unterabfrage. Dann wird ursprünglicher Auftrag erhalten und wir nicht brauchen ORDER BY, GROUP BYoder sogar ein eindeutiger Schlüssel in der äußeren Abfrage. Sehen:

• Wie werden ORDER BY und LIMIT in Kombination mit einer Aggregatfunktion angewendet?

Ersetzen Sie 'json' jsonbin allen folgenden SQL-Codes durch 'jsonb' .

SELECT t.tbl_id, d.list
FROM   tbl t
CROSS  JOIN LATERAL (
   SELECT string_agg(d.elem::text, ', ') AS list
   FROM   json_array_elements_text(t.data->'tags') AS d(elem)
   ) d;

Kurze Syntax:

SELECT t.tbl_id, d.list
FROM   tbl t, LATERAL (
   SELECT string_agg(value::text, ', ') AS list
   FROM   json_array_elements_text(t.data->'tags')  -- col name default: "value"
   ) d;

Verbunden:

• Was ist der Unterschied zwischen LATERAL und einer Unterabfrage in PostgreSQL?

ARRAY-Konstruktor in korrelierter Unterabfrage:

SELECT tbl_id, ARRAY(SELECT json_array_elements_text(t.data->'tags')) AS txt_arr
FROM   tbl t;

Verbunden:

• Wie werden ORDER BY und LIMIT in Kombination mit einer Aggregatfunktion angewendet?

Subtiler Unterschied : nullElemente bleiben in tatsächlichen Arrays erhalten . Dies ist in den obigen Abfragen, die eine textZeichenfolge erzeugen , die keine nullWerte enthalten kann, nicht möglich . Die wahre Darstellung ist ein Array.

Funktions-Wrapper

Um dies noch einfacher zu machen, kapseln Sie bei wiederholter Verwendung die Logik in eine Funktion:

CREATE OR REPLACE FUNCTION json_arr2text_arr(_js json)
  RETURNS text[] LANGUAGE sql IMMUTABLE AS
'SELECT ARRAY(SELECT json_array_elements_text(_js))';

Machen Sie es zu einer SQL-Funktion , damit es in größeren Abfragen eingebunden werden kann.
Machen Sie es IMMUTABLE(weil es ist), um wiederholte Auswertung in größeren Abfragen zu vermeiden und es in Indexausdrücken zuzulassen.

Anruf:

SELECT tbl_id, json_arr2text_arr(data->'tags')
FROM   tbl;

db <> hier fummeln

Postgres 9.3 oder älter

Nutzen Sie die Funktion json_array_elements(). Aber wir bekommen doppelte Anführungszeichen .

Alternative Abfrage mit Aggregation in der äußeren Abfrage. CROSS JOINEntfernt Zeilen mit fehlenden oder leeren Arrays. Kann auch zur Verarbeitung von Elementen nützlich sein. Wir benötigen einen eindeutigen Schlüssel für die Aggregation:

SELECT t.tbl_id, string_agg(d.elem::text, ', ') AS list
FROM   tbl t
CROSS  JOIN LATERAL json_array_elements(t.data->'tags') AS d(elem)
GROUP  BY t.tbl_id;

ARRAY-Konstruktor, immer noch mit zitierten Zeichenfolgen:

SELECT tbl_id, ARRAY(SELECT json_array_elements(t.data->'tags')) AS quoted_txt_arr
FROM   tbl t;

Beachten Sie, dass nullim Gegensatz zu oben in den Textwert "null" konvertiert wird. Falsch, genau genommen und möglicherweise mehrdeutig.

Der arme Mann spricht nicht mit trim():

SELECT t.tbl_id, string_agg(trim(d.elem::text, '"'), ', ') AS list
FROM   tbl t, json_array_elements(t.data->'tags') d(elem)
GROUP  BY 1;

Rufen Sie eine einzelne Zeile von tbl ab:

SELECT string_agg(trim(d.elem::text, '"'), ', ') AS list
FROM   tbl t, json_array_elements(t.data->'tags') d(elem)
WHERE  t.tbl_id = 1;

Zeichenfolgen bilden eine korrelierte Unterabfrage:

SELECT tbl_id, (SELECT string_agg(trim(value::text, '"'), ', ')
                FROM   json_array_elements(t.data->'tags')) AS list
FROM   tbl t;

ARRAY-Konstruktor:

SELECT tbl_id, ARRAY(SELECT trim(value::text, '"')
                     FROM   json_array_elements(t.data->'tags')) AS txt_arr
FROM   tbl t;

Ursprüngliche (veraltete) SQL-Geige .
db <> hier fummeln .

Verbunden:

• Es muss ein JSON-Array-Element dynamisch aus einer postgresql-Tabelle ausgewählt werden

Anmerkungen (veraltet seit Seite 9.4)

Wir benötigen a json_array_elements_text(json), den Zwilling von json_array_elements(json), um korrekte textWerte aus einem JSON-Array zurückzugeben. Dies scheint jedoch im bereitgestellten Arsenal von JSON-Funktionen zu fehlen . Oder eine andere Funktion, um einen textWert aus einem Skalarwert zu extrahieren JSON. Das scheint mir auch zu fehlen.
Also habe ich mit improvisiert trim(), aber das wird für nicht-triviale Fälle scheitern ...

PG 9.4+

Die akzeptierte Antwort ist definitiv das, was Sie brauchen, aber der Einfachheit halber hier ist ein Helfer, den ich dafür benutze:

CREATE OR REPLACE FUNCTION jsonb_array_to_text_array(
  p_input jsonb
) RETURNS TEXT[] AS $BODY$

DECLARE v_output text[];

BEGIN

  SELECT array_agg(ary)::text[]
  INTO v_output
  FROM jsonb_array_elements_text(p_input) AS ary;

  RETURN v_output;

END;

$BODY$
LANGUAGE plpgsql VOLATILE;

Dann machen Sie einfach:

SELECT jsonb_array_to_text_array('["a", "b", "c"]'::jsonb);

Diese Frage wurde in den PostgreSQL-Mailinglisten gestellt und ich fand diese hackige Methode zum Konvertieren von JSON-Text in PostgreSQL-Text über den JSON-Feldextraktionsoperator:

CREATE FUNCTION json_text(json) RETURNS text IMMUTABLE LANGUAGE sql
AS $$ SELECT ('['||$1||']')::json->>0 $$;

db=# select json_text(json_array_elements('["hello",1.3,"\u2603"]'));
 json_text 
-----------
 hello
 1.3
 ☃

Grundsätzlich konvertiert es den Wert in ein Einzelelement-Array und fragt dann nach dem ersten Element.

Ein anderer Ansatz wäre, diesen Operator zu verwenden, um alle Felder einzeln zu extrahieren. Bei großen Arrays ist dies wahrscheinlich langsamer, da der gesamte JSON-String für jedes Array-Element analysiert werden muss, was zu einer Komplexität von O (n ^ 2) führt.

CREATE FUNCTION json_array_elements_text(json) RETURNS SETOF text IMMUTABLE LANGUAGE sql
AS $$ SELECT $1->>i FROM generate_series(0, json_array_length($1)-1) AS i $$;

db=# select json_array_elements_text('["hello",1.3,"\u2603"]');
 json_array_elements_text 
--------------------------
 hello
 1.3
 ☃

Ich habe ein paar Optionen getestet. Hier ist meine Lieblingsfrage. Angenommen, wir haben eine Tabelle mit ID und JSON-Feld. Das json-Feld enthält array, das wir in pg array umwandeln wollen.

SELECT * 
FROM   test 
WHERE  TRANSLATE(jsonb::jsonb::text, '[]','{}')::INT[] 
       && ARRAY[1,2,3];

Es funktioniert überall und ist schneller als andere, sieht aber mürrisch aus.)

Zuerst wird das JSON-Array als Text umgewandelt, und dann ändern wir die eckigen Klammern in Klammern. Schließlich wird der Text als Array des erforderlichen Typs umgewandelt.

SELECT TRANSLATE('[1]'::jsonb::text, '[]','{}')::INT[];

und wenn Sie Text [] Arrays bevorzugen

SELECT TRANSLATE('[1]'::jsonb::text, '[]','{}')::TEXT[];

Diese wenigen Funktionen, die den Antworten auf diese Frage entnommen sind, werden von mir verwendet und funktionieren hervorragend

CREATE OR REPLACE FUNCTION json_array_casttext(json) RETURNS text[] AS $f$
    SELECT array_agg(x) || ARRAY[]::text[] FROM json_array_elements_text($1) t(x);
$f$ LANGUAGE sql IMMUTABLE;

CREATE OR REPLACE FUNCTION jsonb_array_casttext(jsonb) RETURNS text[] AS $f$
    SELECT array_agg(x) || ARRAY[]::text[] FROM jsonb_array_elements_text($1) t(x);
$f$ LANGUAGE sql IMMUTABLE;

CREATE OR REPLACE FUNCTION json_array_castint(json) RETURNS int[] AS $f$
    SELECT array_agg(x)::int[] || ARRAY[]::int[] FROM json_array_elements_text($1) t(x);
$f$ LANGUAGE sql IMMUTABLE;

CREATE OR REPLACE FUNCTION jsonb_array_castint(jsonb) RETURNS int[] AS $f$
    SELECT array_agg(x)::int[] || ARRAY[]::int[] FROM jsonb_array_elements_text($1) t(x);
$f$ LANGUAGE sql IMMUTABLE;

In jedem von ihnen wird durch die Verkettung mit einem leeren Array ein Fall behandelt, bei dem ich mir ein wenig den Kopf zerbrochen habe. Wenn Sie versuchen, ein leeres Array von json/ jsonbohne Array zu werfen , wird statt eines nichts zurückgegeben leeres Array ( {}), wie Sie es erwarten würden. Ich bin mir sicher, dass es Optimierungen für sie gibt, aber sie bleiben der Einfachheit halber bei der Erläuterung des Konzepts erhalten.