Jsquery - the jsonb query language with GIN indexing support

JsQuery
the jsonb query language with GIN indexing support
October, 2014, Madrid, Spain
Alexander Korotkov, Intaro
Oleg Bartunov, Teodor Sigaev, SAI MSU

Oleg Bartunov, Teodor Sigaev
• Locale support
• Extendability (indexing)
• GiST (KNN), GIN, SP-GiST
• Full Text Search (FTS)
• Jsonb, VODKA
• Extensions:
• intarray
• pg_trgm
• ltree
• hstore
• plantuner
https://www.facebook.com/oleg.bartunov
obartunov@gmail.com, teodor@sigaev.ru
https://www.facebook.com/groups/postgresql/

Alexander Korotkov
• Indexed regexp search
• GIN compression & fast scan
• Fast GiST build
• Range types indexing
• Split for GiST
• Indexing for jsonb
• jsquery
• Generic WAL + create am (WIP) aekorotkov@gmail.com

Agenda
• Intruduction into jsonb
• Jsonb indexing
• Jsquery - Jsonb Query Language
• Jsonb GIN opclasses with JsQuery support
• Future of Jsonb querying

Introduction to hstore
• Hstore benefits
• In provides a flexible model for storing a semi-structured data in relational
database
• hstore has binary storage and rich set of operators and functions, indexes
• Hstore drawbacks
• Too simple model !
Hstore key-value model doesn't supports tree-like structures as json
(introduced in 2006, 3 years after hstore)
• Json — popular and standartized (ECMA-404 The JSON Data
Interchange Standard, JSON RFC-7159)
• Json — PostgreSQL 9.2, textual storage

Nested hstore & jsonb
• Nested hstore at PGCon-2013, Ottawa, Canada ( May 24) — thanks
Engine Yard for support !
One step forward true json data type.Nested hstore with arrays support
• Binary storage for nested data at PGCon Europe — 2013, Dublin, Ireland
(Oct 29)
Binary storage for nested data structuresand application to hstore data type
• November, 2013 — binary storage was reworked, nested hstore and
jsonb share the same storage. Andrew Dunstan joined the project.
• January, 2014 - binary storage moved to core

Nested hstore & jsonb
• Feb-Mar, 2014 - Peter Geoghegan joined the project, nested hstore was
cancelled in favour to jsonb (Nested hstore patch for 9.3).
• Mar 23, 2014 Andrew Dunstan committed jsonb to 9.4 branch !
pgsql: Introduce jsonb, a structured format for storing json.
Introduce jsonb, a structured format for storing json.
The new format accepts exactly the same data as the json type. However, it is
stored in a format that does not require reparsing the orgiginal text in order
to process it, making it much more suitable for indexing and other operations.
Insignificant whitespace is discarded, and the order of object keys is not
preserved. Neither are duplicate object keys kept - the later value for a given
key is the only one stored.

Jsonb vs Json
SELECT '{"c":0, "a":2,"a":1}'::json, '{"c":0, "a":2,"a":1}'::jsonb;
json | jsonb
-----------------------+------------------
{"c":0, "a":2,"a":1} | {"a": 1, "c": 0}
(1 row)
• json: textual storage «as is»
• jsonb: no whitespaces
• jsonb: no duplicate keys, last key win
• jsonb: keys are sorted

Jsonb vs Json
• Data
• 1,252,973 Delicious bookmarks
• Server
• MBA, 8 GB RAM, 256 GB SSD
• Test
• Input performance - copy data to table
• Access performance - get value by key
• Search performance contains @> operator

Jsonb vs Json
• Input performance (parser)
Copy data (1,252,973 rows) as text, json,jsonb
copy tt from '/path/to/test.dump'
Text: 34 s - as is
Json: 37 s - json validation
Jsonb: 43 s - json validation, binary storage

Jsonb vs Json (binary storage)
• Access performance — get value by key
• Base: SELECT js FROM js;
• Jsonb: SELECT j->>'updated' FROM jb;
• Json: SELECT j->>'updated' FROM js;
Base: 0.6 s
Jsonb: 1 s 0.4
Json: 9.6 s 9
Jsonb ~ 20X faster Json

