Speed up range test for key values nested in jsonb array of objects

问题

Suppose I have the following parents table:

create table parents (
  id       integer not null constraint parents_pkey primary key,
  name     text    not null,
  children jsonb   not null
);

Where children is a json array of the following structure:

[
    {
        "name": "child1",
        "age": 10
    }, 
    {
        "name": "child2",
        "age": 12
    } 
]

And I need, for example, to get all parents that have children with age between 10 and 12.

I create the following query:

select distinct
  p.*
from
  parents p, jsonb_array_elements(p.children) c
where
  (c->>'age')::int between 10 and 12;

It works well but very slowly when the table parents is big (for example 1M records). I tried to use 'gin' index on children field but this did not help.

So is there a way to speed up such queries? Or maybe there is another solution to make queries/indexes against fields in the nested json arrays?

Query plan:

Unique  (cost=1793091.18..1803091.18 rows=1000000 width=306) (actual time=4070.866..5106.998 rows=399947 loops=1)
  ->  Sort  (cost=1793091.18..1795591.18 rows=1000000 width=306) (actual time=4070.864..4836.241 rows=497313 loops=1)
        Sort Key: p.id, p.children, p.name
        Sort Method: external merge  Disk: 186040kB
        ->  Gather  (cost=1000.00..1406321.34 rows=1000000 width=306) (actual time=0.892..1354.147 rows=497313 loops=1)
              Workers Planned: 2
              Workers Launched: 2
              ->  Nested Loop  (cost=0.00..1305321.34 rows=416667 width=306) (actual time=0.162..1794.134 rows=165771 loops=3)
                    ->  Parallel Seq Scan on parents p  (cost=0.00..51153.67 rows=416667 width=306) (actual time=0.075..239.786 rows=333333 loops=3)
                    ->  Function Scan on jsonb_array_elements c  (cost=0.00..3.00 rows=1 width=0) (actual time=0.004..0.004 rows=0 loops=1000000)
                          Filter: ((((value ->> 'age'::text))::integer >= 10) AND (((value ->> 'age'::text))::integer <= 12))
                          Rows Removed by Filter: 3
Planning time: 0.218 ms
Execution time: 5140.277 ms

回答1:

A first immediate measure would be to make the query you have a bit faster:

SELECT *
FROM   parents p
WHERE  EXISTS (
   SELECT FROM jsonb_array_elements(p.children) c
   WHERE (c->>'age')::int BETWEEN 10 AND 12
   );

The EXISTS semi-join avoids duplication of rows in the intermediate table when multiple array objects match - and the need for DISTINCT ON in the outer query. But that's only mildly faster, yet.

The core problem is that you want to test for a range of integer values, while existing jsonb operators do not provide such functionality.

There are various ways around this. Not knowing any of this, here is a "smart" solution that solves the given example. The trick is to split the range to distinct values and use the jsonb containment operator @>:

SELECT *
FROM   parents p
WHERE (p.children @> '[{"age": 10}]'
OR     p.children @> '[{"age": 11}]'
OR     p.children @> '[{"age": 12}]');

Supported by a jsonb_path_ops GIN index:

CREATE INDEX parents_children_gin_idx ON parents USING gin (children jsonb_path_ops);

But if your ranges span more than a hand full of integer values, you'll need something more generic. As always, the best solution depends on the complete situation: Data distribution, value frequencies, typical ranges in queries, NULL values possible?, row size, read/write patterns, does every jsonb value have one or more matching age key? ...

Related answer with specialized, very fast index:

• Search for nested values in jsonb array with greater operator

Related:

• Index for finding an element in a JSON array
• Using indexes in json array in PostgreSQL

回答2:

I suggest you try this way (this is from my experience).

WITH t AS (SELECT id, jsonb_array_elements(children) as child_data FROM parents)
SELECT *  
  FROM parents 
 WHERE id IN (
              SELECT id
                FROM t
               WHERE (child_data->>'age')::int between 10 and 12
           )

Hopefully it works.

来源：https://stackoverflow.com/questions/49532773/speed-up-range-test-for-key-values-nested-in-jsonb-array-of-objects