| Type | Description                                |  Example                                         | Example Result
----+------+--------------------------------------------+--------------------------------------------------+----------------
 -> | int  | Get JSON array element (indexed from zero) | '[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json->2 | {"c":"baz"}
 -> | text | Get JSON object field by key               | '{"a": {"b":"foo"}}'::json->a                  | {"b":"foo"}

     | Type | Description                    |  Example                    | Example Result
-----+------+--------------------------------+-----------------------------+----------------
 ->> | int  | Get JSON array element as text | '[1,2,3]'::json->>2         | 3
 ->> | text | Get JSON object field as text  | '{"a":1,"b":2}'::json->>b | 2

     | Type   | Description                       |  Example                                   | Example Result
-----+--------+-----------------------------------+--------------------------------------------+----------------
 #>  | text[] | Get JSON object at specified path | '{"a": {"b":{"c": "foo"}}}'::json#>'{a,b}' | {"c": "foo"}

     | Type   | Description                               |  Example                                    | Example Result
-----+--------+-------------------------------------------+---------------------------------------------+----------------
 #>> | text[] | Get JSON object at specified path as text | '{"a":[1,2,3],"b":[4,5,6]}'::json#>>'{a,2}' | 3

    | Type  | Description                                                 |  Example
----+-------+-------------------------------------------------------------+---------------------------------------------
 @> | jsonb | Does the left JSON value contain within it the right value? | '{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb

    | Type  | Description                                              |  Example
----+-------+----------------------------------------------------------+---------------------------------------------
 <@ | jsonb | Is the left JSON value contained within the right value? | '{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb

   | Type | Description                                                     |  Example
---+------+-----------------------------------------------------------------+-------------------------------
 ? | text | Does the string exist as a top-level key within the JSON value? | '{"a":1, "b":2}'::jsonb ? b

    | Type   | Description                                            |  Example
----+--------+--------------------------------------------------------+---------------------------------------------------
 ?| | text[] | Do any of these array strings exist as top-level keys? | '{"a":1, "b":2, "c":3}'::jsonb ?| array[b, c]

    | Type   | Description                                            |  Example
----+--------+--------------------------------------------------------+----------------------------------------
 ?& | text[] | Do all of these array strings exist as top-level keys? | '["a", "b"]'::jsonb ?& array[a, b]

{"a": 3.14}            - "a"         == {}
{"a": "b"}             - "b"         == {"a": "b"}
{"a": 3.14}            - "a"         == {}
{"a": 3.14, "c": true} - "a"         == {"c": true}
["a", 2, "c"]          - "a"         == [2, "c"] -- can remove strings from arrays
[true, "b", 5]         - 0           == ["b", 5]
[true, "b", 5]         - 3           == [true, "b", 5]
[true, "b", 5]         - -1          == [true, "b"]
[true, "b", 5]         - -4          == [true, "b", 5]
[]                     - 1           == []
{"1": true}            - 1           == ERROR: cannot delete from object using integer index
1                      - <anything>  == ERROR: cannot delete from scalar
"a"                    - <anything>  == ERROR: cannot delete from scalar
true                   - <anything>  == ERROR: cannot delete from scalar
null                   - <anything>  == ERROR: cannot delete from scalar

   | Type    | Description                                                            |  Example
---+---------+------------------------------------------------------------------------+-------------------------------------------------
 - | text    | Delete key/value pair or string element from left operand.             | '{"a": "b"}'::jsonb - a
   |         | Key/value pairs are matched based on their key value.                  |
 - | integer | Delete the array element with specified index (Negative integers count | '["a", "b"]'::jsonb - 1
   |         | from the end). Throws an error if top level container is not an array. |

   | Type    | Description                                                            |  Example
---+---------+------------------------------------------------------------------------+-------------------------------------------------
 - | text[]  | Delete multiple key/value pairs or string elements from left operand.  | '{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[]
   |         | Key/value pairs are matched based on their key value.                  |

{"a": 3.14, "b": null}        #- []        == {"a": 3.14, "b": null}
{"a": 3.14, "b": null}        #- ["a"]     == {"b": null}
{"a": 3.14, "b": null}        #- ["a","b"] == {"a": 3.14, "b": null}
{"a": {"b":false}, "b": null} #- ["a","b"] == {"a": {}, "b": null}

[true, {"b":null}, 5]       #- []            == [true, {"b":null}, 5]
[true, {"b":null}, 5]       #- ["0"]         == [{"b":null}, 5]
[true, {"b":null}, 5]       #- ["b"]         == ERROR: path element at position 1 is not an integer: "b"
[true, {"b":null}, 5]       #- ["1","b"]     == [true, {}, 5]
[true, {"b":null}, 5]       #- ["-2","b"]    == [true, {}, 5]
{"a": {"b":[false,4,null]}} #- ["a","b","2"] == {"a": {"b":[false,4]}}
{"a": {"b":[false,4,null]}} #- ["a","b","c"] == ERROR: path element at position 3 is not an integer: "c"

1    #- {anything} == ERROR: cannot delete from scalar
"a"  #- {anything} == ERROR: cannot delete from scalar
true #- {anything} == ERROR: cannot delete from scalar
null #- {anything} == ERROR: cannot delete from scalar

    | Type   | Description                                             |  Example
----+--------+---------------------------------------------------------+------------------------------------
 #- | text[] | Delete the field or element with specified path         | '["a", {"b":1}]'::jsonb #- '{1,b}'
    |        | (for JSON arrays, negative integers count from the end) |

This operator is a standard concatenation function when used on arrays:

[1,2]   || [2,3]   == [1,2,2,3]
[]      || [1,2,3] == [1,2,3]
[1,2,3] || []      == [1,2,3]

When concatenating JSON objects with other JSON objects, the fields from the JSON object on the right are added to the JSON object on the left. When concatenating a JSON object with a JSON array, the object will be inserted into the array; either on the left or right, depending on the position relative to the operator.

When concatening an object with a scalar value, an exception is thrown.

{"a": 3.14}                    || {"b": true}         == {"a": 3.14, "b": true}
{"a": "b"}                     || {"a": null}         == {"a": null}
{"a": {"b": true, "c": false}} || {"a": {"b": false}} == {"a": {"b": false}}
{"a": 3.14}                    || [1,null]            == [{"a": 3.14},1,null]
[1,null]                       || {"a": 3.14}         == [1,null,{"a": 3.14}]
1                              || {"a": 3.14}         == ERROR: invalid concatenation of jsonb objects
{"a": 3.14}                    || false               == ERROR: invalid concatenation of jsonb objects

Scalar values can be thought of as being singleton arrays when used with this operator. This rule does not apply when concatenating with JSON objects.

1          || null       == [1,null]
true       || "a"        == [true,"a"]
[1,2]      || false      == [1,2,false]
null       || [1,"a"]    == [null,1,"a"]
{"a":3.14} || true       == ERROR: invalid concatenation of jsonb objects
3.14       || {"a":3.14} == ERROR: invalid concatenation of jsonb objects
{"a":3.14} || [true]     == [{"a":3.14},true]
[false]    || {"a":3.14} == [false,{"a":3.14}]

    | Type  | Description                                         |  Example
----+-------+-----------------------------------------------------+--------------------------------------------
 || | jsonb | Concatenate two jsonb values into a new jsonb value | '["a", "b"]'::jsonb || '["c", "d"]'::jsonb

Note: The || operator concatenates the elements at the top level of each of its operands. It does not operate recursively.

For example, if both operands are objects with a common key field name, the value of the field in the result will just be the value from the right hand operand.