Jsonb vs Json
EXPLAIN ANALYZE SELECT count(*) FROM js WHERE js #>>'{tags,0,term}' = 'NYC';
QUERY PLAN
----------------------------------------------------------------------------
Aggregate (cost=187812.38..187812.39 rows=1 width=0)
(actual time=10054.602..10054.602 rows=1 loops=1)
-> Seq Scan on js (cost=0.00..187796.88 rows=6201 width=0)
Filter: ((js #>> '{tags,0,term}'::text[]) = 'NYC'::text)
Rows Removed by Filter: 1252850
Planning time: 0.078 ms
Execution runtime: 10054.635 ms
(6 rows)
Json: no contains @> operator,
search first array element

Jsonb vs Json (binary storage)
EXPLAIN ANALYZE SELECT count(*) FROM jb WHERE jb @> '{"tags":[{"term":"NYC"}]}'::jsonb;
QUERY PLAN
---------------------------------------------------------------------------------------
-> Seq Scan on jb (cost=0.00..191518.16 rows=1253 width=0)
Filter: (jb @> '{"tags": [{"term": "NYC"}]}'::jsonb)
Execution runtime: 1263.225 ms Execution runtime: 10054.635 ms
(6 rows)

Jsonb vs Json (GIN: key && value)
QUERY PLAN
---------------------------------------------------------------------------------------
-> Bitmap Heap Scan on jb (cost=73.71..4769.59 rows=1253 width=0)
Recheck Cond: (jb @> '{"tags": [{"term": "NYC"}]}'::jsonb)
Heap Blocks: exact=285
-> Bitmap Index Scan on gin_jb_idx (cost=0.00..73.40 rows=1253 width=0)
Index Cond: (jb @> '{"tags": [{"term": "NYC"}]}'::jsonb)
(8 rows)
CREATE INDEX gin_jb_idx ON jb USING gin(jb);

Jsonb vs Json (GIN: hash path.value)
QUERY PLAN
---------------------------------------------------------------------------------------
-> Bitmap Heap Scan on jb (cost=33.71..4729.59 rows=1253 width=0)
Recheck Cond: (jb @> '{"tags": [{"term": "NYC"}]}'::jsonb)
-> Bitmap Index Scan on gin_jb_path_idx
(cost=0.00..33.40 rows=1253 width=0) (actual time=0.062..0.062 rows=285 loops=1)
Index Cond: (jb @> '{"tags": [{"term": "NYC"}]}'::jsonb)
(8 rows)
CREATE INDEX gin_jb_path_idx ON jb USING gin(jb jsonb_path_ops);

MongoDB 2.6.0
• Load data - ~13 min SLOW ! Jsonb 43 s
• Search - ~ 1s (seqscan) THE SAME
• Search - ~ 1ms (indexscan) Jsonb 0.7ms
mongoimport --host localhost -c js --type json < delicious-rss-1250k
2014-04-08T22:47:10.014+0400 3700 1233/second
...
2014-04-08T23:00:36.050+0400 1252000 1547/second
2014-04-08T23:00:36.565+0400 check 9 1252973
2014-04-08T23:00:36.566+0400 imported 1252973 objects
db.js.find({tags: {$elemMatch:{ term: "NYC"}}}).count()
285
-- 980 ms
db.js.ensureIndex( {"tags.term" : 1} )
db.js.find({tags: {$elemMatch:{ term: "NYC"}}}).

Summary: PostgreSQL 9.4 vs Mongo 2.6.0
• Operator contains @>
• json : 10 s seqscan
• jsonb : 8.5 ms GIN jsonb_ops
• jsonb : 0.7 ms GIN jsonb_path_ops
• mongo : 1.0 ms btree index
• Index size
• jsonb_ops - 636 Mb (no compression, 815Mb)
jsonb_path_ops - 295 Mb
• jsonb_path_ops (tags) - 44 Mb USING gin((jb->'tags') jsonb_path_ops
• mongo (tags) - 387 Mb
mongo (tags.term) - 100 Mb
•Table size
•postgres : 1.3Gb
•mongo : 1.8Gb
•Input performance:
• Text : 34 s
• Json : 37 s
• Jsonb : 43 s
• mongo : 13 m

Jsonb (Apr, 2014)
• Documentation
• JSON Types, JSON Functions and Operators
• There are many functionality left in nested hstore
• Can be an extension
• Need query language for jsonb
• <,>,&& … operators for values
a.b.c.d && [1,2,10]
• Structural queries on paths
*.d && [1,2,10]
• Indexes !

Jsonb query
Currently, one can search jsonb data using:
• Contains operators - jsonb @> jsonb, jsonb <@ jsonb (GIN indexes)
jb @> '{"tags":[{"term":"NYC"}]}'::jsonb
Keys should be specified from root
●
Equivalence operator — jsonb = jsonb (GIN indexes)
• Exists operators — jsonb ? text, jsonb ?! text[], jsonb ?& text[] (GIN indexes)
jb WHERE jb ?| '{tags,links}'
Only root keys supported
• Operators on jsonb parts (functional indexes)
SELECT ('{"a": {"b":5}}'::jsonb -> 'a'->>'b')::int > 2;
CREATE INDEX ….USING BTREE ( (jb->'a'->>'b')::int);
Very cumbersome, too many functional indexes

Jsonb querying an array: simple case
Find bookmarks with tag «NYC»:
SELECT *
FROM js
WHERE js @> '{"tags":[{"term":"NYC"}]}';

Jsonb querying an array: complex case
Find companies where CEO or CTO is called Neil.
One could write...
SELECT * FROM company
WHERE js @> '{"relationships":[{"person":
{"first_name":"Neil"}}]}' AND
(js @> '{"relationships":[{"title":"CTO"}]}' OR
js @> '{"relationships":[{"title":"CEO"}]}');

