json -> integer → json

jsonb -> integer → jsonb

Extracts <parameter>n</parameter>'th element of JSON array (array elements are indexed from zero, but negative integers count from the end). JSON配列のn番目の要素を取り出します。 （配列要素はゼロから始まりますが、負の整数は最後から数えられます。）

'[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json -> 2 → {"c":"baz"}

'[{"a":"foo"},{"b":"bar"},{"c":"baz"}]'::json -> -3 → {"a":"foo"}

json -> text → json

jsonb -> text → jsonb

Extracts JSON object field with the given key. 与えられたキーでJSONオブジェクトフィールドを取り出します。

'{"a": {"b":"foo"}}'::json -> 'a' → {"b":"foo"}

json ->> integer → text

jsonb ->> integer → text

Extracts <parameter>n</parameter>'th element of JSON array, as <type>text</type>. JSON配列のn番目の要素をtextとして取り出します。

'[1,2,3]'::json ->> 2 → 3

json ->> text → text

jsonb ->> text → text

Extracts JSON object field with the given key, as <type>text</type>. 与えられたキーでJSONオブジェクトフィールドをtextとして取り出します。

'{"a":1,"b":2}'::json ->> 'b' → 2

json #> text[] → json

jsonb #> text[] → jsonb

Extracts JSON sub-object at the specified path, where path elements can be either field keys or array indexes. 指定したパスにおけるJSONの副オブジェクトを取り出します。パス要素はフィールドキーあるいは配列のインデックスでも構いません。

'{"a": {"b": ["foo","bar"]}}'::json #> '{a,b,1}' → "bar"

json #>> text[] → text

jsonb #>> text[] → text

Extracts JSON sub-object at the specified path as <type>text</type>. 指定したパスにおけるJSONの副オブジェクトをtextとして取り出します。

'{"a": {"b": ["foo","bar"]}}'::json #>> '{a,b,1}' → bar

jsonb @> jsonb → boolean

Does the first JSON value contain the second? (See <xref linkend="json-containment"/> for details about containment.) 最初のJSON値は二番目を含んでいるか？ （包含の詳細は8.14.3を参照してください。）

'{"a":1, "b":2}'::jsonb @> '{"b":2}'::jsonb → t

jsonb <@ jsonb → boolean

Is the first JSON value contained in the second? 最初のJSON値は二番目に含まれているか？

'{"b":2}'::jsonb <@ '{"a":1, "b":2}'::jsonb → t

jsonb ? text → boolean

Does the text string exist as a top-level key or array element within the JSON value? そのテキスト文字列はトップレベルのキーあるいは配列要素としてJSON値中に存在しているか？

'{"a":1, "b":2}'::jsonb ? 'b' → t

'["a", "b", "c"]'::jsonb ? 'b' → t

jsonb ?| text[] → boolean

Do any of the strings in the text array exist as top-level keys or array elements? テキスト配列中のどれかの文字列がトップレベルのキーあるいは配列要素として存在しているか？

'{"a":1, "b":2, "c":3}'::jsonb ?| array['b', 'd'] → t

jsonb ?& text[] → boolean

Do all of the strings in the text array exist as top-level keys or array elements? テキスト配列のすべての文字列がトップレベルのキーあるいは配列要素として存在しているか？

'["a", "b", "c"]'::jsonb ?& array['a', 'b'] → t

jsonb || jsonb → jsonb

Concatenates two <type>jsonb</type> values. Concatenating two arrays generates an array containing all the elements of each input. Concatenating two objects generates an object containing the union of their keys, taking the second object's value when there are duplicate keys. All other cases are treated by converting a non-array input into a single-element array, and then proceeding as for two arrays. Does not operate recursively: only the top-level array or object structure is merged. 2つのjsonb値を結合します。 2つの配列を結合するとそれらのキーの和を持つ配列を生成します。 キーが重複している場合は2番目のオブジェクトの値が使用されます。 それ以外の場合には非配列入力を単一の要素を持つ配列に変換し、次に2つの配列として取り扱います。 再帰操作は行いません。トップレベルの配列あるいはオブジェクト構造だけがマージされます。

'["a", "b"]'::jsonb || '["a", "d"]'::jsonb → ["a", "b", "a", "d"]

'{"a": "b"}'::jsonb || '{"c": "d"}'::jsonb → {"a": "b", "c": "d"}

'[1, 2]'::jsonb || '3'::jsonb → [1, 2, 3]

'{"a": "b"}'::jsonb || '42'::jsonb → [{"a": "b"}, 42]

To append an array to another array as a single entry, wrap it in an additional layer of array, for example: 一つの要素を持つとして配列を他の配列に追加するには、例のように配列の追加のレイヤ中に含めてください。

'[1, 2]'::jsonb || jsonb_build_array('[3, 4]'::jsonb) → [1, 2, [3, 4]]

jsonb - text → jsonb

Deletes a key (and its value) from a JSON object, or matching string value(s) from a JSON array. キー（及びその値）をJSONオブジェクトから削除します。あるいはマッチする文字列値をJSON配列から削除します。

'{"a": "b", "c": "d"}'::jsonb - 'a' → {"c": "d"}

'["a", "b", "c", "b"]'::jsonb - 'b' → ["a", "c"]

jsonb - text[] → jsonb

Deletes all matching keys or array elements from the left operand. 左のオペランドからマッチするすべてのキーあるいは配列要素を削除します。

