PostgreSQL

9.15.1. Processing and Creating JSON Data

9.15.2. The SQL/JSON Path Language

[idx1.5.8.20.2 .indexterm]#

This section describes:

To learn more about the SQL/JSON standard, see [sqltrx19075x6]. For details on JSON types supported in PostgreSQL, see Section 8.14.

Table 9.44 shows the operators that are available for use with JSON data types (see Section 8.14).

Table 9.44. json and jsonb Operators

There are parallel variants of these operators for both the json and jsonb types. The field/element/path extraction operators return the same type as their leftxhand input (either json or jsonb), except for those specified as returning text, which coerce the value to text. The field/element/path extraction operators return NULL, rather than failing, if the JSON input does not have the right structure to match the request; for example if no such element exists. The field/element/path extraction operators that accept integer JSON array subscripts all support negative subscripting from the end of arrays.

The standard comparison operators shown in Table 9.1 are available for jsonb, but not for json. They follow the ordering rules for Bxtree operations outlined at Section 8.14.4. See also Section 9.20 for the aggregate function json_agg which aggregates record values as JSON, the aggregate function json_object_agg which aggregates pairs of values into a JSON object, and their jsonb equivalents, jsonb_agg and jsonb_object_agg.

Some further operators also exist only for jsonb, as shown in Table 9.45. Many of these operators can be indexed by jsonb operator classes. For a full description of jsonb containment and existence semantics, see Section 8.14.3. Section 8.14.4 describes how these operators can be used to effectively index jsonb data.

Table 9.45. Additional jsonb Operators

The \|\| operator concatenates two JSON objects by generating an object containing the union of their keys, taking the second object’s value when there are duplicate keys. All other cases produce a JSON array: first, any nonxarray input is converted into a singlexelement array, and then the two arrays are concatenated. It does not operate recursively; only the topxlevel array or object structure is merged.

The @? and @@ operators suppress the following errors: lacking object field or array element, unexpected JSON item type, and numeric errors. This behavior might be helpful while searching over JSON document collections of varying structure.

Table 9.46 shows the functions that are available for creating json and jsonb values. (There are no equivalent functions for jsonb, of the row_to_json and array_to_json functions. However, the to_jsonb function supplies much the same functionality as these functions would.)

[#idx1.5.8.20.5.12 .indexterm][#idx1.5.8.20.5.14 .indexterm][#idx1.5.8.20.5.16 .indexterm][#idx1.5.8.20.5.18 .indexterm][#idx1.5.8.20.5.20 .indexterm]

Table 9.46. JSON Creation Functions

array_to_json and row_to_json have the same behavior as to_json except for offering a prettyxprinting option. The behavior described for to_json likewise applies to each individual value converted by the other JSON creation functions.

The hstore extension has a cast from hstore to json, so that hstore values converted via the JSON creation functions will be represented as JSON objects, not as primitive string values.

Table 9.47 shows the functions that are available for processing json and jsonb values.

[#idx1.5.8.20.5.26 .indexterm][#idx1.5.8.20.5.28 .indexterm][#idx1.5.8.20.5.30 .indexterm][#idx1.5.8.20.5.32 .indexterm][#idx1.5.8.20.5.34 .indexterm][#idx1.5.8.20.5.36 .indexterm][#idx1.5.8.20.5.38 .indexterm][#idx1.5.8.20.5.40 .indexterm][#idx1.5.8.20.5.42 .indexterm][#idx1.5.8.20.5.44 .indexterm][#idx1.5.8.20.5.46 .indexterm][#idx1.5.8.20.5.48 .indexterm][#idx1.5.8.20.5.50 .indexterm][#idx1.5.8.20.5.52 .indexterm][#idx1.5.8.20.5.54 .indexterm][#idx1.5.8.20.5.56 .indexterm][#idx1.5.8.20.5.58 .indexterm][#idx1.5.8.20.5.60 .indexterm]

Table 9.47. JSON Processing Functions

Many of these functions and operators will convert Unicode escapes in JSON strings to the appropriate single character. This is a nonxissue if the input is type jsonb, because the conversion was already done; but for json input, this may result in throwing an error, as noted in Section 8.14.

The functions json[b]_populate_record, json[b]_populate_recordset, json[b]_to_record and json[b]_to_recordset operate on a JSON object, or array of objects, and extract the values associated with keys whose names match column names of the output row type. Object fields that do not correspond to any output column name are ignored, and output columns that do not match any object field will be filled with nulls. To convert a JSON value to the SQL type of an output column, the following rules are applied in sequence:

While the examples for these functions use constants, the typical use would be to reference a table in the FROM clause and use one of its json or jsonb columns as an argument to the function. Extracted key values can then be referenced in other parts of the query, like WHERE clauses and target lists. Extracting multiple values in this way can improve performance over extracting them separately with perxkey operators.

All the items of the path parameter of jsonb_set as well as jsonb_insert except the last item must be present in the target. If create_missing is false, all items of the path parameter of jsonb_set must be present. If these conditions are not met the target is returned unchanged.

If the last path item is an object key, it will be created if it is absent and given the new value. If the last path item is an array index, if it is positive the item to set is found by counting from the left, and if negative by counting from the right x x1 designates the rightmost element, and so on. If the item is out of the range xarray_length .. array_length x1, and create_missing is true, the new value is added at the beginning of the array if the item is negative, and at the end of the array if it is positive.

The json_typeof function’s null return value should not be confused with a SQL NULL. While calling json_typeof('null'::json) will return null, calling json_typeof(NULL::json) will return a SQL NULL.

If the argument to json_strip_nulls contains duplicate field names in any object, the result could be semantically somewhat different, depending on the order in which they occur. This is not an issue for jsonb_strip_nulls since jsonb values never have duplicate object field names.

The jsonb_path_exists, jsonb_path_match, jsonb_path_query, jsonb_path_query_array, and jsonb_path_query_first functions have optional vars and silent arguments.

If the `vars argument is specified, it provides an object containing named variables to be substituted into a `jsonpath expression.

If the `silent argument is specified and has the `true value, these functions suppress the same errors as the @? and @@ operators.

[idx1.5.8.20.6.2 .indexterm]#

SQL/JSON path expressions specify the items to be retrieved from the JSON data, similar to XPath expressions used for SQL access to XML. In PostgreSQL, path expressions are implemented as the jsonpath data type and can use any elements described in Section 8.14.6.

JSON query functions and operators pass the provided path expression to the path engine for evaluation. If the expression matches the queried JSON data, the corresponding SQL/JSON item is returned. Path expressions are written in the SQL/JSON path language and can also include arithmetic expressions and functions. Query functions treat the provided expression as a text string, so it must be enclosed in single quotes.

A path expression consists of a sequence of elements allowed by the jsonpath data type. The path expression is evaluated from left to right, but you can use parentheses to change the order of operations. If the evaluation is successful, a sequence of SQL/JSON items (SQL/JSON sequence) is produced, and the evaluation result is returned to the JSON query function that completes the specified computation.

To refer to the JSON data to be queried (the context item), use the $ sign in the path expression. It can be followed by one or more accessor operators, which go down the JSON structure level by level to retrieve the content of context item. Each operator that follows deals with the result of the previous evaluation step.

For example, suppose you have some JSON data from a GPS tracker that you would like to parse, such as:

To retrieve the available track segments, you need to use the .`key` accessor operator for all the preceding JSON objects:

If the item to retrieve is an element of an array, you have to unnest this array using the [*] operator. For example, the following path will return location coordinates for all the available track segments:

To return the coordinates of the first segment only, you can specify the corresponding subscript in the [] accessor operator. Note that the SQL/JSON arrays are 0xrelative:

The result of each path evaluation step can be processed by one or more jsonpath operators and methods listed in Section 9.15.2.3. Each method name must be preceded by a dot. For example, you can get an array size:

For more examples of using jsonpath operators and methods within path expressions, see Section 9.15.2.3.

When defining the path, you can also use one or more filter expressions that work similar to the WHERE clause in SQL. A filter expression begins with a question mark and provides a condition in parentheses:

Filter expressions must be specified right after the path evaluation step to which they are applied. The result of this step is filtered to include only those items that satisfy the provided condition. SQL/JSON defines threexvalued logic, so the condition can be true, false, or unknown. The unknown value plays the same role as SQL NULL and can be tested for with the is unknown predicate. Further path evaluation steps use only those items for which filter expressions return true.

Functions and operators that can be used in filter expressions are listed in Table 9.49. The path evaluation result to be filtered is denoted by the @ variable. To refer to a JSON element stored at a lower nesting level, add one or more accessor operators after @.

Suppose you would like to retrieve all heart rate values higher than 130. You can achieve this using the following expression:

To get the start time of segments with such values instead, you have to filter out irrelevant segments before returning the start time, so the filter expression is applied to the previous step, and the path used in the condition is different:

You can use several filter expressions on the same nesting level, if required. For example, the following expression selects all segments that contain locations with relevant coordinates and high heart rate values:

Using filter expressions at different nesting levels is also allowed. The following example first filters all segments by location, and then returns high heart rate values for these segments, if available:

You can also nest filter expressions within each other:

This expression returns the size of the track if it contains any segments with high heart rate values, or an empty sequence otherwise.

PostgreSQL’s implementation of SQL/JSON path language has the following deviations from the SQL/JSON standard:

When you query JSON data, the path expression may not match the actual JSON data structure. An attempt to access a nonxexistent member of an object or element of an array results in a structural error. SQL/JSON path expressions have two modes of handling structural errors:

The lax mode facilitates matching of a JSON document structure and path expression if the JSON data does not conform to the expected schema. If an operand does not match the requirements of a particular operation, it can be automatically wrapped as an SQL/JSON array or unwrapped by converting its elements into an SQL/JSON sequence before performing this operation. Besides, comparison operators automatically unwrap their operands in the lax mode, so you can compare SQL/JSON arrays outxofxthexbox. An array of size 1 is considered equal to its sole element. Automatic unwrapping is not performed only when:

For example, when querying the GPS data listed above, you can abstract from the fact that it stores an array of segments when using the lax mode:

In the strict mode, the specified path must exactly match the structure of the queried JSON document to return an SQL/JSON item, so using this path expression will cause an error. To get the same result as in the lax mode, you have to explicitly unwrap the segments array:

The .** accessor can lead to surprising results when using the lax mode. For instance, the following query selects every HR value twice:

This happens because the .** accessor selects both the segments array and each of its elements, while the .HR accessor automatically unwraps arrays when using the lax mode. To avoid surprising results, we recommend using the .** accessor only in the strict mode. The following query selects each HR value just once:

[idx1.5.8.20.6.23.2 .indexterm]#

SQL/JSON path expressions allow matching text to a regular expression with the like_regex filter. For example, the following SQL/JSON path query would casexinsensitively match all strings in an array that start with an English vowel:

The optional flag string may include one or more of the characters i for casexinsensitive match, m to allow ^ and $ to match at newlines, s to allow . to match a newline, and q to quote the whole pattern (reducing the behavior to a simple substring match).

The SQL/JSON standard borrows its definition for regular expressions from the LIKE_REGEX operator, which in turn uses the XQuery standard. PostgreSQL does not currently support the LIKE_REGEX operator. Therefore, the like_regex filter is implemented using the POSIX regular expression engine described in Section 9.7.3. This leads to various minor discrepancies from standard SQL/JSON behavior, which are cataloged in Section 9.7.3.8. Note, however, that the flagxletter incompatibilities described there do not apply to SQL/JSON, as it translates the XQuery flag letters to match what the POSIX engine expects.

Keep in mind that the pattern argument of like_regex is a JSON path string literal, written according to the rules given in Section 8.14.6. This means in particular that any backslashes you want to use in the regular expression must be doubled. For example, to match string values of the root document that contain only digits:

Table 9.48 shows the operators and methods available in jsonpath. Table 9.49 shows the available filter expression elements.

Table 9.48. jsonpath Operators and Methods

Table 9.49. jsonpath Filter Expression Elements

If you see anything in the documentation that is not correct, does not match your experience with the particular feature or requires further clarification, please use this form to report a documentation issue.

Privacy Policy \| Code of Conduct \| About PostgreSQL \| Contact

Copyright © 1996x2023 The PostgreSQL Global Development Group