Each «@>» is processed independently.
WHERE js @> '{"relationships":[{"person":
{"first_name":"Neil"}}]}' AND
(js @> '{"relationships":[{"title":"CTO"}]}' OR
js @> '{"relationships":[{"title":"CEO"}]}');
Actually, this query searches for companies with some
CEO or CTO and someone called Neil...

The correct version is so.
WHERE js @> '{"relationships":[{"title":"CEO",
"person":{"first_name":"Neil"}}]}' OR
js @> '{"relationships":[{"title":"CTO",
"person":{"first_name":"Neil"}}]}';
When constructing complex conditions over same array
element, query length can grow exponentially.

Jsonb querying an array: another approach
Using subselect and jsonb_array_elements:
WHERE EXISTS (
SELECT 1
FROM jsonb_array_elements(js -> 'relationships') t
WHERE t->>'title' IN ('CEO', 'CTO') AND
t ->'person'->>'first_name' = 'Neil');

Jsonb querying an array: summary
Using «@>»
• Pro
• Indexing support
• Cons
• Checks only equality for scalars
• Hard to explain complex logic
Using subselect and
jsonb_array_elements
• Pro
• Full power of SQL can be used to
express condition over element
• Cons
• No indexing support
• Heavy syntax

Jsonb query
• Need Jsonb query language
• Simple and effective way to search in arrays (and other iterative searches)
• More comparison operators
• Types support
• Schema support (constraints on keys, values)
• Indexes support
• Introduce Jsquery - textual data type and @@ match operator
jsonb @@ jsquery

• # - any element array
• % - any key
• * - anything
• $ - current element
• Use "double quotes" for key !
SELECT '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b.# = 2';
SELECT '{"a": {"b": [1,2,3]}}'::jsonb @@ '%.b.# = 2';
SELECT '{"a": {"b": [1,2,3]}}'::jsonb @@ '*.# = 2';
select '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b.# ($ = 2 OR $ < 3)';
select 'a1."12222" < 111'::jsquery;
path ::= key
| path '.' key_any
| NOT '.' key_any
key ::= '*'
| '#'
| '%'
| '$'
| STRING
….....
key_any ::= key
| NOT

