Come trasformare array JSON in array Postgres?

Ho una colonna datache contiene un jsondocumento più o meno in questo modo:

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

Vorrei trasformare l' tagsarray nidificato in una stringa concatenata ( foo, bar). Ciò sarebbe facilmente possibile con la array_to_string()funzione in teoria. Tuttavia, questa funzione non agisce sugli jsonarray. Quindi mi chiedo come trasformare questo jsonarray in un Postgres array?

Postgres 9.4 o successivo

Ovviamente ispirato a questo post , Postgres 9.4 ha aggiunto le funzioni mancanti:
_{Grazie a Laurence Rowe per la patch e Andrew Dunstan per l'impegno!}

• json_array_elements_text(json)
• jsonb_array_elements_text(jsonb)

Per rovesciare l'array JSON. Quindi utilizzare array_agg()o un costruttore ARRAY per costruire un array Postgres da esso. O string_agg()per costruire una text stringa .

Aggrega elementi non desiderati per riga in una LATERALo sottoquery correlata. Quindi l' ordine originale viene preservato e non è necessario ORDER BY, GROUP BYo anche una chiave univoca nella query esterna. Vedere:

• Come applicare ORDER BY e LIMIT in combinazione con una funzione aggregata?

Sostituisci "json" con "jsonb" per jsonbin tutto il seguente codice SQL.

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;

Sintassi breve:

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;

Relazionato:

• Qual è la differenza tra LATERAL e una sottoquery in PostgreSQL?

Costruttore ARRAY in subquery correlata:

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

Relazionato:

• Come applicare ORDER BY e LIMIT in combinazione con una funzione aggregata?

Differenza sottile : gli nullelementi sono conservati in array reali . Questo non è possibile nelle query sopra che producono una textstringa, che non può contenere nullvalori. La vera rappresentazione è un array.

Funzione wrapper

Per un uso ripetuto, per rendere questo ancora più semplice, incapsulare la logica in una funzione:

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

Renderlo una funzione SQL , quindi può essere integrato in query più grandi.
Renderlo IMMUTABLE(perché lo è) per evitare ripetute valutazioni in query più grandi e consentirlo nelle espressioni di indice.

Chiamata:

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

db <> violino qui

Postgres 9.3 o precedente

Utilizzare la funzione json_array_elements(). Ma otteniamo stringhe tra virgolette doppie da esso.

Query alternativa con aggregazione nella query esterna. CROSS JOINrimuove le righe con array mancanti o vuoti. Può essere utile anche per l'elaborazione di elementi. Abbiamo bisogno di una chiave univoca per aggregare:

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;

Costruttore ARRAY, ancora con stringhe tra virgolette:

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

Si noti che nullviene convertito nel valore di testo "null", diversamente da quanto sopra. Inesatto, a rigor di termini e potenzialmente ambiguo.

Povero uomo che non sta citando 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;

Recupera una singola riga da tbl:

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;

Sottoquery correlata forma stringhe:

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

Costruttore ARRAY:

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

Fiddle SQL originale (obsoleto) .
db <> violino qui.

Relazionato:

• È necessario selezionare un elemento array JSON in modo dinamico da una tabella postgresql

Note (obsolete da pag 9.4)

Avremmo bisogno di un json_array_elements_text(json), il gemello di json_array_elements(json)per restituire i textvalori corretti da un array JSON. Ma questo sembra mancare dall'arsenale fornito di funzioni JSON . O qualche altra funzione per estrarre un textvalore da un JSONvalore scalare . Mi sembra che manchi anche quello.
Così ho improvvisato con trim(), ma ciò fallirà per casi non banali ...

PG 9.4+

La risposta accettata è sicuramente ciò di cui hai bisogno, ma per semplicità ecco un aiuto che uso per questo:

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;

Quindi fai semplicemente:

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

Questa domanda è stata posta sulle mailing list di PostgreSQL e mi è venuta in mente questa maniera hacker di convertire il testo JSON in tipo di testo PostgreSQL tramite l'operatore di estrazione di campi JSON:

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
 ☃

Fondamentalmente converte il valore in una matrice a elemento singolo e quindi chiede il primo elemento.

Un altro approccio sarebbe quello di utilizzare questo operatore per estrarre tutti i campi uno per uno. Ma per array di grandi dimensioni questo è probabilmente più lento, poiché deve analizzare l'intera stringa JSON per ciascun elemento dell'array, portando alla complessità O (n ^ 2).

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
 ☃

Ho testato alcune opzioni. Ecco la mia domanda preferita. Supponiamo di avere una tabella contenente id e json field. Il campo json contiene array, che vogliamo trasformare in array pg.

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

Funziona ovunque e più velocemente di altri, ma sembra stampella)

In primo luogo la matrice json viene lanciata come testo, quindi cambiamo solo le parentesi quadre in parentesi. Finalmente il testo viene lanciato come matrice del tipo richiesto.

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

e se preferisci le matrici di testo []

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

Queste poche funzioni, prese dalle risposte a questa domanda , sono ciò che sto usando e stanno funzionando alla grande

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 ognuno di essi, concatenandosi con un array vuoto, gestiscono un caso che mi ha fatto distrarre un po 'il cervello, nel senso che se provi a lanciare un array vuoto da json/ jsonbsenza di esso non otterrai nulla, al posto di un array vuoto ( {}) come ti aspetteresti. Sono certo che ci sia un po 'di ottimizzazione per loro, ma sono lasciati per semplicità nella spiegazione del concetto.