Problema

Nota: mi riferisco alle sequenze matematiche , non al meccanismo delle sequenze di PostgreSQL .

Ho una tabella che rappresenta sequenze di numeri interi. La definizione è:

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)
);

Il mio obiettivo è trovare le righe usando una data sottosequenza. Vale a dire, le righe in cui il sequencecampo è una sequenza che contiene la sottosequenza data (nel mio caso, la sequenza è ordinata).

Esempio

Supponiamo che la tabella contenga i seguenti dati:

+----+-------+------------+-------------------------------+
| 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}     |
+----+-------+------------+-------------------------------+

Quindi, se la sottosequenza data è {12, 742, 225, 547}, voglio trovare la riga 2.

Allo stesso modo, se la sottosequenza data è {3, 17, 25, 377}, voglio trovare la riga 1 e la riga 4.

Infine, se la sottosequenza data è {12, 4, 3, 25, 377}, allora non ci sono righe restituite.

indagini

Innanzitutto, non sono del tutto sicuro che rappresentare sequenze con un tipo di dati array sia saggio. Anche se questo sembra appropriato alla situazione; Temo che renda la gestione più complicata. Forse è meglio rappresentare le sequenze in modo diverso, usando un modello di relazioni con un'altra tabella.

Allo stesso modo, penso di espandere le sequenze usando la unnestfunzione array e quindi aggiungere i miei criteri di ricerca. Tuttavia, il numero di termini nella sequenza essendo variabile non vedo come farlo.

So che è anche possibile tagliare la mia sequenza in sottosequenza usando la subarrayfunzione del modulo intarray ma non vedo come mi avvantaggia la mia ricerca.

vincoli

Anche se al momento il mio modello è ancora in fase di sviluppo, la tabella dovrebbe essere composta da molte sequenze, tra 50.000 e 300.000 righe. Quindi ho un forte vincolo di prestazioni.

Nel mio esempio ho usato numeri interi relativamente piccoli. In pratica, è possibile che questi numeri interi diventino molto più grandi, fino a traboccare bigint. In una situazione del genere, penso che il migliore sia memorizzare numeri come stringhe (poiché non è necessario eseguire queste sequenze di operazioni matematiche). Tuttavia, optando per questa soluzione, ciò rende impossibile utilizzare il modulo intarray , menzionato sopra.

Se stai cercando miglioramenti significativi delle prestazioni della risposta di Dnoeth , considera l'utilizzo di una funzione C nativa e la creazione dell'operatore appropriato.

Ecco un esempio per le matrici int4. ( Una variante di matrice generica e lo script SQL corrispondente ).

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
);

Ora puoi filtrare le righe in questo modo.

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

Ho condotto un piccolo esperimento per scoprire quanto è più veloce questa soluzione.

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"

Quindi, è circa 16 volte più veloce. Se non è abbastanza, puoi aggiungere il supporto per gli indici GIN o GiST, ma questo sarà un compito molto più difficile.

È possibile trovare facilmente la sottosequenza quando si eseguono il cast degli array in stringhe e si sostituiscono le parentesi graffe con virgole:

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

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

Fai lo stesso per l'array che stai cercando e aggiungi un carattere iniziale e finale %:

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

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

Ora lo confronti usando LIKE:

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

Modificare:

Fiddle sta di nuovo lavorando.

Se le matrici sono normalizzate in una riga per valore, è possibile applicare la logica basata su set:

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    );

ndeve essere sequenziale, senza duplicati, senza spazi vuoti. Ora unisciti a valori comuni e sfrutta il fatto che le sequenze sono sequenziali :-)

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;

Infine conta il numero di righe con lo stesso manichino e controlla se è il numero corretto:

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)
;

Prova un indice sulle sequenze (val, id, n).