it-swarm.com.de

Wie ändere ich Felder innerhalb des neuen PostgreSQL-JSON-Datentyps?

Mit postgresql 9.3 kann ich bestimmte Felder eines JSON-Datentyps AUSWÄHLEN, aber wie modifiziert man sie mit UPDATE? Ich kann keine Beispiele dafür in der Postgresql-Dokumentation oder irgendwo online finden. Ich habe das Offensichtliche ausprobiert:

postgres=# create table test (data json);
CREATE TABLE
postgres=# insert into test (data) values ('{"a":1,"b":2}');
INSERT 0 1
postgres=# select data->'a' from test where data->>'b' = '2';
 ?column?
----------
 1
(1 row)
postgres=# update test set data->'a' = to_json(5) where data->>'b' = '2';
ERROR:  syntax error at or near "->"
LINE 1: update test set data->'a' = to_json(5) where data->>'b' = '2...
167
user9645

Update: Mit PostgreSQL 9.5 gibt es in PostgreSQL selbst einige jsonb-Manipulationsfunktionen (aber keine für json; Casts sind erforderlich, um json-Werte zu bearbeiten).

Zusammenführen von 2 (oder mehr) JSON-Objekten (oder Verketten von Arrays):

SELECT jsonb '{"a":1}' || jsonb '{"b":2}', -- will yield jsonb '{"a":1,"b":2}'
       jsonb '["a",1]' || jsonb '["b",2]'  -- will yield jsonb '["a",1,"b",2]'

Setzen eines einfachen Schlüssels kann folgendermaßen ausgeführt werden:

SELECT jsonb '{"a":1}' || jsonb_build_object('<key>', '<value>')

Dabei sollte <key> eine Zeichenfolge sein und <value> kann ein beliebiger Typ sein, den to_jsonb() akzeptiert.

Für einen Wert tief in einer JSON-Hierarchie setzen kann die Funktion jsonb_set() verwendet werden:

SELECT jsonb_set('{"a":[null,{"b":[]}]}', '{a,1,b,0}', jsonb '{"c":3}')
-- will yield jsonb '{"a":[null,{"b":[{"c":3}]}]}'

Vollständige Parameterliste von jsonb_set():

jsonb_set(target         jsonb,
          path           text[],
          new_value      jsonb,
          create_missing boolean default true)

path kann auch JSON-Array-Indizes enthalten. Negative Ganzzahlen, die dort angezeigt werden, zählen vom Ende der JSON-Arrays. Ein nicht vorhandener, aber positiver JSON-Array-Index fügt das Element jedoch an das Ende des Arrays an:

SELECT jsonb_set('{"a":[null,{"b":[1,2]}]}', '{a,1,b,1000}', jsonb '3', true)
-- will yield jsonb '{"a":[null,{"b":[1,2,3]}]}'

Für Einfügen in ein JSON-Array (wobei alle ursprünglichen Werte beibehalten werden)} kann die Funktion jsonb_insert() verwendet werden (in 9.6+; nur diese Funktion in diesem Abschnitt):

SELECT jsonb_insert('{"a":[null,{"b":[1]}]}', '{a,1,b,0}', jsonb '2')
-- will yield jsonb '{"a":[null,{"b":[2,1]}]}', and
SELECT jsonb_insert('{"a":[null,{"b":[1]}]}', '{a,1,b,0}', jsonb '2', true)
-- will yield jsonb '{"a":[null,{"b":[1,2]}]}'

Vollständige Parameterliste von jsonb_insert():

jsonb_insert(target       jsonb,
             path         text[],
             new_value    jsonb,
             insert_after boolean default false)

Negative Ganzzahlen, die in path angezeigt werden, zählen vom Ende der JSON-Arrays.

Also, z. Das Anhängen an ein Ende eines JSON-Arrays kann wie folgt durchgeführt werden:

SELECT jsonb_insert('{"a":[null,{"b":[1,2]}]}', '{a,1,b,-1}', jsonb '3', true)
-- will yield jsonb '{"a":[null,{"b":[1,2,3]}]}', and

Diese Funktion arbeitet jedoch etwas anders (als jsonb_set()), wenn path in target der Schlüssel eines JSON-Objekts ist. In diesem Fall wird ein neues Schlüsselwertpaar für das JSON-Objekt nur hinzugefügt, wenn der Schlüssel nicht verwendet wird. Wenn es verwendet wird, wird ein Fehler ausgegeben:

