Проблема

Примітка. Я маю на увазі математичні послідовності , а не механізм послідовностей PostgreSQL .

У мене є таблиця, що представляє послідовності цілих чисел. Визначення таке:

CREATE TABLE sequences
(
  id serial NOT NULL,
  title character varying(255) NOT NULL,
  date date NOT NULL,
  sequence integer[] NOT NULL,
  CONSTRAINT "PRIM_KEY_SEQUENCES" PRIMARY KEY (id)
);

Моя мета - знайти рядки за допомогою заданої послідовності. Тобто, рядки, де sequenceполе - це послідовність, яка містить задану послідовність (у моєму випадку послідовність послідовностей).

Приклад

Припустимо, таблиця містить такі дані:

+----+-------+------------+-------------------------------+
| id | title |    date    |           sequence            |
+----+-------+------------+-------------------------------+
|  1 | BG703 | 2004-12-24 | {1,3,17,25,377,424,242,1234}  |
|  2 | BG256 | 2005-05-11 | {5,7,12,742,225,547,2142,223} |
|  3 | BD404 | 2004-10-13 | {3,4,12,5698,526}             |
|  4 | BK956 | 2004-08-17 | {12,4,3,17,25,377,456,25}     |
+----+-------+------------+-------------------------------+

Отже, якщо дана підрядність є {12, 742, 225, 547}, я хочу знайти рядок 2.

Точно так само, якщо дана підрядність є {3, 17, 25, 377}, я хочу знайти рядок 1 і рядок 4.

Нарешті, якщо дана підрядність є {12, 4, 3, 25, 377}, то рядки не повертаються.

Розслідування

По-перше, я не зовсім впевнений, що мудрі представляють послідовності з типом даних масиву. Хоча це видається відповідним ситуації; Я боюся, що це ускладнює обробку. Можливо, краще представити послідовності по-різному, використовуючи модель відносин з іншою таблицею.

Таким же чином я думаю про розширення послідовностей за допомогою функції unnestмасиву, а потім додаю свої критерії пошуку. Тим не менш, кількість термінів у послідовності, що змінюється, я не бачу, як це зробити.

Я знаю, що також можна в подальшому скоротити мою послідовність за допомогою subarrayфункції модуля intarray, але я не бачу, як це моє користь для мого пошуку.

Обмеження

Навіть якщо на даний момент моя модель ще розробляється, таблиця повинна складатися з безлічі послідовностей, між 50 000 і 300 000 рядків. Тож у мене сильне обмеження в роботі.

У своєму прикладі я використовував відносно невеликі цілі числа. На практиці можливо, ці цілі числа стають набагато більшими, аж до переповнення bigint. У такій ситуації я думаю, що найкраще - зберігати числа як рядки (оскільки виконувати ці послідовності математичних операцій не потрібно). Однак, вибравши це рішення, це унеможливлює використання модуля intarray , згаданого вище.

Якщо ви шукаєте значних покращень продуктивності для відповіді dnoeth , подумайте про використання нативного C-функції та створення відповідного оператора.

Ось приклад для масивів int4. ( Загальний варіант масиву та відповідний сценарій SQL ).

Datum
_int_sequence_contained(PG_FUNCTION_ARGS)
{
    return DirectFunctionCall2(_int_contains_sequence,
                               PG_GETARG_DATUM(1),
                               PG_GETARG_DATUM(0));
}

Datum
_int_contains_sequence(PG_FUNCTION_ARGS)
{
    ArrayType  *a = PG_GETARG_ARRAYTYPE_P(0);
    ArrayType  *b = PG_GETARG_ARRAYTYPE_P(1);
    int         na, nb;
    int32      *pa, *pb;
    int         i, j;

    na = ArrayGetNItems(ARR_NDIM(a), ARR_DIMS(a));
    nb = ArrayGetNItems(ARR_NDIM(b), ARR_DIMS(b));
    pa = (int32 *) ARR_DATA_PTR(a);
    pb = (int32 *) ARR_DATA_PTR(b);

    /* The naive searching algorithm. Replace it with a better one if your arrays are quite large. */
    for (i = 0; i <= na - nb; ++i)
    {
        for (j = 0; j < nb; ++j)
            if (pa[i + j] != pb[j])
                break;

        if (j == nb)
            PG_RETURN_BOOL(true);
    }

    PG_RETURN_BOOL(false);
}

