Zusammenführen von verketteten JSON (B) -Spalten in der Abfrage

In Postgres 9.5+ können Sie JSONB wie folgt zusammenführen:

select json1 || json2;

Oder, wenn es sich um JSON handelt, zwingen Sie ggf. JSONB:

select json1::jsonb || json2::jsonb;

Oder:

select COALESCE(json1::jsonb||json2::jsonb, json1::jsonb, json2::jsonb);

(Andernfalls gibt jeder Nullwert in json1 oder json2 eine leere Zeile zurück.)

Zum Beispiel:

select data || '{"foo":"bar"}'::jsonb from photos limit 1;
                               ?column?
----------------------------------------------------------------------
 {"foo": "bar", "preview_url": "https://unsplash.it/500/720/123"}

Ein großes Lob an @MattZukowski für den Hinweis in einem Kommentar.

Sie können auch Json in Text umwandeln, verketten, ersetzen und wieder in Json konvertieren. Mit den gleichen Daten von Clément können Sie Folgendes tun:

SELECT replace(
    (json1::text || json2::text), 
    '}{', 
    ', ')::json 
FROM test

Sie können auch alle Json1 zu Single-Json verketten:

SELECT regexp_replace(
    array_agg((json1))::text,
    '}"(,)"{|\\| |^{"|"}$', 
    '\1', 
    'g'
)::json
FROM test

Diese Frage wird jedoch schon vor einiger Zeit beantwortet; die Tatsache, dass, wenn json1 und json2 den gleichen Schlüssel enthalten; Der Schlüssel erscheint zweimal im Dokument, scheint jedoch nicht best practice zu sein.

Daher können Sie diese jsonb_merge-Funktion mit PostgreSQL 9.5 verwenden:

CREATE OR REPLACE FUNCTION jsonb_merge(jsonb1 JSONB, jsonb2 JSONB)
    RETURNS JSONB AS $$
    DECLARE
      result JSONB;
      v RECORD;
    BEGIN
       result = (
    SELECT json_object_agg(KEY,value)
    FROM
      (SELECT jsonb_object_keys(jsonb1) AS KEY,
              1::int AS jsb,
              jsonb1 -> jsonb_object_keys(jsonb1) AS value
       UNION SELECT jsonb_object_keys(jsonb2) AS KEY,
                    2::int AS jsb,
                    jsonb2 -> jsonb_object_keys(jsonb2) AS value ) AS t1
           );
       RETURN result;
    END;
    $$ LANGUAGE plpgsql;

Die folgende Abfrage gibt die verketteten Jsonb-Spalten zurück, wobei die Schlüssel in json2 die Schlüssel in json1 dominieren:

select id, jsonb_merge(json1, json2) from test

Zu Ihrer Information, wenn jemand jsonb in> = 9.5 verwendet und er sich nur darum kümmert, dass Elemente der obersten Ebene ohne doppelte Schlüssel zusammengeführt werden, ist dies genauso einfach wie das Verwenden der || Operator:

select '{"a1": "b2"}'::jsonb || '{"f":{"g" : "h"}}'::jsonb;
      ?column?           
-----------------------------
 {"a1": "b2", "f": {"g": "h"}}
(1 row)

Diese Funktion würde verschachtelte Json-Objekte zusammenführen 

create or replace function jsonb_merge(CurrentData jsonb,newData jsonb)
 returns jsonb
 language sql
 immutable
as $jsonb_merge_func$
 select case jsonb_typeof(CurrentData)
   when 'object' then case jsonb_typeof(newData)
     when 'object' then (
       select    jsonb_object_agg(k, case
                   when e2.v is null then e1.v
                   when e1.v is null then e2.v
                   when e1.v = e2.v then e1.v 
                   else jsonb_merge(e1.v, e2.v)
                 end)
       from      jsonb_each(CurrentData) e1(k, v)
       full join jsonb_each(newData) e2(k, v) using (k)
     )
     else newData
   end
   when 'array' then CurrentData || newData
   else newData
 end
$jsonb_merge_func$;

CREATE OR REPLACE FUNCTION jsonb_merge(pCurrentData jsonb, pMergeData jsonb, pExcludeKeys text[])
RETURNS jsonb IMMUTABLE LANGUAGE sql
AS $$
    SELECT json_object_agg(key,value)::jsonb
    FROM (
        WITH to_merge AS (
            SELECT * FROM jsonb_each(pMergeData) 
        )
        SELECT *
        FROM jsonb_each(pCurrentData)
        WHERE key NOT IN (SELECT key FROM to_merge)
     AND ( pExcludeKeys ISNULL OR key <> ALL(pExcludeKeys))
        UNION ALL
        SELECT * FROM to_merge
    ) t;
$$;

SELECT jsonb_merge ('{"a": 1, "b": 9, "c": 3, "e": 5}' :: jsonb, '{"b": 2, "d": 4}': : jsonb, '{"c", "e"}' :: text []) als jsonb

funktioniert gut als Alternative zu || wenn rekursives Deep Merge erforderlich ist (gefunden hier ):

create or replace function jsonb_merge_recurse(orig jsonb, delta jsonb)
returns jsonb language sql as $$
    select
        jsonb_object_agg(
            coalesce(keyOrig, keyDelta),
            case
                when valOrig isnull then valDelta
                when valDelta isnull then valOrig
                when (jsonb_typeof(valOrig) <> 'object' or jsonb_typeof(valDelta) <> 'object') then valDelta
                else jsonb_merge_recurse(valOrig, valDelta)
            end
        )
    from jsonb_each(orig) e1(keyOrig, valOrig)
    full join jsonb_each(delta) e2(keyDelta, valDelta) on keyOrig = keyDelta
$$;

Versuchen Sie dies, wenn jemand ein Problem beim Zusammenführen von zwei JSON-Objekten hat

select table.attributes::jsonb || json_build_object('foo',1,'bar',2)::jsonb FROM table where table.x='y';