SELECT jsonb_insert('{"a":[null,{"b":[1]}]}', '{a,1,c}', jsonb '[2]')
-- will yield jsonb '{"a":[null,{"b":[1],"c":[2]}]}', but
SELECT jsonb_insert('{"a":[null,{"b":[1]}]}', '{a,1,b}', jsonb '[2]')
-- will raise SQLSTATE 22023 (invalid_parameter_value): cannot replace existing key

Löschen eines Schlüssels (oder eines Index) aus einem JSON-Objekt (oder aus einem Array) kann mit dem Operator - durchgeführt werden:

SELECT jsonb '{"a":1,"b":2}' - 'a', -- will yield jsonb '{"b":2}'
       jsonb '["a",1,"b",2]' - 1    -- will yield jsonb '["a","b",2]'

Löschen aus einer JSON-Hierarchie kann mit dem Operator #- durchgeführt werden:

SELECT '{"a":[null,{"b":[3.14]}]}' #- '{a,1,b,0}'
-- will yield jsonb '{"a":[null,{"b":[]}]}'

Für 9.4 können Sie eine modifizierte Version der ursprünglichen Antwort (unten) verwenden, aber anstatt einen JSON-String zu aggregieren, können Sie ihn mit json_object_agg() direkt in einem Json-Objekt aggregieren.

Ursprüngliche Antwort: Es ist möglich (ohne plpython oder plv8) auch in reinem SQL (benötigt jedoch 9.3+ und funktioniert nicht mit 9.2)

CREATE OR REPLACE FUNCTION "json_object_set_key"(
  "json"          json,
  "key_to_set"    TEXT,
  "value_to_set"  anyelement
)
  RETURNS json
  LANGUAGE sql
  IMMUTABLE
  STRICT
AS $function$
SELECT concat('{', string_agg(to_json("key") || ':' || "value", ','), '}')::json
  FROM (SELECT *
          FROM json_each("json")
         WHERE "key" <> "key_to_set"
         UNION ALL
        SELECT "key_to_set", to_json("value_to_set")) AS "fields"
$function$;

SQLFiddle

Bearbeiten:

Eine Version, die mehrere Schlüssel und Werte festlegt:

CREATE OR REPLACE FUNCTION "json_object_set_keys"(
  "json"          json,
  "keys_to_set"   TEXT[],
  "values_to_set" anyarray
)
  RETURNS json
  LANGUAGE sql
  IMMUTABLE
  STRICT
AS $function$
SELECT concat('{', string_agg(to_json("key") || ':' || "value", ','), '}')::json
  FROM (SELECT *
          FROM json_each("json")
         WHERE "key" <> ALL ("keys_to_set")
         UNION ALL
        SELECT DISTINCT ON ("keys_to_set"["index"])
               "keys_to_set"["index"],
               CASE
                 WHEN "values_to_set"["index"] IS NULL THEN 'null'::json
                 ELSE to_json("values_to_set"["index"])
               END
          FROM generate_subscripts("keys_to_set", 1) AS "keys"("index")
          JOIN generate_subscripts("values_to_set", 1) AS "values"("index")
         USING ("index")) AS "fields"
$function$;

Edit 2: as @ErwinBrandstetter bemerkt Diese Funktionen funktionieren wie ein sogenanntes UPSERT (aktualisiert ein Feld, falls es existiert, fügt ein, wenn es nicht existiert). Hier ist eine Variante, die nur UPDATE ist:

CREATE OR REPLACE FUNCTION "json_object_update_key"(
  "json"          json,
  "key_to_set"    TEXT,
  "value_to_set"  anyelement
)
  RETURNS json
  LANGUAGE sql
  IMMUTABLE
  STRICT
AS $function$
SELECT CASE
  WHEN ("json" -> "key_to_set") IS NULL THEN "json"
  ELSE (SELECT concat('{', string_agg(to_json("key") || ':' || "value", ','), '}')
          FROM (SELECT *
                  FROM json_each("json")
                 WHERE "key" <> "key_to_set"
                 UNION ALL
                SELECT "key_to_set", to_json("value_to_set")) AS "fields")::json
END
$function$;

Edit 3: Hier handelt es sich um eine rekursive Variante, die einen Blattwert setzen kann (UPSERT) (und die erste Funktion dieser Antwort verwendet), die sich auf einem Schlüsselpfad befindet (wobei Schlüssel nur auf innere Objekte verweisen können. innere Arrays nicht unterstützt):

