Question

我正在开发一个应用程序来显示用户共享的内容，并且我使用PostgreSQL Arrays来处理安全模型。

我们支持公共和私人内容，我有两个需要优化的查询。从PostgreSQL文档中我需要在索引数组列时使用GIN索引，但我不能让PostgreSQL选择它们。

这是我的数据和索引定义：

-- Table: public.usershares

-- DROP TABLE public.usershares;

CREATE TABLE public.usershares
(
  id integer NOT NULL,
  title text,
  sharedcontent text,
  shared_on timestamp without time zone,
  roles text[],
  claims text[],
  users integer[],
  private boolean,
  CONSTRAINT pk_id PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);
ALTER TABLE public.usershares
  OWNER TO postgres;

-- Index: public.idx_arrays_private

-- DROP INDEX public.idx_arrays_private;

CREATE INDEX idx_arrays_private
  ON public.usershares
  USING gin
  (roles COLLATE pg_catalog."default", claims COLLATE pg_catalog."default", users)
  WHERE private = true AND claims <> '{}'::text[];

-- Index: public.idx_arrays_public

-- DROP INDEX public.idx_arrays_public;

CREATE INDEX idx_arrays_public
  ON public.usershares
  USING gin
  (roles COLLATE pg_catalog."default", users)
  WHERE private = false AND claims = '{}'::text[];

-- Index: public.idx_sharedon

-- DROP INDEX public.idx_sharedon;

CREATE INDEX idx_sharedon
  ON public.usershares
  USING btree
  (shared_on DESC);

-- Index: public.idx_sharedon_notprivate

-- DROP INDEX public.idx_sharedon_notprivate;

CREATE INDEX idx_sharedon_notprivate
  ON public.usershares
  USING btree
  (shared_on DESC)
  WHERE private = false;

-- Index: public.idx_sharedon_private

-- DROP INDEX public.idx_sharedon_private;

CREATE INDEX idx_sharedon_private
  ON public.usershares
  USING btree
  (shared_on DESC)
  WHERE private = true;

QUERY＃1：虽然我对此查询有一个部分GIN索引＆＃39; idx_arrays_private＆＃39;但PostgreSQL使用＆＃39; idx_sharedon_private＆＃39; （这也是部分索引，但不包括数组列（角色，声明和用户）

select *
from   usershares 
where  
    ( usershares.private = true 
         and usershares.claims != '{}' 
         and ( ( array['adminX'] && usershares.roles /* to see private content user has to belong to one of the roles */ 
                                and array['managerX'] <@ usershares.claims ) /* and have all the required claims */ 
                or array[]::integer[] && usershares.users /* or just be member of the list of authorized users */ ) ) 
order by shared_on desc
limit 100
offset 100;

QUERY＃2：虽然我对此查询也有一个部分GIN索引＆＃39; idx_arrays_public＆＃39;但PostgreSQL使用＆＃39; idx_sharedon_notprivate＆＃39; （这也是部分索引，但不包括数组列（角色，声明和用户）

select *
from   usershares 
where  
        ( usershares.private = false 
             and usershares.claims = '{}' 
             and ( array['admin'] && usershares.roles /* to see public content user has to belong to one of the roles  */ 
                                   or array[1,2,3,4,5] && usershares.users /* or be a member of the list of authorized users */
                  ) ) 
order by shared_on desc
limit 100
offset 100;

生成测试数据的脚本：

TRUNCATE TABLE usershares; 

INSERT INTO usershares 
            (id, 
             title, 
             sharedcontent, 
             shared_on, 
             roles, 
             claims, 
             users, 
             private) 
SELECT x.id, 
       'title #' 
       || x.id, 
       'content #' 
       || x.id, 
       Now(), 
       array['admin','registered'], 
       '{}', 
       '{}', 
       false 
FROM   Generate_series(1, 500000) AS x(id); 

INSERT INTO usershares 
            (id, 
             title, 
             sharedcontent, 
             shared_on, 
             roles, 
             claims, 
             users, 
             private) 
SELECT x.id, 
       'title #' 
       || x.id, 
       'content #' 
       || x.id, 
       Now(), 
       array['admin','registered'], 
       array['manager', 'director'], 
       array[1,2,3,4,5,6,7,8,9,10], 
       true 
FROM   Generate_series(500001, 750000) AS x(id); 

INSERT INTO usershares 
            (id, 
             title, 
             sharedcontent, 
             shared_on, 
             roles, 
             claims, 
             users, 
             private) 
SELECT x.id, 
       'title #' 
       || x.id, 
       'content #' 
       || x.id, 
       Now(), 
       array['adminX','registeredX'], 
       array['managerX', 'directorX'], 
       '{}', 
       true 
FROM   Generate_series(750001, 1000000) AS x(id);

Answer 1

这似乎是两个因素的结合。

首先，考虑到测试数据的分布，规划人员知道指数不是很有选择性;例如，claims='{}' and array['admin'] && roles只将其缩小到表的50％，此时索引遍历可能不比堆扫描好。它也可以根据private=false条件消除尽可能多的行，只需从部分shared_on索引中提取每条记录（这似乎是第二次查询的首选方法）。

其次，LIMIT子句意味着在过滤之前进行排序通常会更有效。在查询＃1中使用GIN索引意味着找到所有250,000个匹配记录，对它们进行排序，然后丢弃最后的249,800。另一种方法是逐个从shared_on索引中提取记录，直到找到200个匹配项。

因此，考虑到具体情况，它只是选择它认为最有效的方法。并且很难与结果争论;对我来说，第一个查询使用GIN索引需要140ms，使用B树需要0.3ms。

鉴于匹配记录的比例较低，数组索引成为一个更有效的过滤器，并且预先进行排序变得不太可行（通过有效随机抽样定位200个匹配可能需要更长的时间......）。在最终插入中有10,000条记录而不是250,000条，查询＃1始终选择GIN索引。

数组上的PostgreSQL GIN索引

1 个答案: