Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb '{"a": 12}' @? '$';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 12}' @? '1';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 12}' @? '$.a.b';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 12}' @? '$.b';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 12}' @? '$.a + 2';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 12}' @? '$.b + 2';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"a": 12}}' @? '$.a.a';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"a": 12}}' @? '$.*.a';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"b": {"a": 12}}' @? '$.*.a';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"b": {"a": 12}}' @? '$.*.b';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"b": {"a": 12}}' @? 'strict $.*.b';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{}' @? '$.*';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 1}' @? '$.*';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? 'lax $.**{1}';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? 'lax $.**{2}';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? 'lax $.**{3}';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[]' @? '$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? '$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? '$[1]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? 'strict $[1]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1]', 'strict $[1]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is out of bounds
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1]', 'strict $[1]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? 'lax $[10000000000000000]';
|
2019-03-16 10:21:19 +01:00
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb '[1]' @? 'strict $[10000000000000000]';
|
2019-03-16 10:21:19 +01:00
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1]', 'lax $[10000000000000000]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is out of integer range
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1]', 'strict $[10000000000000000]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is out of integer range
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb '[1]' @? '$[0]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? '$[0.3]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? '$[0.5]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? '$[0.9]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? '$[1.2]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1]' @? 'strict $[1.2]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": [1,2,3], "b": [3,4,5]}' @? '$ ? (@.a[*] > @.b[*])';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": [1,2,3], "b": [3,4,5]}' @? '$ ? (@.a[*] >= @.b[*])';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": [1,2,3], "b": [3,4,"5"]}' @? '$ ? (@.a[*] >= @.b[*])';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": [1,2,3], "b": [3,4,"5"]}' @? 'strict $ ? (@.a[*] >= @.b[*])';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": [1,2,3], "b": [3,4,null]}' @? '$ ? (@.a[*] >= @.b[*])';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '1' @? '$ ? ((@ == "1") is unknown)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '1' @? '$ ? ((@ == 1) is unknown)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[{"a": 1}, {"a": 2}]' @? '$[0 to 1] ? (@.a > 1)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_exists('[{"a": 1}, {"a": 2}, 3]', 'lax $[*].a', silent => false);
|
|
|
|
jsonb_path_exists
|
|
|
|
-------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_exists('[{"a": 1}, {"a": 2}, 3]', 'lax $[*].a', silent => true);
|
|
|
|
jsonb_path_exists
|
|
|
|
-------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_exists('[{"a": 1}, {"a": 2}, 3]', 'strict $[*].a', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath member accessor can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_exists('[{"a": 1}, {"a": 2}, 3]', 'strict $[*].a', silent => true);
|
|
|
|
jsonb_path_exists
|
|
|
|
-------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'lax $.a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'strict $.a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath member accessor can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('1', 'strict $.*');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath wildcard member accessor can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('1', 'strict $.a', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'strict $.*', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'lax $.a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'strict $.a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath member accessor can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[]', 'strict $.a', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{}', 'lax $.a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{}', 'strict $.a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: JSON object does not contain key "a"
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('{}', 'strict $.a', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'strict $[1]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array accessor can only be applied to an array
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('1', 'strict $[*]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath wildcard array accessor can only be applied to an array
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[]', 'strict $[1]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is out of bounds
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[]', 'strict $["a"]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is not a single numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('1', 'strict $[1]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'strict $[*]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'strict $[1]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'strict $["a"]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 12, "b": {"a": 13}}', '$.a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
12
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 12, "b": {"a": 13}}', '$.b');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 13}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 12, "b": {"a": 13}}', '$.*');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
12
|
|
|
|
{"a": 13}
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 12, "b": {"a": 13}}', 'lax $.*.a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[*].a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[*].*');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
14
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[0].a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[1].a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[2].a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[0,1].a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[0 to 10].a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}]', 'lax $[0 to 10 / 0].a');
|
|
|
|
ERROR: division by zero
|
|
|
|
select jsonb_path_query('[12, {"a": 13}, {"b": 14}, "ccc", true]', '$[2.5 - 1 to $.size() - 2]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 13}
|
|
|
|
{"b": 14}
|
|
|
|
"ccc"
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'lax $[0]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('1', 'lax $[*]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1]', 'lax $[0]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1]', 'lax $[*]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,2,3]', 'lax $[*]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,2,3]', 'strict $[*].a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath member accessor can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1,2,3]', 'strict $[*].a', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', '$[last]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', '$[last ? (exists(last))]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'strict $[last]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is out of bounds
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[]', 'strict $[last]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1]', '$[last]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,2,3]', '$[last]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
3
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,2,3]', '$[last - 1]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
2
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,2,3]', '$[last ? (@.type() == "number")]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
3
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,2,3]', '$[last ? (@.type() == "string")]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath array subscript is not a single numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1,2,3]', '$[last ? (@.type() == "string")]', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('{"a": 10}', '$');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 10}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)');
|
2019-05-17 02:40:02 +02:00
|
|
|
ERROR: could not find jsonpath variable "value"
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select * from jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '1');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: "vars" argument is not an object
|
|
|
|
DETAIL: Jsonpath parameters should be encoded as key-value pairs of "vars" object.
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select * from jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '[{"value" : 13}]');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: "vars" argument is not an object
|
|
|
|
DETAIL: Jsonpath parameters should be encoded as key-value pairs of "vars" object.
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select * from jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{"value" : 13}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 10}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('{"a": 10}', '$ ? (@.a < $value)', '{"value" : 8}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('{"a": 10}', '$.a ? (@ < $value)', '{"value" : 13}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
10
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[10,11,12,13,14,15]', '$[*] ? (@ < $value)', '{"value" : 13}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
10
|
|
|
|
11
|
|
|
|
12
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[10,11,12,13,14,15]', '$[0,1] ? (@ < $x.value)', '{"x": {"value" : 13}}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
10
|
|
|
|
11
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[10,11,12,13,14,15]', '$[0 to 2] ? (@ < $value)', '{"value" : 15}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
10
|
|
|
|
11
|
|
|
|
12
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[1,"1",2,"2",null]', '$[*] ? (@ == "1")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"1"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[1,"1",2,"2",null]', '$[*] ? (@ == $value)', '{"value" : "1"}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"1"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[1,"1",2,"2",null]', '$[*] ? (@ == $value)', '{"value" : null}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
null
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[1, "2", null]', '$[*] ? (@ != null)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
"2"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[1, "2", null]', '$[*] ? (@ == null)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
null
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('{}', '$ ? (@ == @)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select * from jsonb_path_query('[]', 'strict $ ? (@ == @)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": {"b": 1}}
|
|
|
|
{"b": 1}
|
|
|
|
1
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{0}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": {"b": 1}}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{0 to last}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": {"b": 1}}
|
|
|
|
{"b": 1}
|
|
|
|
1
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{1}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"b": 1}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{1 to last}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"b": 1}
|
|
|
|
1
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{2}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{2 to last}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{3 to last}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{last}');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{0}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{1}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{0 to last}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{1 to last}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"b": 1}}', 'lax $.**{1 to 2}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**{0}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**{1}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**{0 to last}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**{1 to last}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**{1 to 2}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": {"c": {"b": 1}}}', 'lax $.**{2 to 3}.b ? (@ > 0)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? '$.**.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? '$.**{0}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? '$.**{1}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? '$.**{0 to last}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? '$.**{1 to last}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"b": 1}}' @? '$.**{1 to 2}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**{0}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**{1}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**{0 to last}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**{1 to last}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**{1 to 2}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": {"c": {"b": 1}}}' @? '$.**{2 to 3}.b ? ( @ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": {"x": 2}}', '$.g ? (exists (@.x))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"x": 2}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": {"x": 2}}', '$.g ? (exists (@.y))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": {"x": 2}}', '$.g ? (exists (@.x ? (@ >= 2) ))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"x": 2}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'lax $.g ? (exists (@.x))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"x": 2}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'lax $.g ? (exists (@.x + "3"))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'lax $.g ? ((exists (@.x + "3")) is unknown)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"x": 2}
|
|
|
|
{"y": 3}
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'strict $.g[*] ? (exists (@.x))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"x": 2}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'strict $.g[*] ? ((exists (@.x)) is unknown)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"y": 3}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'strict $.g ? (exists (@[*].x))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"g": [{"x": 2}, {"y": 3}]}', 'strict $.g ? ((exists (@[*].x)) is unknown)');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------
|
|
|
|
[{"x": 2}, {"y": 3}]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
--test ternary logic
|
|
|
|
select
|
|
|
|
x, y,
|
|
|
|
jsonb_path_query(
|
|
|
|
'[true, false, null]',
|
|
|
|
'$[*] ? (@ == true && ($x == true && $y == true) ||
|
|
|
|
@ == false && !($x == true && $y == true) ||
|
|
|
|
@ == null && ($x == true && $y == true) is unknown)',
|
|
|
|
jsonb_build_object('x', x, 'y', y)
|
|
|
|
) as "x && y"
|
|
|
|
from
|
|
|
|
(values (jsonb 'true'), ('false'), ('"null"')) x(x),
|
|
|
|
(values (jsonb 'true'), ('false'), ('"null"')) y(y);
|
|
|
|
x | y | x && y
|
|
|
|
--------+--------+--------
|
|
|
|
true | true | true
|
|
|
|
true | false | false
|
|
|
|
true | "null" | null
|
|
|
|
false | true | false
|
|
|
|
false | false | false
|
|
|
|
false | "null" | false
|
|
|
|
"null" | true | null
|
|
|
|
"null" | false | false
|
|
|
|
"null" | "null" | null
|
|
|
|
(9 rows)
|
|
|
|
|
|
|
|
select
|
|
|
|
x, y,
|
|
|
|
jsonb_path_query(
|
|
|
|
'[true, false, null]',
|
|
|
|
'$[*] ? (@ == true && ($x == true || $y == true) ||
|
|
|
|
@ == false && !($x == true || $y == true) ||
|
|
|
|
@ == null && ($x == true || $y == true) is unknown)',
|
|
|
|
jsonb_build_object('x', x, 'y', y)
|
|
|
|
) as "x || y"
|
|
|
|
from
|
|
|
|
(values (jsonb 'true'), ('false'), ('"null"')) x(x),
|
|
|
|
(values (jsonb 'true'), ('false'), ('"null"')) y(y);
|
|
|
|
x | y | x || y
|
|
|
|
--------+--------+--------
|
|
|
|
true | true | true
|
|
|
|
true | false | true
|
|
|
|
true | "null" | true
|
|
|
|
false | true | true
|
|
|
|
false | false | false
|
|
|
|
false | "null" | null
|
|
|
|
"null" | true | true
|
|
|
|
"null" | false | null
|
|
|
|
"null" | "null" | null
|
|
|
|
(9 rows)
|
|
|
|
|
|
|
|
select jsonb '{"a": 1, "b":1}' @? '$ ? (@.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 1, "b":1}}' @? '$ ? (@.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 1, "b":1}}' @? '$.c ? (@.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 1, "b":1}}' @? '$.c ? ($.c.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 1, "b":1}}' @? '$.* ? (@.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 1, "b":1}' @? '$.** ? (@.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 1, "b":1}}' @? '$.** ? (@.a == @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"c": {"a": 2, "b":1}}', '$.** ? (@.a == 1 + 1)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 2, "b": 1}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"c": {"a": 2, "b":1}}', '$.** ? (@.a == (1 + 1))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 2, "b": 1}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"c": {"a": 2, "b":1}}', '$.** ? (@.a == @.b + 1)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 2, "b": 1}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"c": {"a": 2, "b":1}}', '$.** ? (@.a == (@.b + 1))');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 2, "b": 1}
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": -1, "b":1}}' @? '$.** ? (@.a == - 1)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": -1, "b":1}}' @? '$.** ? (@.a == -1)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": -1, "b":1}}' @? '$.** ? (@.a == -@.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": -1, "b":1}}' @? '$.** ? (@.a == - @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 0, "b":1}}' @? '$.** ? (@.a == 1 - @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 2, "b":1}}' @? '$.** ? (@.a == 1 - - @.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"c": {"a": 0, "b":1}}' @? '$.** ? (@.a == 1 - +@.b)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,2,3]' @? '$ ? (+@[*] > +2)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,2,3]' @? '$ ? (+@[*] > +3)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,2,3]' @? '$ ? (-@[*] < -2)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,2,3]' @? '$ ? (-@[*] < -3)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '1' @? '$ ? ($ > 0)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- arithmetic errors
|
|
|
|
select jsonb_path_query('[1,2,0,3]', '$[*] ? (2 / @ > 0)');
|
2019-03-16 10:21:19 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
(3 rows)
|
|
|
|
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1,2,0,3]', '$[*] ? ((2 / @ > 0) is unknown)');
|
2019-03-16 10:21:19 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
0
|
|
|
|
(1 row)
|
|
|
|
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('0', '1 / $');
|
|
|
|
ERROR: division by zero
|
|
|
|
select jsonb_path_query('0', '1 / $ + 2');
|
|
|
|
ERROR: division by zero
|
|
|
|
select jsonb_path_query('0', '-(3 + 1 % $)');
|
|
|
|
ERROR: division by zero
|
|
|
|
select jsonb_path_query('1', '$ + "2"');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: right operand of jsonpath operator + is not a single numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1, 2]', '3 * $');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: right operand of jsonpath operator * is not a single numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('"a"', '-$');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: operand of unary jsonpath operator - is not a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1,"2",3]', '+$');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: operand of unary jsonpath operator + is not a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('1', '$ + "2"', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1, 2]', '3 * $', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('"a"', '-$', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,"2",3]', '+$', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '["1",2,0,3]' @? '-$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,"2",0,3]' @? '-$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '["1",2,0,3]' @? 'strict -$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,"2",0,3]' @? 'strict -$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
-- unwrapping of operator arguments in lax mode
|
|
|
|
select jsonb_path_query('{"a": [2]}', 'lax $.a * 3');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
6
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": [2]}', 'lax $.a + 3');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
5
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": [2, 3, 4]}', 'lax -$.a');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
-2
|
|
|
|
-3
|
|
|
|
-4
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
-- should fail
|
|
|
|
select jsonb_path_query('{"a": [1, 2]}', 'lax $.a * 3');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: left operand of jsonpath operator * is not a single numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('{"a": [1, 2]}', 'lax $.a * 3', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
-- extension: boolean expressions
|
|
|
|
select jsonb_path_query('2', '$ > 1');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
true
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('2', '$ <= 1');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
false
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('2', '$ == "2"');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
null
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '2' @? '$ == "2"';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '2' @@ '$ > 1';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '2' @@ '$ <= 1';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '2' @@ '$ == "2"';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '2' @@ '1';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{}' @@ '$';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[]' @@ '$';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[1,2,3]' @@ '$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '[]' @@ '$[*]';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_match('[[1, true], [2, false]]', 'strict $[*] ? (@[0] > $x) [1]', '{"x": 1}');
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_match('[[1, true], [2, false]]', 'strict $[*] ? (@[0] < $x) [1]', '{"x": 2}');
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_match('[{"a": 1}, {"a": 2}, 3]', 'lax exists($[*].a)', silent => false);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_match('[{"a": 1}, {"a": 2}, 3]', 'lax exists($[*].a)', silent => true);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_match('[{"a": 1}, {"a": 2}, 3]', 'strict exists($[*].a)', silent => false);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_match('[{"a": 1}, {"a": 2}, 3]', 'strict exists($[*].a)', silent => true);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null,1,true,"a",[],{}]', '$.type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"array"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null,1,true,"a",[],{}]', 'lax $.type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"array"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null,1,true,"a",[],{}]', '$[*].type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"null"
|
|
|
|
"number"
|
|
|
|
"boolean"
|
|
|
|
"string"
|
|
|
|
"array"
|
|
|
|
"object"
|
|
|
|
(6 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('null', 'null.type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"null"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('null', 'true.type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"boolean"
|
|
|
|
(1 row)
|
|
|
|
|
2019-03-25 13:43:56 +01:00
|
|
|
select jsonb_path_query('null', '(123).type()');
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"number"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('null', '"123".type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"string"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 2}', '($.a - 5).abs() + 10');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
13
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 2.5}', '-($.a * $.a).floor() % 4.3');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
-1.7
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1, 2, 3]', '($[*] > 2) ? (@ == true)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
true
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1, 2, 3]', '($[*] > 3).type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"boolean"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1, 2, 3]', '($[*].a > 3).type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"boolean"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1, 2, 3]', 'strict ($[*].a > 3).type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"null"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,null,true,"11",[],[1],[1,2,3],{},{"a":1,"b":2}]', 'strict $[*].size()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .size() can only be applied to an array
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[1,null,true,"11",[],[1],[1,2,3],{},{"a":1,"b":2}]', 'strict $[*].size()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[1,null,true,"11",[],[1],[1,2,3],{},{"a":1,"b":2}]', 'lax $[*].size()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1
|
|
|
|
1
|
|
|
|
1
|
|
|
|
1
|
|
|
|
0
|
|
|
|
1
|
|
|
|
3
|
|
|
|
1
|
|
|
|
1
|
|
|
|
(9 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[0, 1, -2, -3.4, 5.6]', '$[*].abs()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
0
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3.4
|
|
|
|
5.6
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[0, 1, -2, -3.4, 5.6]', '$[*].floor()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
0
|
|
|
|
1
|
|
|
|
-2
|
|
|
|
-4
|
|
|
|
5
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[0, 1, -2, -3.4, 5.6]', '$[*].ceiling()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
0
|
|
|
|
1
|
|
|
|
-2
|
|
|
|
-3
|
|
|
|
6
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[0, 1, -2, -3.4, 5.6]', '$[*].ceiling().abs()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
0
|
|
|
|
1
|
|
|
|
2
|
|
|
|
3
|
|
|
|
6
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[0, 1, -2, -3.4, 5.6]', '$[*].ceiling().abs().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"number"
|
|
|
|
"number"
|
|
|
|
"number"
|
|
|
|
"number"
|
|
|
|
"number"
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[{},1]', '$[*].keyvalue()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .keyvalue() can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[{},1]', '$[*].keyvalue()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{}', '$.keyvalue()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{"a": 1, "b": [1, 2], "c": {"a": "bbb"}}', '$.keyvalue()');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------------------------
|
|
|
|
{"id": 0, "key": "a", "value": 1}
|
|
|
|
{"id": 0, "key": "b", "value": [1, 2]}
|
|
|
|
{"id": 0, "key": "c", "value": {"a": "bbb"}}
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[{"a": 1, "b": [1, 2]}, {"c": {"a": "bbb"}}]', '$[*].keyvalue()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------------------------
|
|
|
|
{"id": 12, "key": "a", "value": 1}
|
|
|
|
{"id": 12, "key": "b", "value": [1, 2]}
|
|
|
|
{"id": 72, "key": "c", "value": {"a": "bbb"}}
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[{"a": 1, "b": [1, 2]}, {"c": {"a": "bbb"}}]', 'strict $.keyvalue()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .keyvalue() can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[{"a": 1, "b": [1, 2]}, {"c": {"a": "bbb"}}]', 'lax $.keyvalue()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------------------------
|
|
|
|
{"id": 12, "key": "a", "value": 1}
|
|
|
|
{"id": 12, "key": "b", "value": [1, 2]}
|
|
|
|
{"id": 72, "key": "c", "value": {"a": "bbb"}}
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[{"a": 1, "b": [1, 2]}, {"c": {"a": "bbb"}}]', 'strict $.keyvalue().a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .keyvalue() can only be applied to an object
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb '{"a": 1, "b": [1, 2]}' @? 'lax $.keyvalue()';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb '{"a": 1, "b": [1, 2]}' @? 'lax $.keyvalue().key';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('null', '$.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a string or numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('true', '$.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a string or numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('null', '$.double()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('true', '$.double()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', '$.double()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'strict $.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a string or numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('{}', '$.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a string or numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('[]', 'strict $.double()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{}', '$.double()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('1.23', '$.double()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1.23
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"1.23"', '$.double()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
1.23
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"1.23aaa"', '$.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('"nan"', '$.double()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"NaN"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"NaN"', '$.double()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"NaN"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"inf"', '$.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('"-inf"', '$.double()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .double() can only be applied to a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('"inf"', '$.double()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('"-inf"', '$.double()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('{}', '$.abs()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .abs() can only be applied to a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('true', '$.floor()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .floor() can only be applied to a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('"1.2"', '$.ceiling()');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: jsonpath item method .ceiling() can only be applied to a numeric value
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
select jsonb_path_query('{}', '$.abs()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('true', '$.floor()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('"1.2"', '$.ceiling()', silent => true);
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('["", "a", "abc", "abcabc"]', '$[*] ? (@ starts with "abc")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"abc"
|
|
|
|
"abcabc"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('["", "a", "abc", "abcabc"]', 'strict $ ? (@[*] starts with "abc")');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
["", "a", "abc", "abcabc"]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('["", "a", "abd", "abdabc"]', 'strict $ ? (@[*] starts with "abc")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('["abc", "abcabc", null, 1]', 'strict $ ? (@[*] starts with "abc")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('["abc", "abcabc", null, 1]', 'strict $ ? ((@[*] starts with "abc") is unknown)');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
["abc", "abcabc", null, 1]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[[null, 1, "abc", "abcabc"]]', 'lax $ ? (@[*] starts with "abc")');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
[null, 1, "abc", "abcabc"]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[[null, 1, "abd", "abdabc"]]', 'lax $ ? ((@[*] starts with "abc") is unknown)');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
[null, 1, "abd", "abdabc"]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null, 1, "abd", "abdabc"]', 'lax $[*] ? ((@ starts with "abc") is unknown)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
null
|
|
|
|
1
|
|
|
|
(2 rows)
|
|
|
|
|
Fix bogus handling of XQuery regex option flags.
The SQL spec defers to XQuery to define what the option flags are
for LIKE_REGEX patterns. XQuery says that:
* 's' allows the dot character to match newlines, which by
default it will not;
* 'm' allows ^ and $ to match at newlines, not only at the
start/end of the whole string.
Thus, these are *not* inverses as they are for the similarly-named
POSIX options, and neither one corresponds to the POSIX 'n' option.
Fortunately, Spencer's library does expose these two behaviors as
separately twiddlable flags, so we just have to fix the mapping from
JSP flag bits to REG flag bits. I also chose to rename the symbol
for 's' to DOTALL, to make it clearer that it's not the inverse
of MLINE.
Also, XQuery says that if the 'q' flag "is used together with the m, s,
or x flag, that flag has no effect". I read this as saying that 'q'
overrides the other flags; whoever wrote our code seems to have read
it backwards.
Lastly, while XQuery's 'x' flag is related to what Spencer's code
does for REG_EXPANDED, it's not the same or a subset. It seems best
to treat XQuery's 'x' as unimplemented for now. Maybe later we can
expand our regex code to offer 'x'-style parsing as a separate option.
While at it, refactor the jsonpath code so that (a) there's only
one copy of the flag transformation logic not two, and (b) the
processing of flags is independent of the order in which the flags
are written.
We need some documentation updates to go with this, but I'll
tackle that separately.
Back-patch to v12 where this code originated.
Discussion: https://postgr.es/m/CAPpHfdvDci4iqNF9fhRkTqhe-5_8HmzeLt56drH%2B_Rv2rNRqfg@mail.gmail.com
Reference: https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/#flags
2019-09-17 21:39:51 +02:00
|
|
|
select jsonb_path_query('[null, 1, "abc", "abd", "aBdC", "abdacb", "babc", "adc\nabc", "ab\nadc"]', 'lax $[*] ? (@ like_regex "^ab.*c")');
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"abc"
|
|
|
|
"abdacb"
|
|
|
|
(2 rows)
|
|
|
|
|
Fix bogus handling of XQuery regex option flags.
The SQL spec defers to XQuery to define what the option flags are
for LIKE_REGEX patterns. XQuery says that:
* 's' allows the dot character to match newlines, which by
default it will not;
* 'm' allows ^ and $ to match at newlines, not only at the
start/end of the whole string.
Thus, these are *not* inverses as they are for the similarly-named
POSIX options, and neither one corresponds to the POSIX 'n' option.
Fortunately, Spencer's library does expose these two behaviors as
separately twiddlable flags, so we just have to fix the mapping from
JSP flag bits to REG flag bits. I also chose to rename the symbol
for 's' to DOTALL, to make it clearer that it's not the inverse
of MLINE.
Also, XQuery says that if the 'q' flag "is used together with the m, s,
or x flag, that flag has no effect". I read this as saying that 'q'
overrides the other flags; whoever wrote our code seems to have read
it backwards.
Lastly, while XQuery's 'x' flag is related to what Spencer's code
does for REG_EXPANDED, it's not the same or a subset. It seems best
to treat XQuery's 'x' as unimplemented for now. Maybe later we can
expand our regex code to offer 'x'-style parsing as a separate option.
While at it, refactor the jsonpath code so that (a) there's only
one copy of the flag transformation logic not two, and (b) the
processing of flags is independent of the order in which the flags
are written.
We need some documentation updates to go with this, but I'll
tackle that separately.
Back-patch to v12 where this code originated.
Discussion: https://postgr.es/m/CAPpHfdvDci4iqNF9fhRkTqhe-5_8HmzeLt56drH%2B_Rv2rNRqfg@mail.gmail.com
Reference: https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/#flags
2019-09-17 21:39:51 +02:00
|
|
|
select jsonb_path_query('[null, 1, "abc", "abd", "aBdC", "abdacb", "babc", "adc\nabc", "ab\nadc"]', 'lax $[*] ? (@ like_regex "^ab.*c" flag "i")');
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"abc"
|
|
|
|
"aBdC"
|
|
|
|
"abdacb"
|
|
|
|
(3 rows)
|
|
|
|
|
Fix bogus handling of XQuery regex option flags.
The SQL spec defers to XQuery to define what the option flags are
for LIKE_REGEX patterns. XQuery says that:
* 's' allows the dot character to match newlines, which by
default it will not;
* 'm' allows ^ and $ to match at newlines, not only at the
start/end of the whole string.
Thus, these are *not* inverses as they are for the similarly-named
POSIX options, and neither one corresponds to the POSIX 'n' option.
Fortunately, Spencer's library does expose these two behaviors as
separately twiddlable flags, so we just have to fix the mapping from
JSP flag bits to REG flag bits. I also chose to rename the symbol
for 's' to DOTALL, to make it clearer that it's not the inverse
of MLINE.
Also, XQuery says that if the 'q' flag "is used together with the m, s,
or x flag, that flag has no effect". I read this as saying that 'q'
overrides the other flags; whoever wrote our code seems to have read
it backwards.
Lastly, while XQuery's 'x' flag is related to what Spencer's code
does for REG_EXPANDED, it's not the same or a subset. It seems best
to treat XQuery's 'x' as unimplemented for now. Maybe later we can
expand our regex code to offer 'x'-style parsing as a separate option.
While at it, refactor the jsonpath code so that (a) there's only
one copy of the flag transformation logic not two, and (b) the
processing of flags is independent of the order in which the flags
are written.
We need some documentation updates to go with this, but I'll
tackle that separately.
Back-patch to v12 where this code originated.
Discussion: https://postgr.es/m/CAPpHfdvDci4iqNF9fhRkTqhe-5_8HmzeLt56drH%2B_Rv2rNRqfg@mail.gmail.com
Reference: https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/#flags
2019-09-17 21:39:51 +02:00
|
|
|
select jsonb_path_query('[null, 1, "abc", "abd", "aBdC", "abdacb", "babc", "adc\nabc", "ab\nadc"]', 'lax $[*] ? (@ like_regex "^ab.*c" flag "m")');
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"abc"
|
|
|
|
"abdacb"
|
|
|
|
"adc\nabc"
|
|
|
|
(3 rows)
|
|
|
|
|
Fix bogus handling of XQuery regex option flags.
The SQL spec defers to XQuery to define what the option flags are
for LIKE_REGEX patterns. XQuery says that:
* 's' allows the dot character to match newlines, which by
default it will not;
* 'm' allows ^ and $ to match at newlines, not only at the
start/end of the whole string.
Thus, these are *not* inverses as they are for the similarly-named
POSIX options, and neither one corresponds to the POSIX 'n' option.
Fortunately, Spencer's library does expose these two behaviors as
separately twiddlable flags, so we just have to fix the mapping from
JSP flag bits to REG flag bits. I also chose to rename the symbol
for 's' to DOTALL, to make it clearer that it's not the inverse
of MLINE.
Also, XQuery says that if the 'q' flag "is used together with the m, s,
or x flag, that flag has no effect". I read this as saying that 'q'
overrides the other flags; whoever wrote our code seems to have read
it backwards.
Lastly, while XQuery's 'x' flag is related to what Spencer's code
does for REG_EXPANDED, it's not the same or a subset. It seems best
to treat XQuery's 'x' as unimplemented for now. Maybe later we can
expand our regex code to offer 'x'-style parsing as a separate option.
While at it, refactor the jsonpath code so that (a) there's only
one copy of the flag transformation logic not two, and (b) the
processing of flags is independent of the order in which the flags
are written.
We need some documentation updates to go with this, but I'll
tackle that separately.
Back-patch to v12 where this code originated.
Discussion: https://postgr.es/m/CAPpHfdvDci4iqNF9fhRkTqhe-5_8HmzeLt56drH%2B_Rv2rNRqfg@mail.gmail.com
Reference: https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/#flags
2019-09-17 21:39:51 +02:00
|
|
|
select jsonb_path_query('[null, 1, "abc", "abd", "aBdC", "abdacb", "babc", "adc\nabc", "ab\nadc"]', 'lax $[*] ? (@ like_regex "^ab.*c" flag "s")');
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"abc"
|
|
|
|
"abdacb"
|
Fix bogus handling of XQuery regex option flags.
The SQL spec defers to XQuery to define what the option flags are
for LIKE_REGEX patterns. XQuery says that:
* 's' allows the dot character to match newlines, which by
default it will not;
* 'm' allows ^ and $ to match at newlines, not only at the
start/end of the whole string.
Thus, these are *not* inverses as they are for the similarly-named
POSIX options, and neither one corresponds to the POSIX 'n' option.
Fortunately, Spencer's library does expose these two behaviors as
separately twiddlable flags, so we just have to fix the mapping from
JSP flag bits to REG flag bits. I also chose to rename the symbol
for 's' to DOTALL, to make it clearer that it's not the inverse
of MLINE.
Also, XQuery says that if the 'q' flag "is used together with the m, s,
or x flag, that flag has no effect". I read this as saying that 'q'
overrides the other flags; whoever wrote our code seems to have read
it backwards.
Lastly, while XQuery's 'x' flag is related to what Spencer's code
does for REG_EXPANDED, it's not the same or a subset. It seems best
to treat XQuery's 'x' as unimplemented for now. Maybe later we can
expand our regex code to offer 'x'-style parsing as a separate option.
While at it, refactor the jsonpath code so that (a) there's only
one copy of the flag transformation logic not two, and (b) the
processing of flags is independent of the order in which the flags
are written.
We need some documentation updates to go with this, but I'll
tackle that separately.
Back-patch to v12 where this code originated.
Discussion: https://postgr.es/m/CAPpHfdvDci4iqNF9fhRkTqhe-5_8HmzeLt56drH%2B_Rv2rNRqfg@mail.gmail.com
Reference: https://www.w3.org/TR/2017/REC-xpath-functions-31-20170321/#flags
2019-09-17 21:39:51 +02:00
|
|
|
"ab\nadc"
|
|
|
|
(3 rows)
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
|
2019-06-19 21:40:58 +02:00
|
|
|
select jsonb_path_query('[null, 1, "a\b", "a\\b", "^a\\b$"]', 'lax $[*] ? (@ like_regex "a\\b" flag "q")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"a\\b"
|
|
|
|
"^a\\b$"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null, 1, "a\b", "a\\b", "^a\\b$"]', 'lax $[*] ? (@ like_regex "a\\b" flag "")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"a\b"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null, 1, "a\b", "a\\b", "^a\\b$"]', 'lax $[*] ? (@ like_regex "^a\\b$" flag "q")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"^a\\b$"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null, 1, "a\b", "a\\b", "^a\\b$"]', 'lax $[*] ? (@ like_regex "^a\\B$" flag "q")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null, 1, "a\b", "a\\b", "^a\\b$"]', 'lax $[*] ? (@ like_regex "^a\\B$" flag "iq")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"^a\\b$"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('[null, 1, "a\b", "a\\b", "^a\\b$"]', 'lax $[*] ? (@ like_regex "^a\\b$" flag "")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"a\b"
|
|
|
|
(1 row)
|
|
|
|
|
Implement jsonpath .datetime() method
This commit implements jsonpath .datetime() method as it's specified in
SQL/JSON standard. There are no-argument and single-argument versions of
this method. No-argument version selects first of ISO datetime formats
matching input string. Single-argument version accepts template string as
its argument.
Additionally to .datetime() method itself this commit also implements
comparison ability of resulting date and time values. There is some difficulty
because exising jsonb_path_*() functions are immutable, while comparison of
timezoned and non-timezoned types involves current timezone. At first, current
timezone could be changes in session. Moreover, timezones themselves are not
immutable and could be updated. This is why we let existing immutable functions
throw errors on such non-immutable comparison. In the same time this commit
provides jsonb_path_*_tz() functions which are stable and support operations
involving timezones. As new functions are added to the system catalog,
catversion is bumped.
Support of .datetime() method was the only blocker prevents T832 from being
marked as supported. sql_features.txt is updated correspondingly.
Extracted from original patch by Nikita Glukhov, Teodor Sigaev, Oleg Bartunov.
Heavily revised by me. Comments were adjusted by Liudmila Mantrova.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Discussion: https://postgr.es/m/CAPpHfdsZgYEra_PeCLGNoXOWYx6iU-S3wF8aX0ObQUcZU%2B4XTw%40mail.gmail.com
Author: Alexander Korotkov, Nikita Glukhov, Teodor Sigaev, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Anastasia Lubennikova, Peter Eisentraut
2019-09-25 20:54:14 +02:00
|
|
|
select jsonb_path_query('null', '$.datetime()');
|
|
|
|
ERROR: jsonpath item method .datetime() can only be applied to a string
|
|
|
|
select jsonb_path_query('true', '$.datetime()');
|
|
|
|
ERROR: jsonpath item method .datetime() can only be applied to a string
|
|
|
|
select jsonb_path_query('1', '$.datetime()');
|
|
|
|
ERROR: jsonpath item method .datetime() can only be applied to a string
|
|
|
|
select jsonb_path_query('[]', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query('[]', 'strict $.datetime()');
|
|
|
|
ERROR: jsonpath item method .datetime() can only be applied to a string
|
|
|
|
select jsonb_path_query('{}', '$.datetime()');
|
|
|
|
ERROR: jsonpath item method .datetime() can only be applied to a string
|
|
|
|
select jsonb_path_query('""', '$.datetime()');
|
|
|
|
ERROR: datetime format is not unrecognized
|
|
|
|
HINT: use datetime template argument for explicit format specification
|
|
|
|
select jsonb_path_query('"12:34"', '$.datetime("aaa")');
|
|
|
|
ERROR: invalid datetime format separator: "a"
|
|
|
|
select jsonb_path_query('"aaaa"', '$.datetime("HH24")');
|
|
|
|
ERROR: invalid value "aa" for "HH24"
|
|
|
|
DETAIL: Value must be an integer.
|
|
|
|
select jsonb '"10-03-2017"' @? '$.datetime("dd-mm-yyyy")';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017"', '$.datetime("dd-mm-yyyy")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"2017-03-10"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017"', '$.datetime("dd-mm-yyyy").type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"date"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', '$.datetime("dd-mm-yyyy")');
|
|
|
|
ERROR: trailing characters remain in input string after datetime format
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', '$.datetime("dd-mm-yyyy").type()');
|
|
|
|
ERROR: trailing characters remain in input string after datetime format
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', ' $.datetime("dd-mm-yyyy HH24:MI").type()');
|
|
|
|
jsonb_path_query
|
|
|
|
-------------------------------
|
|
|
|
"timestamp without time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 +05:20"', '$.datetime("dd-mm-yyyy HH24:MI TZH:TZM").type()');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
"timestamp with time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56"', '$.datetime("HH24:MI:SS").type()');
|
|
|
|
jsonb_path_query
|
|
|
|
--------------------------
|
|
|
|
"time without time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56 +05:20"', '$.datetime("HH24:MI:SS TZH:TZM").type()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------
|
|
|
|
"time with time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
set time zone '+00';
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', '$.datetime("dd-mm-yyyy HH24:MI")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------
|
|
|
|
"2017-03-10T12:34:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', '$.datetime("dd-mm-yyyy HH24:MI TZH")');
|
|
|
|
ERROR: input string is too short for datetime format
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 +05"', '$.datetime("dd-mm-yyyy HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00+05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 -05"', '$.datetime("dd-mm-yyyy HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00-05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 +05:20"', '$.datetime("dd-mm-yyyy HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00+05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 -05:20"', '$.datetime("dd-mm-yyyy HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00-05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34"', '$.datetime("HH24:MI")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34"', '$.datetime("HH24:MI TZH")');
|
|
|
|
ERROR: input string is too short for datetime format
|
|
|
|
select jsonb_path_query('"12:34 +05"', '$.datetime("HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00+05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34 -05"', '$.datetime("HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00-05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34 +05:20"', '$.datetime("HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00+05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34 -05:20"', '$.datetime("HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00-05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
set time zone '+10';
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', '$.datetime("dd-mm-yyyy HH24:MI")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------
|
|
|
|
"2017-03-10T12:34:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34"', '$.datetime("dd-mm-yyyy HH24:MI TZH")');
|
|
|
|
ERROR: input string is too short for datetime format
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 +05"', '$.datetime("dd-mm-yyyy HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00+05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 -05"', '$.datetime("dd-mm-yyyy HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00-05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 +05:20"', '$.datetime("dd-mm-yyyy HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00+05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"10-03-2017 12:34 -05:20"', '$.datetime("dd-mm-yyyy HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00-05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34"', '$.datetime("HH24:MI")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34"', '$.datetime("HH24:MI TZH")');
|
|
|
|
ERROR: input string is too short for datetime format
|
|
|
|
select jsonb_path_query('"12:34 +05"', '$.datetime("HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00+05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34 -05"', '$.datetime("HH24:MI TZH")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00-05:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34 +05:20"', '$.datetime("HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00+05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34 -05:20"', '$.datetime("HH24:MI TZH:TZM")');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:00-05:20"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
set time zone default;
|
|
|
|
select jsonb_path_query('"2017-03-10"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"date"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"2017-03-10"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10 12:34:56"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
-------------------------------
|
|
|
|
"timestamp without time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10 12:34:56"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------
|
|
|
|
"2017-03-10T12:34:56"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10 12:34:56 +3"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
"timestamp with time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10 12:34:56 +3"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:56+03:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10 12:34:56 +3:10"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
----------------------------
|
|
|
|
"timestamp with time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"2017-03-10 12:34:56 +3:10"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:56+03:10"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
--------------------------
|
|
|
|
"time without time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:56"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56 +3"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------
|
|
|
|
"time with time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56 +3"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:56+03:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56 +3:10"', '$.datetime().type()');
|
|
|
|
jsonb_path_query
|
|
|
|
-----------------------
|
|
|
|
"time with time zone"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query('"12:34:56 +3:10"', '$.datetime()');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
"12:34:56+03:10"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
set time zone '+00';
|
|
|
|
-- date comparison
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10", "2017-03-11", "2017-03-09", "12:34:56", "01:02:03 +04", "2017-03-10 00:00:00", "2017-03-10 12:34:56", "2017-03-10 01:02:03 +04", "2017-03-10 03:00:00 +03"]',
|
|
|
|
'$[*].datetime() ? (@ == "10.03.2017".datetime("dd.mm.yyyy"))');
|
|
|
|
ERROR: cannot convert value from date to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10", "2017-03-11", "2017-03-09", "12:34:56", "01:02:03 +04", "2017-03-10 00:00:00", "2017-03-10 12:34:56", "2017-03-10 01:02:03 +04", "2017-03-10 03:00:00 +03"]',
|
|
|
|
'$[*].datetime() ? (@ >= "10.03.2017".datetime("dd.mm.yyyy"))');
|
|
|
|
ERROR: cannot convert value from date to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10", "2017-03-11", "2017-03-09", "12:34:56", "01:02:03 +04", "2017-03-10 00:00:00", "2017-03-10 12:34:56", "2017-03-10 01:02:03 +04", "2017-03-10 03:00:00 +03"]',
|
|
|
|
'$[*].datetime() ? (@ < "10.03.2017".datetime("dd.mm.yyyy"))');
|
|
|
|
ERROR: cannot convert value from date to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10", "2017-03-11", "2017-03-09", "12:34:56", "01:02:03 +04", "2017-03-10 00:00:00", "2017-03-10 12:34:56", "2017-03-10 01:02:03 +04", "2017-03-10 03:00:00 +03"]',
|
|
|
|
'$[*].datetime() ? (@ == "10.03.2017".datetime("dd.mm.yyyy"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10"
|
|
|
|
"2017-03-10T00:00:00"
|
|
|
|
"2017-03-10T03:00:00+03:00"
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10", "2017-03-11", "2017-03-09", "12:34:56", "01:02:03 +04", "2017-03-10 00:00:00", "2017-03-10 12:34:56", "2017-03-10 01:02:03 +04", "2017-03-10 03:00:00 +03"]',
|
|
|
|
'$[*].datetime() ? (@ >= "10.03.2017".datetime("dd.mm.yyyy"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10"
|
|
|
|
"2017-03-11"
|
|
|
|
"2017-03-10T00:00:00"
|
|
|
|
"2017-03-10T12:34:56"
|
|
|
|
"2017-03-10T03:00:00+03:00"
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10", "2017-03-11", "2017-03-09", "12:34:56", "01:02:03 +04", "2017-03-10 00:00:00", "2017-03-10 12:34:56", "2017-03-10 01:02:03 +04", "2017-03-10 03:00:00 +03"]',
|
|
|
|
'$[*].datetime() ? (@ < "10.03.2017".datetime("dd.mm.yyyy"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-09"
|
|
|
|
"2017-03-10T01:02:03+04:00"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
-- time comparison
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["12:34:00", "12:35:00", "12:36:00", "12:35:00 +00", "12:35:00 +01", "13:35:00 +01", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +01"]',
|
|
|
|
'$[*].datetime() ? (@ == "12:35".datetime("HH24:MI"))');
|
|
|
|
ERROR: cannot convert value from time to timetz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["12:34:00", "12:35:00", "12:36:00", "12:35:00 +00", "12:35:00 +01", "13:35:00 +01", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +01"]',
|
|
|
|
'$[*].datetime() ? (@ >= "12:35".datetime("HH24:MI"))');
|
|
|
|
ERROR: cannot convert value from time to timetz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["12:34:00", "12:35:00", "12:36:00", "12:35:00 +00", "12:35:00 +01", "13:35:00 +01", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +01"]',
|
|
|
|
'$[*].datetime() ? (@ < "12:35".datetime("HH24:MI"))');
|
|
|
|
ERROR: cannot convert value from time to timetz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["12:34:00", "12:35:00", "12:36:00", "12:35:00 +00", "12:35:00 +01", "13:35:00 +01", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +01"]',
|
|
|
|
'$[*].datetime() ? (@ == "12:35".datetime("HH24:MI"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
---------------------
|
|
|
|
"12:35:00"
|
|
|
|
"12:35:00+00:00"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["12:34:00", "12:35:00", "12:36:00", "12:35:00 +00", "12:35:00 +01", "13:35:00 +01", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +01"]',
|
|
|
|
'$[*].datetime() ? (@ >= "12:35".datetime("HH24:MI"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
---------------------
|
|
|
|
"12:35:00"
|
|
|
|
"12:36:00"
|
|
|
|
"12:35:00+00:00"
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["12:34:00", "12:35:00", "12:36:00", "12:35:00 +00", "12:35:00 +01", "13:35:00 +01", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +01"]',
|
|
|
|
'$[*].datetime() ? (@ < "12:35".datetime("HH24:MI"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
---------------------
|
|
|
|
"12:34:00"
|
|
|
|
"12:35:00+01:00"
|
|
|
|
"13:35:00+01:00"
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
-- timetz comparison
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["12:34:00 +01", "12:35:00 +01", "12:36:00 +01", "12:35:00 +02", "12:35:00 -02", "10:35:00", "11:35:00", "12:35:00", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +1"]',
|
|
|
|
'$[*].datetime() ? (@ == "12:35 +1".datetime("HH24:MI TZH"))');
|
|
|
|
ERROR: cannot convert value from time to timetz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["12:34:00 +01", "12:35:00 +01", "12:36:00 +01", "12:35:00 +02", "12:35:00 -02", "10:35:00", "11:35:00", "12:35:00", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +1"]',
|
|
|
|
'$[*].datetime() ? (@ >= "12:35 +1".datetime("HH24:MI TZH"))');
|
|
|
|
ERROR: cannot convert value from time to timetz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["12:34:00 +01", "12:35:00 +01", "12:36:00 +01", "12:35:00 +02", "12:35:00 -02", "10:35:00", "11:35:00", "12:35:00", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +1"]',
|
|
|
|
'$[*].datetime() ? (@ < "12:35 +1".datetime("HH24:MI TZH"))');
|
|
|
|
ERROR: cannot convert value from time to timetz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["12:34:00 +01", "12:35:00 +01", "12:36:00 +01", "12:35:00 +02", "12:35:00 -02", "10:35:00", "11:35:00", "12:35:00", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +1"]',
|
|
|
|
'$[*].datetime() ? (@ == "12:35 +1".datetime("HH24:MI TZH"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
---------------------
|
|
|
|
"12:35:00+01:00"
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["12:34:00 +01", "12:35:00 +01", "12:36:00 +01", "12:35:00 +02", "12:35:00 -02", "10:35:00", "11:35:00", "12:35:00", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +1"]',
|
|
|
|
'$[*].datetime() ? (@ >= "12:35 +1".datetime("HH24:MI TZH"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
---------------------
|
|
|
|
"12:35:00+01:00"
|
|
|
|
"12:36:00+01:00"
|
|
|
|
"12:35:00-02:00"
|
|
|
|
"11:35:00"
|
|
|
|
"12:35:00"
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["12:34:00 +01", "12:35:00 +01", "12:36:00 +01", "12:35:00 +02", "12:35:00 -02", "10:35:00", "11:35:00", "12:35:00", "2017-03-10", "2017-03-10 12:35:00", "2017-03-10 12:35:00 +1"]',
|
|
|
|
'$[*].datetime() ? (@ < "12:35 +1".datetime("HH24:MI TZH"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
---------------------
|
|
|
|
"12:34:00+01:00"
|
|
|
|
"12:35:00+02:00"
|
|
|
|
"10:35:00"
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
-- timestamp comparison
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10 12:34:00", "2017-03-10 12:35:00", "2017-03-10 12:36:00", "2017-03-10 12:35:00 +01", "2017-03-10 13:35:00 +01", "2017-03-10 12:35:00 -01", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ == "10.03.2017 12:35".datetime("dd.mm.yyyy HH24:MI"))');
|
|
|
|
ERROR: cannot convert value from timestamp to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10 12:34:00", "2017-03-10 12:35:00", "2017-03-10 12:36:00", "2017-03-10 12:35:00 +01", "2017-03-10 13:35:00 +01", "2017-03-10 12:35:00 -01", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ >= "10.03.2017 12:35".datetime("dd.mm.yyyy HH24:MI"))');
|
|
|
|
ERROR: cannot convert value from timestamp to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10 12:34:00", "2017-03-10 12:35:00", "2017-03-10 12:36:00", "2017-03-10 12:35:00 +01", "2017-03-10 13:35:00 +01", "2017-03-10 12:35:00 -01", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ < "10.03.2017 12:35".datetime("dd.mm.yyyy HH24:MI"))');
|
|
|
|
ERROR: cannot convert value from timestamp to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10 12:34:00", "2017-03-10 12:35:00", "2017-03-10 12:36:00", "2017-03-10 12:35:00 +01", "2017-03-10 13:35:00 +01", "2017-03-10 12:35:00 -01", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ == "10.03.2017 12:35".datetime("dd.mm.yyyy HH24:MI"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:35:00"
|
|
|
|
"2017-03-10T13:35:00+01:00"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10 12:34:00", "2017-03-10 12:35:00", "2017-03-10 12:36:00", "2017-03-10 12:35:00 +01", "2017-03-10 13:35:00 +01", "2017-03-10 12:35:00 -01", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ >= "10.03.2017 12:35".datetime("dd.mm.yyyy HH24:MI"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:35:00"
|
|
|
|
"2017-03-10T12:36:00"
|
|
|
|
"2017-03-10T13:35:00+01:00"
|
|
|
|
"2017-03-10T12:35:00-01:00"
|
|
|
|
"2017-03-11"
|
|
|
|
(5 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10 12:34:00", "2017-03-10 12:35:00", "2017-03-10 12:36:00", "2017-03-10 12:35:00 +01", "2017-03-10 13:35:00 +01", "2017-03-10 12:35:00 -01", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ < "10.03.2017 12:35".datetime("dd.mm.yyyy HH24:MI"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00"
|
|
|
|
"2017-03-10T12:35:00+01:00"
|
|
|
|
"2017-03-10"
|
|
|
|
(3 rows)
|
|
|
|
|
|
|
|
-- timestamptz comparison
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10 12:34:00 +01", "2017-03-10 12:35:00 +01", "2017-03-10 12:36:00 +01", "2017-03-10 12:35:00 +02", "2017-03-10 12:35:00 -02", "2017-03-10 10:35:00", "2017-03-10 11:35:00", "2017-03-10 12:35:00", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ == "10.03.2017 12:35 +1".datetime("dd.mm.yyyy HH24:MI TZH"))');
|
|
|
|
ERROR: cannot convert value from timestamp to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10 12:34:00 +01", "2017-03-10 12:35:00 +01", "2017-03-10 12:36:00 +01", "2017-03-10 12:35:00 +02", "2017-03-10 12:35:00 -02", "2017-03-10 10:35:00", "2017-03-10 11:35:00", "2017-03-10 12:35:00", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ >= "10.03.2017 12:35 +1".datetime("dd.mm.yyyy HH24:MI TZH"))');
|
|
|
|
ERROR: cannot convert value from timestamp to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query(
|
|
|
|
'["2017-03-10 12:34:00 +01", "2017-03-10 12:35:00 +01", "2017-03-10 12:36:00 +01", "2017-03-10 12:35:00 +02", "2017-03-10 12:35:00 -02", "2017-03-10 10:35:00", "2017-03-10 11:35:00", "2017-03-10 12:35:00", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ < "10.03.2017 12:35 +1".datetime("dd.mm.yyyy HH24:MI TZH"))');
|
|
|
|
ERROR: cannot convert value from timestamp to timestamptz without timezone usage
|
|
|
|
HINT: use *_tz() function for timezone support
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10 12:34:00 +01", "2017-03-10 12:35:00 +01", "2017-03-10 12:36:00 +01", "2017-03-10 12:35:00 +02", "2017-03-10 12:35:00 -02", "2017-03-10 10:35:00", "2017-03-10 11:35:00", "2017-03-10 12:35:00", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ == "10.03.2017 12:35 +1".datetime("dd.mm.yyyy HH24:MI TZH"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:35:00+01:00"
|
|
|
|
"2017-03-10T11:35:00"
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10 12:34:00 +01", "2017-03-10 12:35:00 +01", "2017-03-10 12:36:00 +01", "2017-03-10 12:35:00 +02", "2017-03-10 12:35:00 -02", "2017-03-10 10:35:00", "2017-03-10 11:35:00", "2017-03-10 12:35:00", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ >= "10.03.2017 12:35 +1".datetime("dd.mm.yyyy HH24:MI TZH"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:35:00+01:00"
|
|
|
|
"2017-03-10T12:36:00+01:00"
|
|
|
|
"2017-03-10T12:35:00-02:00"
|
|
|
|
"2017-03-10T11:35:00"
|
|
|
|
"2017-03-10T12:35:00"
|
|
|
|
"2017-03-11"
|
|
|
|
(6 rows)
|
|
|
|
|
|
|
|
select jsonb_path_query_tz(
|
|
|
|
'["2017-03-10 12:34:00 +01", "2017-03-10 12:35:00 +01", "2017-03-10 12:36:00 +01", "2017-03-10 12:35:00 +02", "2017-03-10 12:35:00 -02", "2017-03-10 10:35:00", "2017-03-10 11:35:00", "2017-03-10 12:35:00", "2017-03-10", "2017-03-11", "12:34:56", "12:34:56 +01"]',
|
|
|
|
'$[*].datetime() ? (@ < "10.03.2017 12:35 +1".datetime("dd.mm.yyyy HH24:MI TZH"))');
|
|
|
|
jsonb_path_query_tz
|
|
|
|
-----------------------------
|
|
|
|
"2017-03-10T12:34:00+01:00"
|
|
|
|
"2017-03-10T12:35:00+02:00"
|
|
|
|
"2017-03-10T10:35:00"
|
|
|
|
"2017-03-10"
|
|
|
|
(4 rows)
|
|
|
|
|
|
|
|
set time zone default;
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
-- jsonpath operators
|
|
|
|
SELECT jsonb_path_query('[{"a": 1}, {"a": 2}]', '$[*]');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
{"a": 1}
|
|
|
|
{"a": 2}
|
|
|
|
(2 rows)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query('[{"a": 1}, {"a": 2}]', '$[*] ? (@.a > 10)');
|
|
|
|
jsonb_path_query
|
|
|
|
------------------
|
|
|
|
(0 rows)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_array('[{"a": 1}, {"a": 2}, {}]', 'strict $[*].a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: JSON object does not contain key "a"
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
SELECT jsonb_path_query_array('[{"a": 1}, {"a": 2}]', '$[*].a');
|
|
|
|
jsonb_path_query_array
|
|
|
|
------------------------
|
|
|
|
[1, 2]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_array('[{"a": 1}, {"a": 2}]', '$[*].a ? (@ == 1)');
|
|
|
|
jsonb_path_query_array
|
|
|
|
------------------------
|
|
|
|
[1]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_array('[{"a": 1}, {"a": 2}]', '$[*].a ? (@ > 10)');
|
|
|
|
jsonb_path_query_array
|
|
|
|
------------------------
|
|
|
|
[]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_array('[{"a": 1}, {"a": 2}, {"a": 3}, {"a": 5}]', '$[*].a ? (@ > $min && @ < $max)', vars => '{"min": 1, "max": 4}');
|
|
|
|
jsonb_path_query_array
|
|
|
|
------------------------
|
|
|
|
[2, 3]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_array('[{"a": 1}, {"a": 2}, {"a": 3}, {"a": 5}]', '$[*].a ? (@ > $min && @ < $max)', vars => '{"min": 3, "max": 4}');
|
|
|
|
jsonb_path_query_array
|
|
|
|
------------------------
|
|
|
|
[]
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}, {}]', 'strict $[*].a');
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: JSON object does not contain key "a"
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}, {}]', 'strict $[*].a', silent => true);
|
|
|
|
jsonb_path_query_first
|
|
|
|
------------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}]', '$[*].a');
|
|
|
|
jsonb_path_query_first
|
|
|
|
------------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}]', '$[*].a ? (@ == 1)');
|
|
|
|
jsonb_path_query_first
|
|
|
|
------------------------
|
|
|
|
1
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}]', '$[*].a ? (@ > 10)');
|
|
|
|
jsonb_path_query_first
|
|
|
|
------------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}, {"a": 3}, {"a": 5}]', '$[*].a ? (@ > $min && @ < $max)', vars => '{"min": 1, "max": 4}');
|
|
|
|
jsonb_path_query_first
|
|
|
|
------------------------
|
|
|
|
2
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_query_first('[{"a": 1}, {"a": 2}, {"a": 3}, {"a": 5}]', '$[*].a ? (@ > $min && @ < $max)', vars => '{"min": 3, "max": 4}');
|
|
|
|
jsonb_path_query_first
|
|
|
|
------------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb '[{"a": 1}, {"a": 2}]' @? '$[*].a ? (@ > 1)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb '[{"a": 1}, {"a": 2}]' @? '$[*] ? (@.a > 2)';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
2019-03-20 08:27:56 +01:00
|
|
|
SELECT jsonb_path_exists('[{"a": 1}, {"a": 2}]', '$[*].a ? (@ > 1)');
|
|
|
|
jsonb_path_exists
|
|
|
|
-------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
SELECT jsonb_path_exists('[{"a": 1}, {"a": 2}, {"a": 3}, {"a": 5}]', '$[*] ? (@.a > $min && @.a < $max)', vars => '{"min": 1, "max": 4}');
|
|
|
|
jsonb_path_exists
|
|
|
|
-------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_exists('[{"a": 1}, {"a": 2}, {"a": 3}, {"a": 5}]', '$[*] ? (@.a > $min && @.a < $max)', vars => '{"min": 3, "max": 4}');
|
|
|
|
jsonb_path_exists
|
|
|
|
-------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('true', '$', silent => false);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_match('false', '$', silent => false);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_match('null', '$', silent => false);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_match('1', '$', silent => true);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_match('1', '$', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: single boolean result is expected
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('"a"', '$', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: single boolean result is expected
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('{}', '$', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: single boolean result is expected
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('[true]', '$', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: single boolean result is expected
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('{}', 'lax $.a', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: single boolean result is expected
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('{}', 'strict $.a', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: JSON object does not contain key "a"
|
2019-04-01 17:09:20 +02:00
|
|
|
SELECT jsonb_path_match('{}', 'strict $.a', silent => true);
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb_path_match('[true, true]', '$[*]', silent => false);
|
2019-04-23 16:43:09 +02:00
|
|
|
ERROR: single boolean result is expected
|
Partial implementation of SQL/JSON path language
SQL 2016 standards among other things contains set of SQL/JSON features for
JSON processing inside of relational database. The core of SQL/JSON is JSON
path language, allowing access parts of JSON documents and make computations
over them. This commit implements partial support JSON path language as
separate datatype called "jsonpath". The implementation is partial because
it's lacking datetime support and suppression of numeric errors. Missing
features will be added later by separate commits.
Support of SQL/JSON features requires implementation of separate nodes, and it
will be considered in subsequent patches. This commit includes following
set of plain functions, allowing to execute jsonpath over jsonb values:
* jsonb_path_exists(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_match(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query(jsonb, jsonpath[, jsonb, bool]),
* jsonb_path_query_array(jsonb, jsonpath[, jsonb, bool]).
* jsonb_path_query_first(jsonb, jsonpath[, jsonb, bool]).
This commit also implements "jsonb @? jsonpath" and "jsonb @@ jsonpath", which
are wrappers over jsonpath_exists(jsonb, jsonpath) and jsonpath_predicate(jsonb,
jsonpath) correspondingly. These operators will have an index support
(implemented in subsequent patches).
Catversion bumped, to add new functions and operators.
Code was written by Nikita Glukhov and Teodor Sigaev, revised by me.
Documentation was written by Oleg Bartunov and Liudmila Mantrova. The work
was inspired by Oleg Bartunov.
Discussion: https://postgr.es/m/fcc6fc6a-b497-f39a-923d-aa34d0c588e8%402ndQuadrant.com
Author: Nikita Glukhov, Teodor Sigaev, Alexander Korotkov, Oleg Bartunov, Liudmila Mantrova
Reviewed-by: Tomas Vondra, Andrew Dunstan, Pavel Stehule, Alexander Korotkov
2019-03-16 10:15:37 +01:00
|
|
|
SELECT jsonb '[{"a": 1}, {"a": 2}]' @@ '$[*].a > 1';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
|
|
|
SELECT jsonb '[{"a": 1}, {"a": 2}]' @@ '$[*].a > 2';
|
|
|
|
?column?
|
|
|
|
----------
|
|
|
|
f
|
|
|
|
(1 row)
|
|
|
|
|
2019-03-20 08:27:56 +01:00
|
|
|
SELECT jsonb_path_match('[{"a": 1}, {"a": 2}]', '$[*].a > 1');
|
|
|
|
jsonb_path_match
|
|
|
|
------------------
|
|
|
|
t
|
|
|
|
(1 row)
|
|
|
|
|
2019-08-11 21:54:53 +02:00
|
|
|
-- test string comparison (Unicode codepoint collation)
|
|
|
|
WITH str(j, num) AS
|
|
|
|
(
|
|
|
|
SELECT jsonb_build_object('s', s), num
|
|
|
|
FROM unnest('{"", "a", "ab", "abc", "abcd", "b", "A", "AB", "ABC", "ABc", "ABcD", "B"}'::text[]) WITH ORDINALITY AS a(s, num)
|
|
|
|
)
|
|
|
|
SELECT
|
|
|
|
s1.j, s2.j,
|
|
|
|
jsonb_path_query_first(s1.j, '$.s < $s', vars => s2.j) lt,
|
|
|
|
jsonb_path_query_first(s1.j, '$.s <= $s', vars => s2.j) le,
|
|
|
|
jsonb_path_query_first(s1.j, '$.s == $s', vars => s2.j) eq,
|
|
|
|
jsonb_path_query_first(s1.j, '$.s >= $s', vars => s2.j) ge,
|
|
|
|
jsonb_path_query_first(s1.j, '$.s > $s', vars => s2.j) gt
|
|
|
|
FROM str s1, str s2
|
|
|
|
ORDER BY s1.num, s2.num;
|
|
|
|
j | j | lt | le | eq | ge | gt
|
|
|
|
---------------+---------------+-------+-------+-------+-------+-------
|
|
|
|
{"s": ""} | {"s": ""} | false | true | true | true | false
|
|
|
|
{"s": ""} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "A"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "AB"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "ABC"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "ABc"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "ABcD"} | true | true | false | false | false
|
|
|
|
{"s": ""} | {"s": "B"} | true | true | false | false | false
|
|
|
|
{"s": "a"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "a"} | {"s": "a"} | false | true | true | true | false
|
|
|
|
{"s": "a"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "a"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "a"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "a"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "a"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "a"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "a"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "a"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "a"} | {"s": "ABcD"} | false | false | false | true | true
|
|
|
|
{"s": "a"} | {"s": "B"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "a"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "ab"} | false | true | true | true | false
|
|
|
|
{"s": "ab"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "ab"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "ab"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "ab"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "ABcD"} | false | false | false | true | true
|
|
|
|
{"s": "ab"} | {"s": "B"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "a"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "ab"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "abc"} | false | true | true | true | false
|
|
|
|
{"s": "abc"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "abc"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "abc"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "ABcD"} | false | false | false | true | true
|
|
|
|
{"s": "abc"} | {"s": "B"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "a"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "ab"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "abc"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "abcd"} | false | true | true | true | false
|
|
|
|
{"s": "abcd"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "abcd"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "ABcD"} | false | false | false | true | true
|
|
|
|
{"s": "abcd"} | {"s": "B"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "a"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "ab"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "abc"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "abcd"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "b"} | false | true | true | true | false
|
|
|
|
{"s": "b"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "ABcD"} | false | false | false | true | true
|
|
|
|
{"s": "b"} | {"s": "B"} | false | false | false | true | true
|
|
|
|
{"s": "A"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "A"} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "A"} | false | true | true | true | false
|
|
|
|
{"s": "A"} | {"s": "AB"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "ABC"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "ABc"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "ABcD"} | true | true | false | false | false
|
|
|
|
{"s": "A"} | {"s": "B"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "AB"} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "AB"} | {"s": "AB"} | false | true | true | true | false
|
|
|
|
{"s": "AB"} | {"s": "ABC"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "ABc"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "ABcD"} | true | true | false | false | false
|
|
|
|
{"s": "AB"} | {"s": "B"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "ABC"} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "ABC"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "ABC"} | {"s": "ABC"} | false | true | true | true | false
|
|
|
|
{"s": "ABC"} | {"s": "ABc"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "ABcD"} | true | true | false | false | false
|
|
|
|
{"s": "ABC"} | {"s": "B"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "ABc"} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "ABc"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "ABc"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "ABc"} | {"s": "ABc"} | false | true | true | true | false
|
|
|
|
{"s": "ABc"} | {"s": "ABcD"} | true | true | false | false | false
|
|
|
|
{"s": "ABc"} | {"s": "B"} | true | true | false | false | false
|
|
|
|
{"s": "ABcD"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "ABcD"} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": "ABcD"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "ABcD"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "ABcD"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "ABcD"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "ABcD"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "ABcD"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "ABcD"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "ABcD"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "ABcD"} | {"s": "ABcD"} | false | true | true | true | false
|
|
|
|
{"s": "ABcD"} | {"s": "B"} | true | true | false | false | false
|
|
|
|
{"s": "B"} | {"s": ""} | false | false | false | true | true
|
|
|
|
{"s": "B"} | {"s": "a"} | true | true | false | false | false
|
|
|
|
{"s": "B"} | {"s": "ab"} | true | true | false | false | false
|
|
|
|
{"s": "B"} | {"s": "abc"} | true | true | false | false | false
|
|
|
|
{"s": "B"} | {"s": "abcd"} | true | true | false | false | false
|
|
|
|
{"s": "B"} | {"s": "b"} | true | true | false | false | false
|
|
|
|
{"s": "B"} | {"s": "A"} | false | false | false | true | true
|
|
|
|
{"s": "B"} | {"s": "AB"} | false | false | false | true | true
|
|
|
|
{"s": "B"} | {"s": "ABC"} | false | false | false | true | true
|
|
|
|
{"s": "B"} | {"s": "ABc"} | false | false | false | true | true
|
|
|
|
{"s": "B"} | {"s": "ABcD"} | false | false | false | true | true
|
|
|
|
{"s": "B"} | {"s": "B"} | false | true | true | true | false
|
|
|
|
(144 rows)
|
|
|
|
|