CREATE OR REPLACE FUNCTION "json_object_set_path"(
  "json"          json,
  "key_path"      TEXT[],
  "value_to_set"  anyelement
)
  RETURNS json
  LANGUAGE sql
  IMMUTABLE
  STRICT
AS $function$
SELECT CASE COALESCE(array_length("key_path", 1), 0)
         WHEN 0 THEN to_json("value_to_set")
         WHEN 1 THEN "json_object_set_key"("json", "key_path"[l], "value_to_set")
         ELSE "json_object_set_key"(
           "json",
           "key_path"[l],
           "json_object_set_path"(
             COALESCE(NULLIF(("json" -> "key_path"[l])::text, 'null'), '{}')::json,
             "key_path"[l+1:u],
             "value_to_set"
           )
         )
       END
  FROM array_lower("key_path", 1) l,
       array_upper("key_path", 1) u
$function$;

Update: Funktionen werden jetzt komprimiert.

249
pozs

Mit 9.5 jsonb_set- verwenden

UPDATE objects
SET body = jsonb_set(body, '{name}', '"Mary"', true)
WHERE id = 1; 

wobei body ein Jsonb-Spaltentyp ist.

61
Teo Choong Ping

Mit Postgresql 9.5 können Sie folgende Schritte ausführen:

UPDATE test
SET data = data - 'a' || '{"a":5}'
WHERE data->>'b' = '2';

OR

UPDATE test
SET data = jsonb_set(data, '{a}', '5'::jsonb);

Jemand hat gefragt, wie viele Felder im Jsonb-Wert gleichzeitig aktualisiert werden sollen. Angenommen, wir erstellen eine Tabelle:

CREATE TABLE testjsonb ( id SERIAL PRIMARY KEY, object JSONB );

Dann fügen wir eine experimentelle Zeile ein:

INSERT INTO testjsonb
VALUES (DEFAULT, '{"a":"one", "b":"two", "c":{"c1":"see1","c2":"see2","c3":"see3"}}');

Dann aktualisieren wir die Zeile:

UPDATE testjsonb SET object = object - 'b' || '{"a":1,"d":4}';

Was macht das Folgende:

  1. Aktualisiert das a-Feld
  2. Entfernt das Feld b
  3. Fügen Sie das d-Feld hinzu

Auswahl der Daten:

SELECT jsonb_pretty(object) FROM testjsonb;

Wird darin enden, dass:

      jsonb_pretty
-------------------------
 {                      +
     "a": 1,            +
     "c": {             +
         "c1": "see1",  +
         "c2": "see2",  +
         "c3": "see3",  +
     },                 +
     "d": 4             +
 }
(1 row)

Verwenden Sie zum Aktualisieren des Felds nicht den concat-Operator ||. Verwenden Sie stattdessen jsonb_set. Welches ist nicht einfach:

UPDATE testjsonb SET object =
jsonb_set(jsonb_set(object, '{c,c1}','"seeme"'),'{c,c2}','"seehim"');

Verwenden Sie den concat-Operator beispielsweise für {c, c1}:

UPDATE testjsonb SET object = object || '{"c":{"c1":"seedoctor"}}';

Entfernt {c, c2} und {c, c3}.

Um mehr Leistung zu erhalten, suchen Sie die Stromversorgung unter postgresql json function documentation . Möglicherweise interessieren Sie sich für den Operator #-, die Funktion jsonb_set und auch für die Funktion jsonb_insert.

29
Fandi Susanto

Um auf den Antworten von @ pozs aufzubauen, finden Sie hier ein paar weitere PostgreSQL-Funktionen, die für einige nützlich sein können. (Erfordert PostgreSQL 9.3 oder höher)

Delete By Key: Löscht einen Wert nach Schlüssel aus der JSON-Struktur.

CREATE OR REPLACE FUNCTION "json_object_del_key"(
  "json"          json,
  "key_to_del"    TEXT
)
  RETURNS json
  LANGUAGE sql
  IMMUTABLE
  STRICT
AS $function$
SELECT CASE
  WHEN ("json" -> "key_to_del") IS NULL THEN "json"
  ELSE (SELECT concat('{', string_agg(to_json("key") || ':' || "value", ','), '}')
          FROM (SELECT *
                  FROM json_each("json")
                 WHERE "key" <> "key_to_del"
               ) AS "fields")::json
