Comment transformer un tableau json en tableau postgres?

J'ai une colonne dataqui contient un jsondocument à peu près comme ceci:

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

Je voudrais transformer le tagstableau imbriqué en une chaîne concaténée ( foo, bar). Ce serait facilement possible avec la array_to_string()fonction en théorie. Cependant, cette fonction n'agit pas sur les jsontableaux. Je me demande donc comment transformer ce jsontableau en Postgres array?

Postgres 9.4 ou plus récent

Visiblement inspiré par ce billet , Postgres 9.4 a ajouté la (les) fonction (s) manquante (s):
_{Merci à Laurence Rowe pour le correctif et Andrew Dunstan pour son engagement!}

• json_array_elements_text(json)
• jsonb_array_elements_text(jsonb)

Pour annuler le tableau JSON. Ensuite, utilisez array_agg()ou un constructeur ARRAY pour construire un tableau Postgres à partir de celui-ci. Ou string_agg()pour construire une text chaîne .

Agrégez les éléments non imbriqués par ligne dans une LATERALsous-requête ou une sous-requête corrélée. Ensuite, l'ordre d'origine est conservé et nous n'avons pas besoin ORDER BY, GROUP BYni même d'une clé unique dans la requête externe. Voir:

• Comment appliquer ORDER BY et LIMIT en combinaison avec une fonction d'agrégat?

Remplacez "json" par "jsonb" jsonbdans tout le code SQL suivant.

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;

Syntaxe courte:

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;

Apparenté, relié, connexe:

• Quelle est la différence entre LATERAL et une sous-requête dans PostgreSQL?

Constructeur ARRAY dans une sous-requête corrélée:

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

Apparenté, relié, connexe:

• Comment appliquer ORDER BY et LIMIT en combinaison avec une fonction d'agrégat?

Différence subtile : les nulléléments sont conservés dans des tableaux réels . Ceci n'est pas possible dans les requêtes ci-dessus produisant une textchaîne, qui ne peut pas contenir de nullvaleurs. La vraie représentation est un tableau.

Fonction wrapper

Pour une utilisation répétée, pour simplifier encore plus, encapsulez la logique dans une fonction:

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

Faites-en une fonction SQL , afin qu'il puisse être intégré dans des requêtes plus volumineuses.
Faites-le IMMUTABLE(parce que c'est le cas) pour éviter les évaluations répétées dans les requêtes plus volumineuses et autorisez-le dans les expressions d'index.

Appel:

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

db <> fiddle ici

Postgres 9.3 ou plus ancien

Utilisez la fonction json_array_elements(). Mais nous en tirons une double chaîne .

Requête alternative avec agrégation dans la requête externe. CROSS JOINsupprime les lignes avec des tableaux manquants ou vides. Peut aussi être utile pour traiter des éléments. Nous avons besoin d'une clé unique pour agréger:

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;

Le constructeur ARRAY, toujours avec les chaînes citées:

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

Notez que cela nullest converti en la valeur de texte "null", contrairement à ci-dessus. Incorrect, à proprement parler, et potentiellement ambigu.

Le pauvre homme sans scrupule avec 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;

Récupérer une seule ligne de 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;

Les chaînes forment une sous-requête corrélée:

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

ARRAY constructeur:

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

Fiddle SQL original (obsolète) .
db <> fiddle ici.

Apparenté, relié, connexe:

• Nécessité de sélectionner dynamiquement un élément de tableau JSON à partir d'une table postgresql

Notes (obsolète depuis la page 9.4)

Nous aurions besoin de json_array_elements_text(json), le jumeau de json_array_elements(json)pour renvoyer les textvaleurs appropriées d'un tableau JSON. Mais cela semble manquer à l' arsenal fourni de fonctions JSON . Ou une autre fonction pour extraire une textvaleur d'une JSONvaleur scalaire . Il me semble qu'il me manque aussi celui-là.
J'ai donc improvisé avec trim(), mais cela échouera pour des cas non triviaux ...

PG 9.4+

La réponse acceptée est certainement ce dont vous avez besoin, mais par souci de simplicité, voici une aide que j’utilise pour cela:

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;

Alors fais juste:

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

Cette question a été posée sur les listes de diffusion de PostgreSQL et j’ai imaginé cette méthode sophistiquée de conversion de texte JSON en type de texte PostgreSQL via l’opérateur d’extraction de champ 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
 ☃

Fondamentalement, il convertit la valeur en un tableau à un seul élément, puis demande le premier élément.

Une autre approche consiste à utiliser cet opérateur pour extraire tous les champs un par un. Mais pour les grands tableaux, cela est probablement plus lent, car il faut analyser la chaîne JSON entière pour chaque élément du tableau, ce qui entraîne une complexité de 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
 ☃

J'ai testé quelques options. Voici ma requête préférée. Supposons que nous ayons une table contenant les champs id et json. Le champ json contient un tableau que nous voulons transformer en tableau pg.

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

Il fonctionne n'importe où et plus vite que les autres, mais a l'air craquant.)

Tout d'abord, json array est converti en texte, puis nous changeons les crochets en parenthèses. Enfin, le texte est converti en tableau du type requis.

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

et si vous préférez les tableaux de texte []

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

Ces quelques fonctions, tirées des réponses à cette question , sont ce que j'utilise et fonctionnent très bien.

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;

Dans chacun d’eux, en concaténant avec un tableau vide, ils gèrent un cas qui m’a un peu troublé la tête, en ce sens que si vous essayez de lancer un tableau vide à partir de json/ jsonbsans, vous n’obtiendrez rien en retour. tableau vide ( {}) comme on peut s'y attendre. Je suis certain qu'il y a une optimisation pour eux, mais ils sont laissés en l'état pour simplifier l'explication du concept.