我尝试了一个普通的Postgres gin索引以及pg_trgm gin_trgm_ops和gist_trgm_ops索引（使用此解决方法：https://stackoverflow.com/a/33016333/283398）。
然而，我的查询'term' % ANY (array_column)上的EXPLAIN即使在执行set enable_seqscan = off;之后也会显示顺序扫描。
（对于我的用例，我需要部分匹配，而pg_trgm似乎比全文搜索更合适，因为我的数据不是语言。我的pg_trgm结果的质量非常好。）
我的用例是带有数组列的行，其中包含名字和全名（空格分隔）的混合。搜索词可以是第一个，最后一个或全名（以空格分隔）。 pg_trgm％运算符结果不区分大小写，并且在数组列中的名称的开头和结尾处显示高度匹配，这对于全名来说非常有用，因为它找到匹配的名字和姓氏，但不一定是中间名。
https://github.com/theirix/parray_gin很有前途，但很老，并没有声称支持Postgres比9.2更新。
答案 0 :(得分：7)
索引类型（即运算符类）gin_trgm_ops基于%运算符，该运算符适用于两个text参数：
CREATE OPERATOR trgm.%(
PROCEDURE = trgm.similarity_op,
LEFTARG = text,
RIGHTARG = text,
COMMUTATOR = %,
RESTRICT = contsel,
JOIN = contjoinsel);
您不能将gin_trgm_ops用于数组。
为数组列定义的索引永远不会与any(array[...])一起使用，因为数组的各个元素未编入索引。
索引数组需要不同类型的索引，即gin数组索引。
幸运的是，索引gin_trgm_ops的设计非常巧妙，它正在与运算符like和ilike一起使用，可以用作替代解决方案（如下所示）。 / p>
有两列(id serial primary key, names text[])，包含分为数组元素的100000个拉丁语句子。
select count(*), sum(cardinality(names))::int words from test;
count | words
--------+---------
100000 | 1799389
select * from test limit 1;
id | names
----+---------------------------------------------------------------------------------------------------------------
1 | {fugiat,odio,aut,quis,dolorem,exercitationem,fugiat,voluptates,facere,error,debitis,ut,nam,et,voluptatem,eum}
搜索单词片段praesent在2400毫秒内提供7051行：
explain analyse
select count(*)
from test
where 'praesent' % any(names);
QUERY PLAN
---------------------------------------------------------------------------------------------------------------
Aggregate (cost=5479.49..5479.50 rows=1 width=0) (actual time=2400.866..2400.866 rows=1 loops=1)
-> Seq Scan on test (cost=0.00..5477.00 rows=996 width=0) (actual time=1.464..2400.271 rows=7051 loops=1)
Filter: ('praesent'::text % ANY (names))
Rows Removed by Filter: 92949
Planning time: 1.038 ms
Execution time: 2400.916 ms
一种解决方案是规范化模型，包括在一行中创建一个具有单个名称的新表。由于现有的查询，视图，功能或其他依赖性，这种重组可能难以实现并且有时是不可能的。使用物化视图可以在不改变表结构的情况下实现类似的效果。
create materialized view test_names as
select id, name, name_id
from test
cross join unnest(names) with ordinality u(name, name_id)
with data;
With ordinality不是必需的，但在按照与主表中相同的顺序聚合名称时非常有用。查询test_names会在同一时间提供与主表相同的结果。
创建索引后，执行时间反复减少：
create index on test_names using gin (name gin_trgm_ops);
explain analyse
select count(distinct id)
from test_names
where 'praesent' % name
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------
Aggregate (cost=4888.89..4888.90 rows=1 width=4) (actual time=56.045..56.045 rows=1 loops=1)
-> Bitmap Heap Scan on test_names (cost=141.95..4884.39 rows=1799 width=4) (actual time=10.513..54.987 rows=7230 loops=1)
Recheck Cond: ('praesent'::text % name)
Rows Removed by Index Recheck: 7219
Heap Blocks: exact=8122
-> Bitmap Index Scan on test_names_name_idx (cost=0.00..141.50 rows=1799 width=0) (actual time=9.512..9.512 rows=14449 loops=1)
Index Cond: ('praesent'::text % name)
Planning time: 2.990 ms
Execution time: 56.521 ms
解决方案有一些缺点。由于视图已实现，因此数据将在数据库中存储两次。您必须记住在更改主表后刷新视图。由于需要将视图连接到主表，查询可能会更复杂。
ilike 我们可以在表示为文本的数组上使用ilike。我们需要一个不可变函数来在整个数组上创建索引：
create function text(text[])
returns text language sql immutable as
$$ select $1::text $$
create index on test using gin (text(names) gin_trgm_ops);
并在查询中使用该函数：
explain analyse
select count(*)
from test
where text(names) ilike '%praesent%'
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
Aggregate (cost=117.06..117.07 rows=1 width=0) (actual time=60.585..60.585 rows=1 loops=1)
-> Bitmap Heap Scan on test (cost=76.08..117.03 rows=10 width=0) (actual time=2.560..60.161 rows=7051 loops=1)
Recheck Cond: (text(names) ~~* '%praesent%'::text)
Heap Blocks: exact=2899
-> Bitmap Index Scan on test_text_idx (cost=0.00..76.08 rows=10 width=0) (actual time=2.160..2.160 rows=7051 loops=1)
Index Cond: (text(names) ~~* '%praesent%'::text)
Planning time: 3.301 ms
Execution time: 60.876 ms
60与2400毫秒，相当不错的结果，无需创建额外的关系。
这个解决方案似乎更简单，只需要更少的工作，但是ilike是一个比trgm %运算符更精确的工具就足够了。
为什么我们应该将ilike而不是%用于整个数组作为文本？
相似性在很大程度上取决于文本的长度。
在不同长度的长文本中搜索单词是非常困难的。
例如。使用limit = 0.3，我们得到了结果：
with data(txt) as (
values
('praesentium,distinctio,modi,nulla,commodi,tempore'),
('praesentium,distinctio,modi,nulla,commodi'),
('praesentium,distinctio,modi,nulla'),
('praesentium,distinctio,modi'),
('praesentium,distinctio'),
('praesentium')
)
select length(txt), similarity('praesent', txt), 'praesent' % txt "matched?"
from data;
length | similarity | matched?
--------+------------+----------
49 | 0.166667 | f <--!
41 | 0.2 | f <--!
33 | 0.228571 | f <--!
27 | 0.275862 | f <--!
22 | 0.333333 | t
11 | 0.615385 | t
(6 rows)
答案 1 :(得分：3)
我创建了一个测试表和一个名为 f 的函数，只转换为文本。
RttiType := TRttiContext.Create.GetType(AInterface);
cast 函数：
CREATE OR REPLACE FUNCTION getNArray(el text[], count int) RETURNS text[] AS $$
SELECT array_agg(el[random()*(array_length(el,1)-1)+1]) FROM generate_series(1,count) g(i)
$$
VOLATILE
LANGUAGE SQL;
DROP TABLE testGin;
CREATE TABLE testGin(id serial PRIMARY KEY, array_column text[]);
WITH t(ray) AS(
SELECT (string_to_array(pg_read_file('words.list')::text,E'\n'))
)
INSERT INTO testGin(array_column)
SELECT getNArray(T.ray, 4) FROM T, generate_series(1,100000);
ILIKE的用法：
CREATE OR REPLACE FUNCTION f(arr text[]) RETURNS text AS $$
SELECT arr::text
LANGUAGE SQL IMMUTABLE;
CREATE INDEX ON testGin USING GIN(f(array_column) gin_trgm_ops);
如果您希望通过包含％运算符进行更准确的搜索，则可以执行以下操作：这将扫描索引然后，它将应用您的过滤器：
postgres=# EXPLAIN SELECT id FROM testgin WHERE f(array_column) ilike '%test%';
QUERY PLAN
-------------------------------------------------------------------------------
Bitmap Heap Scan on testgin (cost=34.82..1669.63 rows=880 width=4)
Recheck Cond: (f(array_column) ~~* '%test%'::text)
-> Bitmap Index Scan on testgin_f_idx (cost=0.00..34.60 rows=880 width=0)
Index Cond: (f(array_column) ~~* '%test%'::text)
(4 rows)