END
$function$;

Rekursives Löschen nach Schlüssel: Löscht einen Wert aus der JSON-Struktur per Schlüsselpfad. (erfordert die json_object_set_key-Funktion von @ pozs)

CREATE OR REPLACE FUNCTION "json_object_del_path"(
  "json"          json,
  "key_path"      TEXT[]
)
  RETURNS json
  LANGUAGE sql
  IMMUTABLE
  STRICT
AS $function$
SELECT CASE
  WHEN ("json" -> "key_path"[l] ) IS NULL THEN "json"
  ELSE
     CASE COALESCE(array_length("key_path", 1), 0)
         WHEN 0 THEN "json"
         WHEN 1 THEN "json_object_del_key"("json", "key_path"[l])
         ELSE "json_object_set_key"(
           "json",
           "key_path"[l],
           "json_object_del_path"(
             COALESCE(NULLIF(("json" -> "key_path"[l])::text, 'null'), '{}')::json,
             "key_path"[l+1:u]
           )
         )
       END
    END
  FROM array_lower("key_path", 1) l,
       array_upper("key_path", 1) u
$function$;

Verwendungsbeispiele:

s1=# SELECT json_object_del_key ('{"hello":[7,3,1],"foo":{"mofu":"fuwa", "moe":"kyun"}}',
                                 'foo'),
            json_object_del_path('{"hello":[7,3,1],"foo":{"mofu":"fuwa", "moe":"kyun"}}',
                                 '{"foo","moe"}');

 json_object_del_key |          json_object_del_path
---------------------+-----------------------------------------
 {"hello":[7,3,1]}   | {"hello":[7,3,1],"foo":{"mofu":"fuwa"}}
9
shru
UPDATE test
SET data = data::jsonb - 'a' || '{"a":5}'::jsonb
WHERE data->>'b' = '2'

Dies scheint an PostgreSQL 9.5 zu arbeiten

8
sigod

Mit PostgreSQL 9.4 haben wir die folgende Python-Funktion implementiert. Es kann auch mit PostgreSQL 9.3 funktionieren.

create language plpython2u;

create or replace function json_set(jdata jsonb, jpaths jsonb, jvalue jsonb) returns jsonb as $$
import json

a = json.loads(jdata)
b = json.loads(jpaths)

if a.__class__.__!= 'dict' and a.__class__.__!= 'list':
  raise plpy.Error("The json data must be an object or a string.")

if b.__class__.__!= 'list':
   raise plpy.Error("The json path must be an array of paths to traverse.")

c = a
for i in range(0, len(b)):
  p = b[i]
  plpy.notice('p == ' + str(p))

  if i == len(b) - 1:
    c[p] = json.loads(jvalue)

  else:
    if p.__class__.__== 'unicode':
      plpy.notice("Traversing '" + p + "'")
      if c.__class__.__!= 'dict':
        raise plpy.Error("  The value here is not a dictionary.")
      else:
        c = c[p]

    if p.__class__.__== 'int':
      plpy.notice("Traversing " + str(p))
      if c.__class__.__!= 'list':
        raise plpy.Error("  The value here is not a list.")
      else:
        c = c[p]

    if c is None:
      break    

return json.dumps(a)
$$ language plpython2u ;

Verwendungsbeispiel:

create table jsonb_table (jsonb_column jsonb);
insert into jsonb_table values
('{"cars":["Jaguar", {"type":"Unknown","partsList":[12, 34, 56]}, "Atom"]}');

select jsonb_column->'cars'->1->'partsList'->2, jsonb_column from jsonb_table;

update jsonb_table
set jsonb_column = json_set(jsonb_column, '["cars",1,"partsList",2]', '99');

select jsonb_column->'cars'->1->'partsList'->2, jsonb_column from jsonb_table;

Beachten Sie, dass ich für einen früheren Arbeitgeber eine Reihe von C-Funktionen zur Bearbeitung von JSON-Daten als Text (nicht als json oder jsonb) für PostgreSQL 7, 8 und 9 geschrieben habe. Zum Beispiel das Extrahieren von Daten mit json_path('{"obj":[12, 34, {"num":-45.67}]}', '$.obj[2]['num']'), Einstellungsdaten mit json_path_set('{"obj":[12, 34, {"num":-45.67}]}', '$.obj[2]['num']', '99.87') und so weiter. Es dauerte ungefähr 3 Tage Arbeit. Wenn Sie also auf älteren Systemen laufen und Zeit haben müssen, ist dies möglicherweise die Mühe wert. Ich kann mir vorstellen, dass die C-Version viel schneller ist als die Python-Version.