• Scalar
• Test for key existence
• Array overlap
• Array contains
• Array contained
select '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b.# IN (1,2,5)';
select '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b = *';
select '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b && [1,2,5]';
select '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b @> [1,2]';
select '{"a": {"b": [1,2,3]}}'::jsonb @@ 'a.b <@ [1,2,3,4,5]';
value_expr
::= '=' scalar_value
| IN '(' value_list ')'
| '=' array
| '=' '*'
| '<' NUMERIC
| '<' '=' NUMERIC
| '>' NUMERIC
| '>' '=' NUMERIC
| '@' '>' array
| '<' '@' array
| '&' '&' array
| IS ARRAY
| IS NUMERIC
| IS OBJECT
| IS STRING
| IS BOOLEAN

• Type checking
select '{"x": true}' @@ 'x IS boolean'::jsquery,
'{"x": 0.1}' @@ 'x IS numeric'::jsquery;
?column? | ?column?
----------+----------
t | t
IS BOOLEAN
IS NUMERIC
IS ARRAY
IS OBJECT
IS STRINGselect '{"a":{"a":1}}' @@ 'a IS object'::jsquery;
?column?
----------
t
select '{"a":["xxx"]}' @@ 'a IS array'::jsquery, '["xxx"]' @@ '$ IS array'::jsquery;
?column? | ?column?
----------+----------
t | t

• How many products are similar to "B000089778" and have
product_sales_rank in range between 10000-20000 ?
• SQL
SELECT count(*) FROM jr WHERE (jr->>'product_sales_rank')::int > 10000
and (jr->> 'product_sales_rank')::int < 20000 and
….boring stuff
• Jsquery
SELECT count(*) FROM jr WHERE jr @@ ' similar_product_ids &&
["B000089778"] AND product_sales_rank( $ > 10000 AND $ < 20000)'
• Mongodb
db.reviews.find( { $and :[ {similar_product_ids: { $in ["B000089778"]}},
{product_sales_rank:{$gt:10000, $lt:20000}}] } ).count()

«#», «*», «%» usage rules
Each usage of «#», «*», «%» means separate element
• Find companies where CEO or CTO is called Neil.
SELECT count(*) FROM company WHERE js @@ 'relationships.#(title in ("CEO",
"CTO") AND person.first_name = "Neil")'::jsquery;
count
-------
12
• Find companies with some CEO or CTO and someone called Neil
SELECT count(*) FROM company WHERE js @@ 'relationships(#.title in ("CEO",
"CTO") AND #.person.first_name = "Neil")'::jsquery;
count
-------
69

explain( analyze, buffers) select count(*) from jb where jb @> '{"tags":[{"term":"NYC"}]}'::jsonb;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------
Aggregate (cost=191517.30..191517.31 rows=1 width=0) (actual time=1039.422..1039.423 rows=1 loops=1)
Buffers: shared hit=97841 read=78011
-> Seq Scan on jb (cost=0.00..191514.16 rows=1253 width=0) (actual time=0.006..1039.310 rows=285 loops=1)
Filter: (jb @> '{"tags": [{"term": "NYC"}]}'::jsonb)
Buffers: shared hit=97841 read=78011
Execution time: 1039.444 ms
explain( analyze,costs off) select count(*) from jb where jb @@ 'tags.#.term = "NYC"';
QUERY PLAN
--------------------------------------------------------------------
Aggregate (actual time=891.707..891.707 rows=1 loops=1)
-> Seq Scan on jb (actual time=0.010..891.553 rows=285 loops=1)
Filter: (jb @@ '"tags".#."term" = "NYC"'::jsquery)