'{"a": "b", "c": "d"}'::jsonb - '{a,c}'::text[] → {}

jsonb - integer → jsonb

Deletes the array element with specified index (negative integers count from the end). Throws an error if JSON value is not an array. 指定したインデックス（負の整数は最後から数えます）の配列要素を削除します。 JSON値が配列でなければエラーが生じます。

'["a", "b"]'::jsonb - 1 → ["a"]

jsonb #- text[] → jsonb

Deletes the field or array element at the specified path, where path elements can be either field keys or array indexes. 指定パスのフィールドあるいは配列要素を削除します。パス要素はフィールドキーあるいは配列インデックスが指定できます。

'["a", {"b":1}]'::jsonb #- '{1,b}' → ["a", {}]

jsonb @? jsonpath → boolean

Does JSON path return any item for the specified JSON value? (This is useful only with SQL-standard JSON path expressions, not <link linkend="functions-sqljson-check-expressions">predicate check expressions</link>, since those always return a value.) JSONパスは指定されたJSON値に対して何らかの項目を返すか?（これはSQL標準のJSONパス式でのみ有用であり、述語チェック式では有効ではありません。述語チェック式は常に値を返すからです。）

'{"a":[1,2,3,4,5]}'::jsonb @? '$.a[*] ? (@ > 2)' → t

jsonb @@ jsonpath → boolean

Returns the result of a JSON path predicate check for the specified JSON value. (This is useful only with <link linkend="functions-sqljson-check-expressions">predicate check expressions</link>, not SQL-standard JSON path expressions, since it will return <literal>NULL</literal> if the path result is not a single boolean value.) 指定されたJSON値に対するJSONパス述語チェックの結果を返します（これは、SQL標準のJSONパス式ではなく、述部チェック式でのみ有用です。パス結果が単一のブール値でない場合はNULLを返すためです）。

'{"a":[1,2,3,4,5]}'::jsonb @@ '$.a[*] > 2' → t

to_json ( anyelement ) → json

to_jsonb ( anyelement ) → jsonb

Converts any SQL value to <type>json</type> or <type>jsonb</type>. Arrays and composites are converted recursively to arrays and objects (multidimensional arrays become arrays of arrays in JSON). Otherwise, if there is a cast from the SQL data type to <type>json</type>, the cast function will be used to perform the conversion;<footnote> SQL値をjsonあるいはjsonbに変換します。 配列と複合型は再帰的に配列とオブジェクトに変換されます。（多次元配列はJSONにおける配列の配列になります。） それ以外は、そのSQLデータ型からjsonにキャストがあれば、キャスト関数が変換のために用いられます。^[a] otherwise, a scalar JSON value is produced. For any scalar other than a number, a Boolean, or a null value, the text representation will be used, with escaping as necessary to make it a valid JSON string value. そうでなければスカラーJSON値が生成されます。 数値、論理値、NULL以外のスカラーには、有効なJSON文字列値にするための必要なエスケープ処理が施されたテキスト表現が使われます。

to_json('Fred said "Hi."'::text) → "Fred said \"Hi.\""

to_jsonb(row(42, 'Fred said "Hi."'::text)) → {"f1": 42, "f2": "Fred said \"Hi.\""}

array_to_json ( anyarray [, boolean ] ) → json

Converts an SQL array to a JSON array. The behavior is the same as <function>to_json</function> except that line feeds will be added between top-level array elements if the optional boolean parameter is true. SQL配列をJSON配列に変換します。 追加の論理引数が真であるときに改行がトップレベルの配列要素の間に加えられる以外は、その振る舞いはto_jsonと同じです。

array_to_json('{{1,5},{99,100}}'::int[]) → [[1,5],[99,100]]