4
Magnus

Obwohl das Folgende diese Anforderung nicht erfüllt (die Funktion json_object_agg ist in PostgreSQL 9.3 nicht verfügbar), kann das Folgende für alle hilfreich sein, die nach einem || suchen Operator für PostgreSQL 9.4, wie in der kommenden PostgreSQL 9.5 implementiert:

CREATE OR REPLACE FUNCTION jsonb_merge(left JSONB, right JSONB)
RETURNS JSONB
AS $$
SELECT
  CASE WHEN jsonb_typeof($1) = 'object' AND jsonb_typeof($2) = 'object' THEN
       (SELECT json_object_agg(COALESCE(o.key, n.key), CASE WHEN n.key IS NOT NULL THEN n.value ELSE o.value END)::jsonb
        FROM jsonb_each($1) o
        FULL JOIN jsonb_each($2) n ON (n.key = o.key))
   ELSE 
     (CASE WHEN jsonb_typeof($1) = 'array' THEN LEFT($1::text, -1) ELSE '['||$1::text END ||', '||
      CASE WHEN jsonb_typeof($2) = 'array' THEN RIGHT($2::text, -1) ELSE $2::text||']' END)::jsonb
   END     
$$ LANGUAGE sql IMMUTABLE STRICT;
GRANT EXECUTE ON FUNCTION jsonb_merge(jsonb, jsonb) TO public;
CREATE OPERATOR || ( LEFTARG = jsonb, RIGHTARG = jsonb, PROCEDURE = jsonb_merge );

Ich habe eine kleine Funktion für mich geschrieben, die in Postgres 9.4 rekursiv arbeitet. Hier ist die Funktion (ich hoffe es funktioniert gut für dich):

CREATE OR REPLACE FUNCTION jsonb_update(val1 JSONB,val2 JSONB)
RETURNS JSONB AS $$
DECLARE
    result JSONB;
    v RECORD;
BEGIN
    IF jsonb_typeof(val2) = 'null'
    THEN 
        RETURN val1;
    END IF;

    result = val1;

    FOR v IN SELECT key, value FROM jsonb_each(val2) LOOP

        IF jsonb_typeof(val2->v.key) = 'object'
            THEN
                result = result || jsonb_build_object(v.key, jsonb_update(val1->v.key, val2->v.key));
            ELSE
                result = result || jsonb_build_object(v.key, v.value);
        END IF;
    END LOOP;

    RETURN result;
END;
$$ LANGUAGE plpgsql;

Hier ist ein Beispielgebrauch:

select jsonb_update('{"a":{"b":{"c":{"d":5,"dd":6},"cc":1}},"aaa":5}'::jsonb, '{"a":{"b":{"c":{"d":15}}},"aa":9}'::jsonb);
                            jsonb_update                             
---------------------------------------------------------------------
 {"a": {"b": {"c": {"d": 15, "dd": 6}, "cc": 1}}, "aa": 9, "aaa": 5}
(1 row)

Wie Sie sehen können, analysieren Sie tief im Inneren und aktualisieren/fügen Sie Werte hinzu, wenn dies erforderlich ist.

2
J. Raczkiewicz

Wenn Ihr Feldtyp json ist, funktionieren die folgenden für Sie.

UPDATE 
table_name
SET field_name = field_name::jsonb - 'key' || '{"key":new_val}' 
WHERE field_name->>'key' = 'old_value'.

Operator '-' löscht Schlüssel/Wert-Paar oder String-Element aus dem linken Operanden. Schlüssel/Wert-Paare werden basierend auf ihrem Schlüsselwert abgeglichen.

Operator '||' Verketten Sie zwei Jsonb-Werte zu einem neuen Jsonb-Wert.

Da es sich um Jsonb-Operatoren handelt, müssen Sie nur Folgendes eingeben: Jsonb

Weitere Informationen: JSON-Funktionen und Operatoren

Sie können meine Notiz hier lesen

1
Neethu

Das folgende Plpython-Snippet könnte hilfreich sein.

CREATE EXTENSION IF NOT EXISTS plpythonu;
CREATE LANGUAGE plpythonu;