Jsquery (indexes)
• GIN opclasses with jsquery support
• jsonb_value_path_ops — use Bloom filtering for key matching
{"a":{"b":{"c":10}}} → 10.( bloom(a) or bloom(b) or bloom(c) )
• Good for key matching (wildcard support) , not good for range query
• jsonb_path_value_ops — hash path (like jsonb_path_ops)
{"a":{"b":{"c":10}}} → hash(a.b.c).10
• No wildcard support, no problem with ranges
List of relations
Schema | Name | Type | Owner | Table | Size | Description
--------+-------------------------+-------+----------+--------------+---------+-------------
public | jb | table | postgres | | 1374 MB |
public | jb_value_path_idx | index | postgres | jb | 306 MB |
public | jb_gin_idx | index | postgres | jb | 544 MB |
public | jb_path_value_idx | index | postgres | jb | 306 MB |
public | jb_path_idx | index | postgres | jb | 251 MB |

Jsquery (indexes)
explain( analyze,costs off) select count(*) from jb where jb @@ 'tags.#.term = "NYC"';
QUERY PLAN
-------------------------------------------------------------------------------------------------
-> Bitmap Heap Scan on jb (actual time=0.115..0.580 rows=285 loops=1)
Recheck Cond: (jb @@ '"tags".#."term" = "NYC"'::jsquery)
-> Bitmap Index Scan on jb_value_path_idx (actual time=0.073..0.073 rows=285 loops=1)
Index Cond: (jb @@ '"tags".#."term" = "NYC"'::jsquery)
(7 rows)

Jsquery (indexes)
explain( analyze,costs off) select count(*) from jb where jb @@ '*.term = "NYC"';
QUERY PLAN
-------------------------------------------------------------------------------------------------
Recheck Cond: (jb @@ '*."term" = "NYC"'::jsquery)
-> Bitmap Index Scan on jb_value_path_idx (actual time=0.113..0.113 rows=285 loops=1)
Index Cond: (jb @@ '*."term" = "NYC"'::jsquery)
(7 rows)

Citus dataset {
"customer_id": "AE22YDHSBFYIP",
"product_category": "Business & Investing",
"product_group": "Book",
"product_id": "1551803542",
"product_sales_rank": 11611,
"product_subcategory": "General",
"product_title": "Start and Run a Coffee Bar (Start & Run a)",
"review_date": {
"$date": 31363200000
},
"review_helpful_votes": 0,
"review_rating": 5,
"review_votes": 10,
"similar_product_ids": [
"0471136174",
"0910627312",
"047112138X",
"0786883561",
"0201570483"
]
}
• 3023162 reviews from Citus
1998-2000 years
• 1573 MB

Jsquery (indexes)
explain (analyze, costs off) select count(*) from jr where
jr @@ ' similar_product_ids && ["B000089778"]';
QUERY PLAN
------------------------------------------------------------------------------------------------
-> Bitmap Heap Scan on jr (actual time=0.084..0.337 rows=185 loops=1)
Recheck Cond: (jr @@ '"similar_product_ids" && ["B000089778"]'::jsquery)
-> Bitmap Index Scan on jr_path_value_idx (actual time=0.057..0.057 rows=185 loops=1)
Index Cond: (jr @@ '"similar_product_ids" && ["B000089778"]'::jsquery)
(7 rows)