CREATE FUNCTION _int_contains_sequence(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;

CREATE FUNCTION _int_sequence_contained(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;

CREATE OPERATOR @@> (
  LEFTARG = _int4,
  RIGHTARG = _int4,
  PROCEDURE = _int_contains_sequence,
  COMMUTATOR = '<@@',
  RESTRICT = contsel,
  JOIN = contjoinsel
);

CREATE OPERATOR <@@ (
  LEFTARG = _int4,
  RIGHTARG = _int4,
  PROCEDURE = _int_sequence_contained,
  COMMUTATOR = '@@>',
  RESTRICT = contsel,
  JOIN = contjoinsel
);

Тепер ви можете фільтрувати такі рядки.

SELECT * FROM sequences WHERE sequence @@> '{12, 742, 225, 547}'

Я провів невеликий експеримент, щоб знайти, наскільки швидше це рішення.

CREATE TEMPORARY TABLE sequences AS
SELECT array_agg((random() * 10)::int4) AS sequence, g1 AS id
FROM generate_series(1, 100000) g1
  CROSS JOIN generate_series(1, 30) g2
GROUP BY g1;

EXPLAIN ANALYZE SELECT * FROM sequences
WHERE        translate(cast(sequence as text), '{}',',,')
 LIKE '%' || translate(cast('{1,2,3,4}'as text), '{}',',,') || '%'

"Seq Scan on sequences  (cost=0.00..7869.42 rows=28 width=36) (actual time=2.487..334.318 rows=251 loops=1)"
"  Filter: (translate((sequence)::text, '{}'::text, ',,'::text) ~~ '%,1,2,3,4,%'::text)"
"  Rows Removed by Filter: 99749"
"Planning time: 0.104 ms"
"Execution time: 334.365 ms"

EXPLAIN ANALYZE SELECT * FROM sequences WHERE sequence @@> '{1,2,3,4}'

"Seq Scan on sequences  (cost=0.00..5752.01 rows=282 width=36) (actual time=0.178..20.792 rows=251 loops=1)"
"  Filter: (sequence @@> '{1,2,3,4}'::integer[])"
"  Rows Removed by Filter: 99749"
"Planning time: 0.091 ms"
"Execution time: 20.859 ms"

Отже, це приблизно в 16 разів швидше. Якщо цього недостатньо, ви можете додати підтримку індексів GIN або GiST, але це буде набагато складніше завдання.

Ви можете легко знайти підпорядкованість, коли накидаєте масиви на рядки та заміните фігурні дужки комами:

translate(cast(sequence as varchar(10000)), '{}',',,')

{1,3,17,25,377,424,242,1234} -> ',1,3,17,25,377,424,242,1234,'

Зробіть те ж саме для масиву, який ви шукаєте, і додайте ведучий та кінцевий %:

'%' || translate(cast(searchedarray as varchar(10000)), '{}',',,') || '%'

{3, 17, 25, 377} -> '%,3,17,25,377,%'

Тепер ви порівнюєте його, використовуючи LIKE:

WHERE        translate(cast(sequence      as varchar(10000)), '{}',',,')
 LIKE '%' || translate(cast(searchedarray as varchar(10000)), '{}',',,') || '%'

Редагувати:

Фіддель знову працює.

Якщо масиви нормалізуються в один рядок за значенням, ви можете застосувати задану логіку:

CREATE TABLE sequences
( id int NOT NULL,
  n int not null,
  val numeric not null
);

insert into sequences values(  1, 1,1     );
insert into sequences values(  1, 2,3     );
insert into sequences values(  1, 3,17    );
insert into sequences values(  1, 4,25    );
insert into sequences values(  1, 5,377   );
insert into sequences values(  1, 6,424   );
insert into sequences values(  1, 7,242   );
insert into sequences values(  1, 8,1234  );
insert into sequences values(  2, 1,5     );
insert into sequences values(  2, 2,7     );
insert into sequences values(  2, 3,12    );
insert into sequences values(  2, 4,742   );
insert into sequences values(  2, 5,225   );
insert into sequences values(  2, 6,547   );
insert into sequences values(  2, 7,2142  );
insert into sequences values(  2, 8,223   );
insert into sequences values(  3, 1,3     );
insert into sequences values(  3, 2,4     );
insert into sequences values(  3, 3,12    );
insert into sequences values(  3, 4,5698  );
insert into sequences values(  3, 5,526   );          
insert into sequences values(  4, 1,12    );
insert into sequences values(  4, 2,4     );
insert into sequences values(  4, 3,3     );
insert into sequences values(  4, 4,17    );
insert into sequences values(  4, 5,25    );
insert into sequences values(  4, 6,377   );
insert into sequences values(  4, 7,456   );
insert into sequences values(  4, 8,25    );
insert into sequences values(  5, 1,12    );
insert into sequences values(  5, 2,4     );
insert into sequences values(  5, 3,3     );
insert into sequences values(  5, 4,17    );
insert into sequences values(  5, 5,17    );
insert into sequences values(  5, 6,25    );
insert into sequences values(  5, 7,377   );
insert into sequences values(  5, 8,456   );
insert into sequences values(  5, 9,25    );

nповинні бути послідовними, без дублікатів, без прогалин. Тепер приєднуйтесь до загальних цінностей і використовуйте той факт, що послідовності є послідовними :-)

with searched (n,val) as (
  VALUES
   ( 1,3  ),
   ( 2,17 ),
   ( 3,25 ),
   ( 4,377)
)
select seq.id, 
   -- this will return the same result if the values from both tables are in the same order
   -- it's a meaningless dummy, but the same meaningless value for sequential rows 
   seq.n - s.n as dummy,
   seq.val,
   seq.n,
   s.n 
from sequences as seq join searched as s
on seq.val = s.val
order by seq.id, dummy, seq.n;

Нарешті порахуйте кількість рядків з однаковою манекеном і перевірте, чи це правильне число:

with searched (n,val) as (
  VALUES
   ( 1,3  ),
   ( 2,17 ),
   ( 3,25 ),
   ( 4,377)
)
select distinct seq.id
from sequences as seq join searched as s
on seq.val = s.val
group by 
   seq.id,
   seq.n - s.n
having count(*) = (select count(*) from searched)
;

Спробуйте індекс на послідовності (val, id, n).