该函数返回子数组sub的数组arr中的索引，如果arr不包含sub，则返回0：

create or replace function index_of_subarray(arr anyarray, sub anyarray)
returns integer language plpgsql immutable as $$
begin
    for i in 1 .. cardinality(arr)- cardinality(sub)+ 1 loop
        if arr[i:i+ cardinality(sub)- 1] = sub then
            return i;
        end if;
    end loop;
    return 0;
end $$;

字符串
用途：

with my_table(e1, e2) as (
values
    ('{a,b,c,d}'::text[], '{1,2,3,4}'::int[]),
    ('{b,c,d,a}', '{1,2,3,4}'),
    ('{c,d}', '{3,4}'),
    ('{b,c,d}', '{2,3,4}')
)

select e1, e2
from my_table
where index_of_subarray(e1, '{b,c,d}') > 0 
and index_of_subarray(e1, '{b,c,d}') = index_of_subarray(e2, '{2,3,4}')

    e1     |    e2     
-----------+-----------
 {a,b,c,d} | {1,2,3,4}
 {b,c,d}   | {2,3,4}
(2 rows)

型

根据具体情况，您可以从数组中创建一个字符串，并使用regex/like查询它。
这听起来像是一个天真的方法，结果比接受答案的plpgsql函数更快。至少在以下情况下：

drop table if exists temp;
create table temp as
  SELECT array[
    chr((floor(random()*26) + 65)::int),
    chr((floor(random()*26) + 65)::int),
    chr((floor(random()*26) + 65)::int),
    chr((floor(random()*26) + 65)::int),
    chr((floor(random()*26) + 65)::int),
    chr((floor(random()*26) + 65)::int)
    ] as a FROM GENERATE_SERIES(1, 1000000);

字符串
用Like查询

\timing

select count(*) from temp
where array_to_string(a, '>>') like '%A>>B%';
 count
-------
  7505
(1 row)

Time: 270,404 ms

型
查询函数

select count(*) from temp
where index_of_subarray (a, array['A', 'B']) != 0;
 count
-------
  7505
(1 row)

Time: 1999,002 ms (00:01,999)

型
当您需要匹配通配符时，性能上的差异变得更加明显：

select count(*) from temp
where array_to_string(a, '>>') like '%A>>B%>>C>>D%';
 count
-------
     7
(1 row)

Time: 173,343 ms

型
与功能

select count(*) from temp
where index_of_subarray (a, array['A', 'B']) != 0
and index_of_subarray (a, array['A', 'B']) < index_of_subarray (a, array['C', 'D']);
 count
-------
     7
(1 row)

Time: 1999,791 ms (00:02,000)

型
我对表现上的差异感到惊讶。
也许是因为plpgsql比Regex的原生实现慢得多，后者很可能是非常优化的。
也许在所创建的测试情况中有一些特殊的东西导致了性能上的优势。
此外，为了使字符串化解决方案可靠，您需要为array_to_string提供一个不在数组元素中出现的字符串。在某些情况下，这可能不可行。
但除此之外，你可以考虑从数组中创建一个字符串，并用like/regex查询它。