Jsquery (indexes)
jr @@ ' similar_product_ids && ["B000089778"]
AND product_sales_rank( $ > 10000 AND $ < 20000)';
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------
Recheck Cond: (jr @@ '("similar_product_ids" && ["B000089778"] &
"product_sales_rank"($ > 10000 & $ < 20000))'::jsquery)
Index Cond: (jr @@ '("similar_product_ids" && ["B000089778"] &
"product_sales_rank"($ > 10000 & $ < 20000))'::jsquery)
Execution time: 129.309 ms !!! No statistics
(7 rows)
• No statistics, no planning :(
Not selective, better not use index!

MongoDB 2.6.0
db.reviews.find( { $and :[ {similar_product_ids: { $in:["B000089778"]}}, {product_sales_rank:{$gt:10000, $lt:20000}}] } )
.explain()
{
"n" : 45,
….................
"millis" : 7,
"indexBounds" : {
"similar_product_ids" : [ index size = 400 MB just for similar_product_ids !!!
[
"B000089778",
"B000089778"
]
]
},
}

Jsquery (indexes)
explain (analyze,costs off) select count(*) from jr where
jr @@ ' similar_product_ids && ["B000089778"]'
and (jr->>'product_sales_rank')::int>10000 and (jr->>'product_sales_rank')::int<20000;
-----------------------------------------------------------------------------------------------------------------------------------------
Filter: ((((jr ->> 'product_sales_rank'::text))::integer > 10000) AND
(((jr ->> 'product_sales_rank'::text))::integer < 20000))
Execution time: 0.506 ms Potentially, query could be faster Mongo !
(9 rows)
• If we rewrite query and use planner

Jsquery (optimizer) — NEW !
• Jsquery now has built-in simple optimiser.
jr @@ 'similar_product_ids && ["B000089778"]
AND product_sales_rank( $ > 10000 AND $ < 20000)'
------------------------------------------------------------------------------------------------------------------------------------------
Recheck Cond: (jr @@ '("similar_product_ids" && ["B000089778"] AND
"product_sales_rank"($ > 10000 AND $ < 20000))'::jsquery)
Rows Removed by Index Recheck: 140
Index Cond: (jr @@ '("similar_product_ids" && ["B000089778"] AND
Execution time: 0.480 ms vs 7 ms MongoDB !

• Since GIN opclasses can't expose something special to explain output,
jsquery optimiser has its own explain functions:
• text gin_debug_query_path_value(jsquery) — explain for jsonb_path_value_ops
# SELECT gin_debug_query_path_value('x = 1 AND (*.y = 1 OR y = 2)');
gin_debug_query_path_value
----------------------------
x = 1 , entry 0 +
• text gin_debug_query_value_path(jsquery) — explain for jsonb_value_path_ops
# SELECT gin_debug_query_value_path('x = 1 AND (*.y = 1 OR y = 2)');
gin_debug_query_value_path
----------------------------
AND +
x = 1 , entry 0 +
OR +
*.y = 1 , entry 1 +
y = 2 , entry 2 +

Jsquery now has built-in optimiser for simple queries.
Analyze query tree and push non-selective parts to recheck (like filter)
Selectivity classes:
1) Equality (x = c)
2) Range (c1 < x < c2)
3) Inequality (c > c1)
4) Is (x is type)
5) Any (x = *)

AND children can be put into recheck.
# SELECT gin_debug_query_path_value('x = 1 AND y > 0');
----------------------------
x = 1 , entry 0 +
While OR children can't. We can't handle false negatives.
# SELECT gin_debug_query_path_value('x = 1 OR y > 0');
----------------------------
OR +
x = 1 , entry 0 +
y > 0 , entry 1 +

Can't do much with NOT, because hash is lossy. After NOT false positives
turns into false negatives which we can't handle.
# SELECT gin_debug_query_path_value('x = 1 AND (NOT y = 0)');
----------------------------
x = 1 , entry 0 +