json_array ( [ { value_expression [ FORMAT JSON ] } [, ...] ] [ { NULL | ABSENT } ON NULL ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

json_array ( [ query_expression ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

Constructs a JSON array from either a series of <replaceable>value_expression</replaceable> parameters or from the results of <replaceable>query_expression</replaceable>, which must be a SELECT query returning a single column. If <literal>ABSENT ON NULL</literal> is specified, NULL values are ignored. This is always the case if a <replaceable>query_expression</replaceable> is used. JSON配列を、一連のvalue_expression引数、またはquery_expressionの結果のいずれかから構成します。 query_expressionは、単一の列を返すSELECT問い合わせである必要があります。 ABSENT ON NULLが指定されている場合、NULL値は無視されます。 query_expressionが使用されている場合、常にそうなります。

json_array(1,true,json '{"a":null}') → [1, true, {"a":null}]

json_array(SELECT * FROM (VALUES(1),(2)) t) → [1, 2]

row_to_json ( record [, boolean ] ) → json

Converts an SQL composite value to a JSON object. The behavior is the same as <function>to_json</function> except that line feeds will be added between top-level elements if the optional boolean parameter is true. SQL複合値をJSONオブジェクトに変換します。 追加の論理引数が真であるときに改行がトップレベルの配列要素の間に加えられる以外は、その振る舞いはto_jsonと同じです。

row_to_json(row(1,'foo')) → {"f1":1,"f2":"foo"}

json_build_array ( VARIADIC "any" ) → json

jsonb_build_array ( VARIADIC "any" ) → jsonb

Builds a possibly-heterogeneously-typed JSON array out of a variadic argument list. Each argument is converted as per <function>to_json</function> or <function>to_jsonb</function>. 異なる型から構成される可能性のあるJSON配列をvariadic引数リストから作成します。 各々の引数はto_jsonあるいはto_jsonbに従って変換されます。

json_build_array(1, 2, 'foo', 4, 5) → [1, 2, "foo", 4, 5]

json_build_object ( VARIADIC "any" ) → json

jsonb_build_object ( VARIADIC "any" ) → jsonb

Builds a JSON object out of a variadic argument list. By convention, the argument list consists of alternating keys and values. Key arguments are coerced to text; value arguments are converted as per <function>to_json</function> or <function>to_jsonb</function>. variadic引数リストからJSONオブジェクトを作成します。 慣例により引数リストは代替キーと値が交互に並んだものです。 キー引数はテキストに強制的に変換されます。 値引数はto_jsonあるいはto_jsonbに従って変換されます。

json_build_object('foo', 1, 2, row(3,'bar')) → {"foo" : 1, "2" : {"f1":3,"f2":"bar"}}

json_object ( [ { key_expression { VALUE | ':' } value_expression [ FORMAT JSON [ ENCODING UTF8 ] ] }[, ...] ] [ { NULL | ABSENT } ON NULL ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ])

Constructs a JSON object of all the key/value pairs given, or an empty object if none are given. <replaceable>key_expression</replaceable> is a scalar expression defining the <acronym>JSON</acronym> key, which is converted to the <type>text</type> type. It cannot be <literal>NULL</literal> nor can it belong to a type that has a cast to the <type>json</type> type. If <literal>WITH UNIQUE KEYS</literal> is specified, there must not be any duplicate <replaceable>key_expression</replaceable>. Any pair for which the <replaceable>value_expression</replaceable> evaluates to <literal>NULL</literal> is omitted from the output if <literal>ABSENT ON NULL</literal> is specified; if <literal>NULL ON NULL</literal> is specified or the clause omitted, the key is included with value <literal>NULL</literal>. 指定されたすべてのキー/値ペアのJSONオブジェクトを構築します。 キー/値ペアが指定されていない場合は、空のオブジェクトを構築します。 key_expressionは、textタイプに変換されるJSONキーを定義するスカラ式です。 NULLにすることも、JSONタイプにキャストを持つタイプに属することもできません。 WITH UNIQUE KEYSが指定されている場合は、重複key_expressionがあってはなりません。 ABSENT ON NULLが指定されている場合、NULLと評価されるvalue_expressionは出力から除外されます。 NULL ON NULLが指定されているか、その句が省略されている場合、キーはNULLの値で含まれます。

json_object('code' VALUE 'P123', 'title': 'Jaws') → {"code" : "P123", "title" : "Jaws"}

json_object ( text[] ) → json

jsonb_object ( text[] ) → jsonb

Builds a JSON object out of a text array. The array must have either exactly one dimension with an even number of members, in which case they are taken as alternating key/value pairs, or two dimensions such that each inner array has exactly two elements, which are taken as a key/value pair. All values are converted to JSON strings. テキスト配列からJSONオブジェクトを作成します。 配列は、偶数個の要素からなる1次元（キー／値の対が交互に並んでいるものと扱われます）あるいは内側の配列が2つの要素を持つ2次元（2つの要素がキー／値のペアとして扱われます）のいずれかでなければなりません。 すべての値はJSON文字列に変換されます。

json_object('{a, 1, b, "def", c, 3.5}') → {"a" : "1", "b" : "def", "c" : "3.5"}

json_object('{{a, 1}, {b, "def"}, {c, 3.5}}') → {"a" : "1", "b" : "def", "c" : "3.5"}

json_object ( keys text[], values text[] ) → json

jsonb_object ( keys text[], values text[] ) → jsonb

This form of <function>json_object</function> takes keys and values pairwise from separate text arrays. Otherwise it is identical to the one-argument form. この形のjson_objectは2つの別々の配列からキーと値の対を取ります。 他の点ではすべて、引数1つの形と同じです。

json_object('{a,b}', '{1,2}') → {"a": "1", "b": "2"}

json ( expression [ FORMAT JSON [ ENCODING UTF8 ]] [ { WITH | WITHOUT } UNIQUE [ KEYS ]] ) → json

Converts a given expression specified as <type>text</type> or <type>bytea</type> string (in UTF8 encoding) into a JSON value. If <replaceable>expression</replaceable> is NULL, an <acronym>SQL</acronym> null value is returned. If <literal>WITH UNIQUE</literal> is specified, the <replaceable>expression</replaceable> must not contain any duplicate object keys. 指定されたtextまたはbytea文字列（UTF8エンコーディング）をJSON値に変換します。 expressionがNULLの場合、SQLのNULL値が返されます。 WITH UNIQUEが指定された場合、expressionは重複するオブジェクトキーを含んではなりません。

json('{"a":123, "b":[true,"foo"], "a":"bar"}') → {"a":123, "b":[true,"foo"], "a":"bar"}

json_scalar ( expression )

Converts a given SQL scalar value into a JSON scalar value. If the input is NULL, an <acronym>SQL</acronym> null is returned. If the input is number or a boolean value, a corresponding JSON number or boolean value is returned. For any other value, a JSON string is returned. 指定されたSQLスカラー値をJSONスカラー値に変換します。 入力がNULLの場合、SQLのNULLが返されます。 入力が数値またはブール値の場合、対応するJSONの数値またはブール値が返されます。 それ以外の場合は、JSONの文字列が返されます。

json_scalar(123.45) → 123.45

json_scalar(CURRENT_TIMESTAMP) → "2022-05-10T10:51:04.62128-04:00"

json_serialize ( expression [ FORMAT JSON [ ENCODING UTF8 ] ] [ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ] )

Converts an SQL/JSON expression into a character or binary string. The <replaceable>expression</replaceable> can be of any JSON type, any character string type, or <type>bytea</type> in UTF8 encoding. The returned type used in <literal> RETURNING</literal> can be any character string type or <type>bytea</type>. The default is <type>text</type>. SQL/JSON式を文字列またはバイナリ文字列に変換します。 expressionは、任意のJSON型、任意の文字列型、またはUTF8エンコーディングのbyteaです。 RETURNINGで使用される戻り型は、任意の文字列型またはbyteaです。 デフォルトはtextです。

json_serialize('{ "a" : 1 } ' RETURNING bytea) → \x7b20226122203a2031207d20

expression IS [ NOT ] JSON [ { VALUE | SCALAR | ARRAY | OBJECT } ] [ { WITH | WITHOUT } UNIQUE [ KEYS ] ]

This predicate tests whether <replaceable>expression</replaceable> can be parsed as JSON, possibly of a specified type. If <literal>SCALAR</literal> or <literal>ARRAY</literal> or <literal>OBJECT</literal> is specified, the test is whether or not the JSON is of that particular type. If <literal>WITH UNIQUE KEYS</literal> is specified, then any object in the <replaceable>expression</replaceable> is also tested to see if it has duplicate keys. この述語は、expressionが指定された型のJSONとして解析できるかどうかをテストします。 SCALAR、ARRAY、またはOBJECTが指定されている場合、テストはJSONがその特定の型のものであるかどうかを示します。 WITH UNIQUE KEYSが指定されている場合、expressionのオブジェクトもテストされ、重複キーがあるかどうかが確認されます。

SELECT js,
  js IS JSON "json?",
  js IS JSON SCALAR "scalar?",
  js IS JSON OBJECT "object?",
  js IS JSON ARRAY "array?"
FROM (VALUES
      ('123'), ('"abc"'), ('{"a": "b"}'), ('[1,2]'),('abc')) foo(js);
     js     | json? | scalar? | object? | array?
------------+-------+---------+---------+--------
 123        | t     | t       | f       | f
 "abc"      | t     | t       | f       | f
 {"a": "b"} | t     | f       | t       | f
 [1,2]      | t     | f       | f       | t
 abc        | f     | f       | f       | f

SELECT js,
  js IS JSON OBJECT "object?",
  js IS JSON ARRAY "array?",
  js IS JSON ARRAY WITH UNIQUE KEYS "array w. UK?",
  js IS JSON ARRAY WITHOUT UNIQUE KEYS "array w/o UK?"
FROM (VALUES ('[{"a":"1"},
 {"b":"2","b":"3"}]')) foo(js);
-[ RECORD 1 ]-+--------------------
js            | [{"a":"1"},        +
              |  {"b":"2","b":"3"}]
object?       | f
array?        | t
array w. UK?  | f
array w/o UK? | t

json_array_elements ( json ) → setof json

jsonb_array_elements ( jsonb ) → setof jsonb

Expands the top-level JSON array into a set of JSON values. トップレベルのJSON配列をJSON値の集合に展開します。

select * from json_array_elements('[1,true, [2,false]]') →

   value
-----------
 1
 true
 [2,false]

json_array_elements_text ( json ) → setof text

jsonb_array_elements_text ( jsonb ) → setof text

Expands the top-level JSON array into a set of <type>text</type> values. トップレベルのJSON配列をtext値の集合に展開します。

select * from json_array_elements_text('["foo", "bar"]') →

   value
-----------
 foo
 bar

json_array_length ( json ) → integer

jsonb_array_length ( jsonb ) → integer

Returns the number of elements in the top-level JSON array. トップレベルのJSON配列の要素数を返します。

json_array_length('[1,2,3,{"f1":1,"f2":[5,6]},4]') → 5

jsonb_array_length('[]') → 0

json_each ( json ) → setof record ( key text, value json )

jsonb_each ( jsonb ) → setof record ( key text, value jsonb )

Expands the top-level JSON object into a set of key/value pairs. トップレベルのJSONオブジェクトをキー／値のペアの集合に展開します。

select * from json_each('{"a":"foo", "b":"bar"}') →

 key | value
-----+-------
 a   | "foo"
 b   | "bar"

json_each_text ( json ) → setof record ( key text, value text )

jsonb_each_text ( jsonb ) → setof record ( key text, value text )

Expands the top-level JSON object into a set of key/value pairs. The returned <parameter>value</parameter>s will be of type <type>text</type>. トップレベルのJSONオブジェクトをキー／値のペアの集合に展開します。 返り値のvalueはtext型です。

select * from json_each_text('{"a":"foo", "b":"bar"}') →

 key | value
-----+-------
 a   | foo
 b   | bar

json_extract_path ( from_json json, VARIADIC path_elems text[] ) → json

jsonb_extract_path ( from_json jsonb, VARIADIC path_elems text[] ) → jsonb

Extracts JSON sub-object at the specified path. (This is functionally equivalent to the <literal>#&gt;</literal> operator, but writing the path out as a variadic list can be more convenient in some cases.) 指定したパスにおけるJSONの副オブジェクトを取り出します。 （これは#>演算子と機能的に同じですが、パスをvariadicリストで書き出す方がより便利な場合があります。）

json_extract_path('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}', 'f4', 'f6') → "foo"

json_extract_path_text ( from_json json, VARIADIC path_elems text[] ) → text

jsonb_extract_path_text ( from_json jsonb, VARIADIC path_elems text[] ) → text

Extracts JSON sub-object at the specified path as <type>text</type>. (This is functionally equivalent to the <literal>#&gt;&gt;</literal> operator.) 指定したパスにおけるJSONの副オブジェクトをtextとして取り出します。 （これは機能的には#>>演算子と同じです。）

json_extract_path_text('{"f2":{"f3":1},"f4":{"f5":99,"f6":"foo"}}', 'f4', 'f6') → foo

json_object_keys ( json ) → setof text

jsonb_object_keys ( jsonb ) → setof text

Returns the set of keys in the top-level JSON object. トップレベルのJSONオブジェクト中のキーの集合を返します。

select * from json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}') →

 json_object_keys
------------------
 f1
 f2

json_populate_record ( base anyelement, from_json json ) → anyelement

jsonb_populate_record ( base anyelement, from_json jsonb ) → anyelement

Expands the top-level JSON object to a row having the composite type of the <parameter>base</parameter> argument. The JSON object is scanned for fields whose names match column names of the output row type, and their values are inserted into those columns of the output. (Fields that do not correspond to any output column name are ignored.) In typical use, the value of <parameter>base</parameter> is just <literal>NULL</literal>, which means that any output columns that do not match any object field will be filled with nulls. However, if <parameter>base</parameter> isn't <literal>NULL</literal> then the values it contains will be used for unmatched columns. トップレベルのJSONオブジェクトをbase引数である複合型を持つ行に展開します。 JSONオブジェクトは出力行型の列名と一致するフィールドが検査されます。 （出力列名と関連のないフィールドは無視されます。） 典型的な使い方としては、baseの値が単にNULLで、これはオブジェクトフィールドと一致しない出力列にはNULLがセットされることを意味します。 しかし、baseがNULLでないなら、それが持つ値が一致しない列に使われます。

To convert a JSON value to the SQL type of an output column, the following rules are applied in sequence: JSON値を出力列のSQL型に変換する際に以下のルールが順に適用されます。

While the example below uses a constant JSON value, typical use would be to reference a <type>json</type> or <type>jsonb</type> column laterally from another table in the query's <literal>FROM</literal> clause. Writing <function>json_populate_record</function> in the <literal>FROM</literal> clause is good practice, since all of the extracted columns are available for use without duplicate function calls. これらの関数の例ではJSON定数を使用していますが、典型的な使用法はそのjsonまたはjsonb列をFROM句の別のテーブルから外側に参照することです。 FROM句でjson_populate_recordを書くのは良い練習になります。 すべての取り出された列を重複した関数呼び出しなしに利用できるからです。

create type subrowtype as (d int, e text); create type myrowtype as (a int, b text[], c subrowtype);

select * from json_populate_record(null::myrowtype, '{"a": 1, "b": ["2", "a b"], "c": {"d": 4, "e": "a b c"}, "x": "foo"}') →

 a |   b       |      c
---+-----------+-------------
 1 | {2,"a b"} | (4,"a b c")

jsonb_populate_record_valid ( base anyelement, from_json json ) → boolean

Function for testing <function>jsonb_populate_record</function>. Returns <literal>true</literal> if the input <function>jsonb_populate_record</function> would finish without an error for the given input JSON object; that is, it's valid input, <literal>false</literal> otherwise. jsonb_populate_recordをテストする関数。 与えられた入力JSONオブジェクトに対してjsonb_populate_recordがエラーなしで終了する場合、すなわち有効な入力ならtrueを、そうでない場合はfalseを返します。

create type jsb_char2 as (a char(2));

select jsonb_populate_record_valid(NULL::jsb_char2, '{"a": "aaa"}'); →

 jsonb_populate_record_valid
-----------------------------
 f
(1 row)

select * from jsonb_populate_record(NULL::jsb_char2, '{"a": "aaa"}') q; →

ERROR:  value too long for type character(2)

select jsonb_populate_record_valid(NULL::jsb_char2, '{"a": "aa"}'); →

 jsonb_populate_record_valid
-----------------------------
 t
(1 row)

select * from jsonb_populate_record(NULL::jsb_char2, '{"a": "aa"}') q; →

 a
----
 aa
(1 row)

json_populate_recordset ( base anyelement, from_json json ) → setof anyelement

jsonb_populate_recordset ( base anyelement, from_json jsonb ) → setof anyelement

Expands the top-level JSON array of objects to a set of rows having the composite type of the <parameter>base</parameter> argument. Each element of the JSON array is processed as described above for <function>json[b]_populate_record</function>. トップレベルのJSONオブジェクトをbase引数である複合型を持つ行の集合に展開します。 JSON配列の個々の要素は上のjson[b]_populate_recordで説明したように処理されます。

create type twoints as (a int, b int);

select * from json_populate_recordset(null::twoints, '[{"a":1,"b":2}, {"a":3,"b":4}]') →

 a | b
---+---
 1 | 2
 3 | 4

json_to_record ( json ) → record

jsonb_to_record ( jsonb ) → record

Expands the top-level JSON object to a row having the composite type defined by an <literal>AS</literal> clause. (As with all functions returning <type>record</type>, the calling query must explicitly define the structure of the record with an <literal>AS</literal> clause.) The output record is filled from fields of the JSON object, in the same way as described above for <function>json[b]_populate_record</function>. Since there is no input record value, unmatched columns are always filled with nulls. トップレベルのJSONオブジェクトをAS句で定義した複合型を持つ行に展開します。 （recordを返すすべての関数では、呼び出す問い合わせは明示的にAS句でレコードの構造を定義しなければなりません。） 上のjson[b]_populate_recordで説明した方法で、出力レコードはJSONオブジェクトのフィールドで満たされます。 入力レコード値がないので、一致しない列は常にNULLで満たされます。

create type myrowtype as (a int, b text);

select * from json_to_record('{"a":1,"b":[1,2,3],"c":[1,2,3],"e":"bar","r": {"a": 123, "b": "a b c"}}') as x(a int, b text, c int[], d text, r myrowtype) →

 a |    b    |    c    | d |       r
---+---------+---------+---+---------------
 1 | [1,2,3] | {1,2,3} |   | (123,"a b c")

json_to_recordset ( json ) → setof record

jsonb_to_recordset ( jsonb ) → setof record

Expands the top-level JSON array of objects to a set of rows having the composite type defined by an <literal>AS</literal> clause. (As with all functions returning <type>record</type>, the calling query must explicitly define the structure of the record with an <literal>AS</literal> clause.) Each element of the JSON array is processed as described above for <function>json[b]_populate_record</function>. トップレベルのJSON配列をAS句で定義した複合型を持つ行に展開します。 （recordを返すすべての関数では、呼び出す問い合わせは明示的にAS句でレコードの構造を定義しなければなりません。） 上のjson[b]_populate_recordで説明した方法で、JSON配列の要素は処理されます。

select * from json_to_recordset('[{"a":1,"b":"foo"}, {"a":"2","c":"bar"}]') as x(a int, b text) →

 a |  b
---+-----
 1 | foo
 2 |

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

Returns <parameter>target</parameter> with the item designated by <parameter>path</parameter> replaced by <parameter>new_value</parameter>, or with <parameter>new_value</parameter> added if <parameter>create_if_missing</parameter> is true (which is the default) and the item designated by <parameter>path</parameter> does not exist. All earlier steps in the path must exist, or the <parameter>target</parameter> is returned unchanged. As with the path oriented operators, negative integers that appear in the <parameter>path</parameter> count from the end of JSON arrays. If the last path step is an array index that is out of range, and <parameter>create_if_missing</parameter> is true, the new value is added at the beginning of the array if the index is negative, or at the end of the array if it is positive. pathで指定された要素をnew_valueで置き換えてtargetを返します。 create_if_missingが真なら（デフォルトです）、pathで指定された項目が無い時にnew_valueが追加されます。 パス中のすべての初期のステップは存在しなければならず、さもなければtargetは変わらないままに返却されます。 パスの位置についての演算子については、pathの中にある負の整数はJSON配列の終わりから数えます。 パスの最後のステップが範囲外の配列のインデックスで、create_if_missingが真のときは、インデックスが負なら配列の最初に、正なら配列の最後に新しい値が追加されます。

jsonb_set('[{"f1":1,"f2":null},2,null,3]', '{0,f1}', '[2,3,4]', false) → [{"f1": [2, 3, 4], "f2": null}, 2, null, 3]

jsonb_set('[{"f1":1,"f2":null},2]', '{0,f3}', '[2,3,4]') → [{"f1": 1, "f2": null, "f3": [2, 3, 4]}, 2]

jsonb_set_lax ( target jsonb, path text[], new_value jsonb [, create_if_missing boolean [, null_value_treatment text ]] ) → jsonb

If <parameter>new_value</parameter> is not <literal>NULL</literal>, behaves identically to <literal>jsonb_set</literal>. Otherwise behaves according to the value of <parameter>null_value_treatment</parameter> which must be one of <literal>'raise_exception'</literal>, <literal>'use_json_null'</literal>, <literal>'delete_key'</literal>, or <literal>'return_target'</literal>. The default is <literal>'use_json_null'</literal>. new_valueがNULLでないなら、jsonb_setと同じ振る舞いをします。 そうでなければnull_value_treatmentにしたがいます。 null_value_treatmentは、'raise_exception'、'use_json_null'、'delete_key'、'return_target'のいずれかでなければなりません。 デフォルトは'use_json_null'です。

jsonb_set_lax('[{"f1":1,"f2":null},2,null,3]', '{0,f1}', null) → [{"f1": null, "f2": null}, 2, null, 3]

jsonb_set_lax('[{"f1":99,"f2":null},2]', '{0,f3}', null, true, 'return_target') → [{"f1": 99, "f2": null}, 2]

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

Returns <parameter>target</parameter> with <parameter>new_value</parameter> inserted. If the item designated by the <parameter>path</parameter> is an array element, <parameter>new_value</parameter> will be inserted before that item if <parameter>insert_after</parameter> is false (which is the default), or after it if <parameter>insert_after</parameter> is true. If the item designated by the <parameter>path</parameter> is an object field, <parameter>new_value</parameter> will be inserted only if the object does not already contain that key. All earlier steps in the path must exist, or the <parameter>target</parameter> is returned unchanged. As with the path oriented operators, negative integers that appear in the <parameter>path</parameter> count from the end of JSON arrays. If the last path step is an array index that is out of range, the new value is added at the beginning of the array if the index is negative, or at the end of the array if it is positive. new_valueを挿入してtargetを返します。 pathで指定した項目が配列要素で、insert_afterが偽（デフォルトです）ならばnew_valueはその項目の前に挿入され、insert_afterが真であれば後に挿入されます。 pathで指定した項目がオブジェクトフィールドならば、オブジェクトがすでにそのキーを含んでいない場合にのみnew_valueが挿入されます。 パス中のすべての初期のステップは存在しなければならず、さもなければtargetは変わらないままに返却されます。 pathについての演算子について言うと、path内の負の整数はJSON配列の終わりから数えます。 パスの最後のステップが範囲外の配列のインデックスで、インデックスが負なら配列の最初に、正なら配列の最後に新しい値が追加されます。

jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"') → {"a": [0, "new_value", 1, 2]}

jsonb_insert('{"a": [0,1,2]}', '{a, 1}', '"new_value"', true) → {"a": [0, 1, "new_value", 2]}

json_strip_nulls ( json ) → json

jsonb_strip_nulls ( jsonb ) → jsonb

Deletes all object fields that have null values from the given JSON value, recursively. Null values that are not object fields are untouched. 与えられたJSON値からNULLを持つオブジェクトフィールドをすべて削除します。 オブジェクトフィールドではないNULL値は変わりません。

json_strip_nulls('[{"f1":1, "f2":null}, 2, null, 3]') → [{"f1":1},2,null,3]

jsonb_path_exists ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

Checks whether the JSON path returns any item for the specified JSON value. (This is useful only with SQL-standard JSON path expressions, not <link linkend="functions-sqljson-check-expressions">predicate check expressions</link>, since those always return a value.) If the <parameter>vars</parameter> argument is specified, it must be a JSON object, and its fields provide named values to be substituted into the <type>jsonpath</type> expression. If the <parameter>silent</parameter> argument is specified and is <literal>true</literal>, the function suppresses the same errors as the <literal>@?</literal> and <literal>@@</literal> operators do. JSONパスが指定したJSON値に対して項目を返すかどうかをチェックします。 （これは、述語チェック式ではなく、SQL標準のJSONパス式でのみ有用です。 なぜなら、それらは常に値を返すからです。） varsが指定されるなら、それはJSONオブジェクトでなければならず、そのフィールドはjsonpath式に置き換えられる名前を持つ値を提供します。 silent引数が指定されていてtrueなら、この関数は@?と@@演算子が生成するのと同じエラーを抑止します。

jsonb_path_exists('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}') → t

jsonb_path_match ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

Returns the result of a JSON path predicate check for the specified JSON value. (This is useful only with <link linkend="functions-sqljson-check-expressions">predicate check expressions</link>, not SQL-standard JSON path expressions, since it will either fail or return <literal>NULL</literal> if the path result is not a single boolean value.) The optional <parameter>vars</parameter> and <parameter>silent</parameter> arguments act the same as for <function>jsonb_path_exists</function>. 指定したJSON値のJSONパス述語チェックの結果を返します。 （これは、パス結果が単一のブール値でない場合、失敗するかNULLを返すため、SQL標準のJSONパス述語ではなく、述語チェック式でのみ有用です）。 オプションのvarsとsilent引数は、jsonb_path_existsと同じように動作します。

jsonb_path_match('{"a":[1,2,3,4,5]}', 'exists($.a[*] ? (@ >= $min && @ <= $max))', '{"min":2, "max":4}') → t

jsonb_path_query ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → setof jsonb

Returns all JSON items returned by the JSON path for the specified JSON value. For SQL-standard JSON path expressions it returns the JSON values selected from <parameter>target</parameter>. For <link linkend="functions-sqljson-check-expressions">predicate check expressions</link> it returns the result of the predicate check: <literal>true</literal>, <literal>false</literal>, or <literal>null</literal>. The optional <parameter>vars</parameter> and <parameter>silent</parameter> arguments act the same as for <function>jsonb_path_exists</function>. 指定されたJSON値のJSONパスによって戻されるすべてのJSON項目を戻します。 SQL標準のJSONパス式の場合、targetから選択されたJSON値を返します。 述語チェック式の場合、述語チェックの結果を返します。 結果はtrue、false、nullのいずれかです。 オプションのvarsとsilent引数はjsonb_path_existsと同じように動作します。

select * from jsonb_path_query('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}') →

 jsonb_path_query
------------------
 2
 3
 4

jsonb_path_query_array ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

Returns all JSON items returned by the JSON path for the specified JSON value, as a JSON array. The parameters are the same as for <function>jsonb_path_query</function>. 指定されたJSON値のJSONパスによって返されるすべてのJSON項目を、JSON配列として返します。 パラメータはjsonb_path_queryと同じです。

jsonb_path_query_array('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}') → [2, 3, 4]

jsonb_path_query_first ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

Returns the first JSON item returned by the JSON path for the specified JSON value, or <literal>NULL</literal> if there are no results. The parameters are the same as for <function>jsonb_path_query</function>. 指定されたJSON値のJSONパスによって返される最初のJSON項目を返します。 結果がない場合はNULLです。 パラメータはjsonb_path_queryと同じです。

jsonb_path_query_first('{"a":[1,2,3,4,5]}', '$.a[*] ? (@ >= $min && @ <= $max)', '{"min":2, "max":4}') → 2

jsonb_path_exists_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

jsonb_path_match_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → boolean

jsonb_path_query_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → setof jsonb

jsonb_path_query_array_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

jsonb_path_query_first_tz ( target jsonb, path jsonpath [, vars jsonb [, silent boolean ]] ) → jsonb

These functions act like their counterparts described above without the <literal>_tz</literal> suffix, except that these functions support comparisons of date/time values that require timezone-aware conversions. The example below requires interpretation of the date-only value <literal>2015-08-02</literal> as a timestamp with time zone, so the result depends on the current <xref linkend="guc-timezone"/> setting. Due to this dependency, these functions are marked as stable, which means these functions cannot be used in indexes. Their counterparts are immutable, and so can be used in indexes; but they will throw errors if asked to make such comparisons. これらの関数は、時間帯を考慮する日時値の比較をサポートすることを除いて、上で述べた、_tz接尾を除いた片割れの関数のように動作します。 以下の例では日付のみの値2015-08-02を時間帯付きタイムスタンプとして解釈することが必要で、結果はTimeZone設定に依存します。 この依存性のために、これらの関数は安定(stable)、として印付けされており、インデックスにはこれらの関数は使えないことを意味します。 これらの関数の片割れは不変(immutable)なので、インデックスで使えます。しかし、そうした比較を要求されるとエラーを吐きます。

jsonb_path_exists_tz('["2015-08-01 12:00:00-05"]', '$[*] ? (@.datetime() < "2015-08-02".datetime())') → t

jsonb_pretty ( jsonb ) → text

Converts the given JSON value to pretty-printed, indented text. 与えられたJSON値を整形されたインデント付きテキストに変換します。

jsonb_pretty('[{"f1":1,"f2":null}, 2]') →

[
    {
        "f1": 1,
        "f2": null
    },
    2
]

json_typeof ( json ) → text

jsonb_typeof ( jsonb ) → text

Returns the type of the top-level JSON value as a text string. Possible types are <literal>object</literal>, <literal>array</literal>, <literal>string</literal>, <literal>number</literal>, <literal>boolean</literal>, and <literal>null</literal>. (The <literal>null</literal> result should not be confused with an SQL NULL; see the examples.) トップレベルのJSON値の型をテキスト文字列として返します。 可能な型は次のとおりです。 object、array、string、number、boolean、null。 （nullの結果をSQLのNULLと混同してはいけません。以下の例をご覧ください。）

json_typeof('-123.4') → number

json_typeof('null'::json) → null

json_typeof(NULL::json) IS NULL → t

JSON_EXISTS (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[{ TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ]) → boolean

Examples: 例：

JSON_EXISTS(jsonb '{"key1": [1,2,3]}', 'strict $.key1[*] ? (@ > $x)' PASSING 2 AS x) → t

JSON_EXISTS(jsonb '{"a": [1,2,3]}', 'lax $.a[5]' ERROR ON ERROR) → f

JSON_EXISTS(jsonb '{"a": [1,2,3]}', 'strict $.a[5]' ERROR ON ERROR) →

ERROR:  jsonpath array subscript is out of bounds

JSON_QUERY (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[ RETURNING data_type [ FORMAT JSON [ ENCODING UTF8 ] ] ]
[ { WITHOUT | WITH { CONDITIONAL | [UNCONDITIONAL] } } [ ARRAY ] WRAPPER ]
[ { KEEP | OMIT } QUOTES [ ON SCALAR STRING ] ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT expression } ON EMPTY ]
[ { ERROR | NULL | EMPTY { [ ARRAY ] | OBJECT } | DEFAULT expression } ON ERROR ]) → jsonb

Examples: 例：

JSON_QUERY(jsonb '[1,[2,3],null]', 'lax $[*][$off]' PASSING 1 AS off WITH CONDITIONAL WRAPPER) → 3

JSON_QUERY(jsonb '{"a": "[1, 2]"}', 'lax $.a' OMIT QUOTES) → [1, 2]

JSON_QUERY(jsonb '{"a": "[1, 2]"}', 'lax $.a' RETURNING int[] OMIT QUOTES ERROR ON ERROR) →

ERROR:  malformed array literal: "[1, 2]"
DETAIL:  Missing "]" after array dimensions.

JSON_VALUE (
context_item, path_expression
[ PASSING { value AS varname } [, ...]]
[ RETURNING data_type ]
[ { ERROR | NULL | DEFAULT expression } ON EMPTY ]
[ { ERROR | NULL | DEFAULT expression } ON ERROR ]) → text

Examples: 例：

JSON_VALUE(jsonb '"123.45"', '$' RETURNING float) → 123.45

JSON_VALUE(jsonb '"03:04 2015-02-01"', '$.datetime("HH24:MI YYYY-MM-DD")' RETURNING date) → 2015-02-01

JSON_VALUE(jsonb '[1,2]', 'strict $[$off]' PASSING 1 as off) → 2

JSON_VALUE(jsonb '[1,2]', 'strict $[*]' DEFAULT 9 ON ERROR) → 9