CREATE OR REPLACE FUNCTION json_update(data json, key text, value text)
 RETURNS json
 AS $$
    import json
    json_data = json.loads(data)
    json_data[key] = value
    return json.dumps(json_data, indent=4)
 $$ LANGUAGE plpythonu;

-- Check how JSON looks before updating

SELECT json_update(content::json, 'CFRDiagnosis.mod_nbs', '1')
FROM sc_server_centre_document WHERE record_id = 35 AND template = 'CFRDiagnosis';

-- Once satisfied update JSON inplace

UPDATE sc_server_centre_document SET content = json_update(content::json, 'CFRDiagnosis.mod_nbs', '1')
WHERE record_id = 35 AND template = 'CFRDiagnosis';
1
Sandeep

Leider habe ich nichts in der Dokumentation gefunden, aber Sie können einen Workaround verwenden, zum Beispiel könnten Sie eine erweiterte Funktion schreiben.

Zum Beispiel in Python:

CREATE or REPLACE FUNCTION json_update(data json, key text, value json)
returns json
as $$
from json import loads, dumps
if key is None: return data
js = loads(data)
js[key] = value
return dumps(js)
$$ language plpython3u

und dann

update test set data=json_update(data, 'a', to_json(5)) where data->>'b' = '2';
1
Roman Pekar

Für diejenigen, die mybatis verwenden, ist hier ein Beispiel für eine Update-Anweisung:

<update id="saveAnswer">
    update quiz_execution set answer_data = jsonb_set(answer_data, concat('{', #{qid}, '}')::text[], #{value}::jsonb), updated_at = #{updatedAt}
    where id = #{id}
</update>


Params:

  • qid, der Schlüssel für das Feld.
  • value, ist eine gültige JSON-Zeichenfolge für den Feldwert.
    z. B. konvertiert von Objekt zu Json String über jackson,
0
Eric Wang

Dies funktionierte für mich, wenn ich versuche, ein Zeichenfolgentypfeld zu aktualisieren.

UPDATE table_name 
SET body = jsonb_set(body, '{some_key}', to_json('value'::TEXT)::jsonb);

Hoffe es hilft jemandem anderen raus!

0
Antonio

Sie können Schlüssel in jsonb auch folgendermaßen atomar inkrementieren:

UPDATE users SET counters = counters || CONCAT('{"bar":', COALESCE(counters->>'bar','0')::int + 1, '}')::jsonb WHERE id = 1;

SELECT * FROM users;

 id |    counters
----+------------
  1 | {"bar": 1}

Undefinierter Schlüssel -> nimmt den Startwert 0 an.

Eine ausführlichere Erklärung finden Sie in meiner Antwort hier: https://stackoverflow.com/a/39076637

0
joonas.fi

Ich habe festgestellt, dass frühere Antworten für erfahrene PostgreSQL-Benutzer geeignet sind, daher meine Antwort:

Angenommen, Sie haben eine Tabellenspalte vom Typ JSONB mit dem folgenden Wert:

{
    "key0": {
        "key01": "2018-05-06T12:36:11.916761+00:00",
        "key02": "DEFAULT_WEB_CONFIGURATION",

    "key1": {
        "key11": "Data System",
        "key12": "<p>Health,<p>my address<p>USA",
        "key13": "*Please refer to main screen labeling"
    }
}

nehmen wir an, wir möchten einen neuen Wert in der Zeile setzen:

"key13": "*Please refer to main screen labeling"

und platziere stattdessen den Wert:

"key13": "See main screen labeling"

wir verwenden die Funktion json_set (), um dem Schlüssel13 einen neuen Wert zuzuweisen

die Parameter zu jsonb_set ()

jsonb_set(target jsonb, path text[], new_value jsonb[, create_missing boolean])

in " target " - Ich werde den jsonb-Spaltennamen einfügen (dies ist die Tabellenspalte, die geändert wird)

" path " - ist der "json keys path", der zu dem zu überschreibenden Schlüssel führt (und diesen einschließt)

" new_value " - das ist der neue Wert, den wir zuweisen

in unserem Fall möchten wir den Wert von key13 aktualisieren, der sich unter key1 befindet (key1 -> key13):

daher lautet die Pfadsyntax : '{key1, key13}' (Der Pfad war der schwierigste Teil zu knacken - weil die Tutorials schrecklich sind)

jsonb_set(jsonb_column,'{key1,key13}','"See main screen labeling"')
0
Dror