• Jsquery optimiser pushes non-selective operators to recheck
jr @@ 'similar_product_ids && ["B000089778"]
AND product_sales_rank( $ > 10000 AND $ < 20000)'
------------------------------------------------------------------------------------------------------------------------------------------
Recheck Cond: (jr @@ '("similar_product_ids" && ["B000089778"] AND
Rows Removed by Index Recheck: 140
Index Cond: (jr @@ '("similar_product_ids" && ["B000089778"] AND

Jsquery (HINTING) — NEW !
• Jsquery now has HINTING ( if you don't like optimiser)!
explain (analyze, costs off) select count(*) from jr where jr @@ 'product_sales_rank > 10000'
----------------------------------------------------------------------------------------------------------
Recheck Cond: (jr @@ '"product_sales_rank" > 10000'::jsquery)
-> Bitmap Index Scan on jr_path_value_idx (actual time=1052.483..1052.48
rows=2373140 loops=1)
Index Cond: (jr @@ '"product_sales_rank" > 10000'::jsquery)
• Better not to use index — HINT /* --noindex */
explain (analyze, costs off) select count(*) from jr where jr @@ 'product_sales_rank /*-- noindex */ > 10000';
----------------------------------------------------------------------------------
-> Seq Scan on jr (actual time=0.013..1222.123 rows=2373140 loops=1)
Filter: (jr @@ '"product_sales_rank" /*-- noindex */ > 10000'::jsquery)

Jsquery (HINTING) — NEW !
• If you know that inequality is selective then use HINT /* --index */
# explain (analyze, costs off) select count(*) from jr where jr @@ 'product_sales_rank /*-- index*/ > 3000000 AND
review_rating = 5'::jsquery;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------
Recheck Cond: (jr @@ '("product_sales_rank" /*-- index */ > 3000000 AND "review_rating" = 5)'::jsquery)
Index Cond: (jr @@ '("product_sales_rank" /*-- index */ > 3000000 AND "review_rating" = 5)'::jsquery)
Execution time: 12.359 ms vs 1709.901 ms (without hint)
(7 rows)

Contrib/jsquery
• Jsquery index support is quite efficient ( 0.5 ms vs Mongo 7 ms ! )
• Future direction
• Make jsquery planner friendly
• Need statistics for jsonb
• Availability
• Jsquery + opclasses are available as extensions
• Grab it from https://github.com/akorotkov/jsquery (branch master) ,
we need your feedback !
• We will release it after PostgreSQL 9.4 release
• Need real sample data and queries !

PostgreSQL 9.4+
●
Open-source
●
Relational database
●
Strong support of json

Better indexing ...
• Provide interface to change hardcoded B-tree in Entry tree
• Use spgist opclass for storing paths and values as is (strings hashed in values)
• We may go further - provide interface to change hardcoded B-tree in
posting tree
• GIS aware full text search !
• New index access method
CREATE INDEX … USING VODKA

GIN History
• Introduced at PostgreSQL Anniversary Meeting in Toronto, Jul 7-8, 2006
by Oleg Bartunov and Teodor Sigaev

GIN History
• Introduced at PostgreSQL Anniversary Meeting in Toronto, Jul 7-8, 2006
by Oleg Bartunov and Teodor Sigaev
• Supported by JFG Networks (France)
• «Gin stands for Generalized Inverted iNdex and should be considered as
a genie, not a drink.»
• Alexander Korotkov, Heikki Linnakangas have joined GIN++ development
in 2013

GIN History
TODO
----
Nearest future:
* Opclasses for all types (no programming, just many catalog changes).
Distant future:
* Replace B-tree of entries to something like GiST (VODKA ! 2014)
* Add multicolumn support
* Optimize insert operations (background index insertion)
• From GIN Readme, posted in -hackers, 2006-04-26

GIN index structure for jsonb
{
"product_sales_rank": 15000
},
{
"product_group": "Music",
}

Vodka index structure for jsonb
{
},
{
"product_group": "Music",
}

select count(*) from jb where jb @@ 'tags.#.term = "NYC"';
-------------------------------------------------------------------------------------------
Recheck Cond: (jb @@ '"tags".#."term" = "NYC"'::jsquery)
-> Bitmap Index Scan on jb_vodka_idx (actual time=0.108..0.108 rows=285 loops=1)
Index Cond: (jb @@ '"tags".#."term" = "NYC"'::jsquery)
Execution time: 0.456 ms (0.634 ms, GIN jsonb_value_path_ops)
select count(*) from jb where jb @@ '*.term = "NYC"';
-------------------------------------------------------------------------------------------
Recheck Cond: (jb @@ '*."term" = "NYC"'::jsquery)
-> Bitmap Index Scan on jb_vodka_idx (actual time=0.214..0.214 rows=285 loops=1)
Index Cond: (jb @@ '*."term" = "NYC"'::jsquery)
Execution time: 0.526 ms (0.716 ms, GIN jsonb_path_value_ops)

explain (analyze, costs off) select count(*) from jr where jr @@ ' similar_product_ids && ["B000089778"]';
QUERY PLAN
-------------------------------------------------------------------------------------------
-> Bitmap Index Scan on jr_vodka_idx (actual time=0.077..0.077 rows=185 loops=1)
Execution time: 0.237 ms (0.394 ms, GIN jsonb_path_value_idx)
(7 rows)

There are can be different flavors of Vodka

New VODKA concept
• Posting list/tree is just a way of
effective duplicate storage
• Entry tree can consist of
multiple levels of different
access methods
• VODKA is a way to combine
different access method in
single index: VODKA
CONNECTING INDEXES

JsQuery limitations
• Variables are always on the left size
x = 1 – OK
1 = x – Error!
• No calculations in query
x + y = 0 — Error!
• No extra datatypes and search operators
point(x,y) <@ '((0,0),(1,1),(2,1),(1,0))'::polygon

JsQuery limitations
Users want jsquery to be as rich as SQL...

JsQuery limitations
Users want jsquery to be as rich as SQL ...
… But we will discourage them ;)

JsQuery language goals
•Provide rich enough query language for jsonb in 9.4.
•Indexing support for 'jsonb @@ jsquery':
•Two GIN opclasses are in jsquery itself
•VODKA opclasses was tested on jsquery
It's NOT intended to be solution for jsonb querying in
long term!

What JsQuery is NOT?
It's not designed to be another extendable, full weight:
•Parser
•Executor
•Optimizer
It's NOT SQL inside SQL.

Jsonb querying an array: summary
Using «@>»
• Pro
• Cons
• Checks only equality for
scalars
• Hard to explain complex
logic
Using subselect and
jsonb_array_elements
• Pro
• SQL-rich
• Cons
• No indexing support
• Heavy syntax
JsQuery
• Pro
• Rich enough for typical
applications
• Cons
• Not extendable
Still looking for a better solution!

Jsonb query: future
Users want jsonb query language to be as rich
as SQL. How to satisfy them?..

Jsonb query: future
Users want jsonb query language to be as rich
as SQL. How to satisfy them?
Bring all required features to SQL-level!

Jsonb query: future
Functional equivalents:
• SELECT * FROM company WHERE EXISTS (SELECT 1
FROM jsonb_array_elements(js->'relationships') t
WHERE t->>'title' IN ('CEO', 'CTO') AND
t->'person'->>'first_name' = 'Neil');
• SELECT count(*) FROM company WHERE js @@ 'relationships(#.title
in ("CEO", "CTO") AND #.person.first_name = "Neil")'::jsquery;
• SELECT * FROM company WHERE
ANYELEMENT OF js-> 'relationships' AS t (
t->>'title' IN ('CEO', 'CTO') AND
t ->'person'->>'first_name' = 'Neil');

Jsonb query: ANYELEMENT
Possible implementation steps:
• Implement ANYELEMENT just as syntactic sugar and only for
arrays.
• Support for various data types (extendable?)
• Handle ANYLEMENT as expression not subselect (problem with
alias).
• Indexing support over ANYELEMENT expressions.

Another idea about ANYLEMENENT
Functional equivalents:
• SELECT t
FROM company,
LATERAL (SELECT t FROM
jsonb_array_elements(js->'relationships') t) el;
• SELECT t
FROM company,
ANYELEMENT OF js->'relationships' AS t;

Summary
• contrib/jsquery for 9.4
• Jsquery - Jsonb Query Language
• Two GIN opclasses with jsquery support
• Grab it from https://github.com/akorotkov/jsquery (branch master)
• Prototype of VODKA access method (supported by Heroku)
• New VODKA concept
• Idea of Jsonb querying in SQL

We invite to PGConf.RU in Moscow,
February 2015!

Jsquery - the jsonb query language with GIN indexing support

More Related Content

What's hot (20)

Similar to Jsquery - the jsonb query language with GIN indexing support (20)

More from Alexander Korotkov (6)

Recently uploaded (20)

Jsquery - the jsonb query language with GIN indexing support