Ho una tabella (in PostgreSQL 9.4) che assomiglia a questa:

CREATE TABLE dates_ranges (kind int, start_date date, end_date date);
INSERT INTO dates_ranges VALUES 
    (1, '2018-01-01', '2018-01-31'),
    (1, '2018-01-01', '2018-01-05'),
    (1, '2018-01-03', '2018-01-06'),
    (2, '2018-01-01', '2018-01-01'),
    (2, '2018-01-01', '2018-01-02'),
    (3, '2018-01-02', '2018-01-08'),
    (3, '2018-01-05', '2018-01-10');

Ora voglio calcolare per le date date e per ogni tipo, in quante righe dates_rangescadono da ciascuna data. Gli zeri potrebbero essere eventualmente omessi.

Risultato desiderato:

+-------+------------+----+
|  kind | as_of_date |  n |
+-------+------------+----+
|     1 | 2018-01-01 |  2 |
|     1 | 2018-01-02 |  2 |
|     1 | 2018-01-03 |  3 |
|     2 | 2018-01-01 |  2 |
|     2 | 2018-01-02 |  1 |
|     3 | 2018-01-02 |  1 |
|     3 | 2018-01-03 |  1 |
+-------+------------+----+

Ho escogitato due soluzioni, una con LEFT JOINeGROUP BY

SELECT
kind, as_of_date, COUNT(*) n
FROM
    (SELECT d::date AS as_of_date FROM generate_series('2018-01-01'::timestamp, '2018-01-03'::timestamp, '1 day') d) dates
LEFT JOIN
    dates_ranges ON dates.as_of_date BETWEEN start_date AND end_date
GROUP BY 1,2 ORDER BY 1,2

e uno con LATERAL, che è leggermente più veloce:

SELECT
    kind, as_of_date, n
FROM
    (SELECT d::date AS as_of_date FROM generate_series('2018-01-01'::timestamp, '2018-01-03'::timestamp, '1 day') d) dates,
LATERAL
    (SELECT kind, COUNT(*) AS n FROM dates_ranges WHERE dates.as_of_date BETWEEN start_date AND end_date GROUP BY kind) ss
ORDER BY kind, as_of_date

Mi chiedo: è un modo migliore per scrivere questa query? E come includere coppie tipo-data con 0 conteggi?

In realtà ci sono alcuni tipi distinti, periodo fino a cinque anni (1800 date) e ~ 30k righe nella dates_rangestabella (ma potrebbe crescere in modo significativo).

Non ci sono indici Per essere precisi nel mio caso è il risultato di una query secondaria, ma ho voluto limitare la domanda a un problema, quindi è più generale.

La seguente query funziona anche se "zero mancanti" sono OK:

select *
from (
  select
    kind,
    generate_series(start_date, end_date, interval '1 day')::date as d,
    count(*)
  from dates_ranges
  group by 1, 2
) x
where d between date '2018-01-01' and date '2018-01-03'
order by 1, 2;

ma non è più veloce della lateralversione con il piccolo set di dati. Potrebbe ridimensionarsi meglio, poiché non è richiesto alcun join, ma la versione precedente si aggrega su tutte le righe, quindi potrebbe perdere di nuovo.

La query seguente cerca di evitare lavori inutili rimuovendo qualsiasi serie che non si sovrapponga comunque:

select
  kind,
  generate_series(greatest(start_date, date '2018-01-01'), least(end_date, date '2018-01-03'), interval '1 day')::date as d,
  count(*)
from dates_ranges
where (start_date, end_date + interval '1 day') overlaps (date '2018-01-01', date '2018-01-03' + interval '1 day')
group by 1, 2
order by 1, 2;

- e devo usare l' overlapsoperatore! Si noti che è necessario aggiungere interval '1 day'a destra poiché l'operatore di sovrapposizione considera i periodi di tempo come aperti a destra (il che è abbastanza logico perché una data viene spesso considerata come un timestamp con componente temporale di mezzanotte).

E come includere coppie tipo-data con 0 conteggi?

Crea una griglia di tutte le combinazioni, quindi LATERAL unisciti al tuo tavolo, in questo modo:

SELECT k.kind, d.as_of_date, c.n
FROM  (SELECT DISTINCT kind FROM dates_ranges) k
CROSS  JOIN (
   SELECT d::date AS as_of_date
   FROM   generate_series(timestamp '2018-01-01', timestamp '2018-01-03', interval '1 day') d
   ) d
CROSS  JOIN LATERAL (
   SELECT count(*)::int AS n
   FROM   dates_ranges
   WHERE  kind = k.kind
   AND    d.as_of_date BETWEEN start_date AND end_date
   ) c
ORDER  BY k.kind, d.as_of_date;

Dovrebbe anche essere il più veloce possibile.

All'inizio avevo LEFT JOIN LATERAL ... on true, ma c'è un aggregato nella sottoquery c, quindi otteniamo sempre una riga e possiamo usare CROSS JOINanche. Nessuna differenza nelle prestazioni.

Se hai una tabella che contiene tutti i tipi rilevanti , usa quella invece di generare l'elenco con la subquery k.

Il cast a integerè facoltativo. Altrimenti ottieni bigint.

Gli indici sarebbero di aiuto, in particolare un indice a più colonne attivo (kind, start_date, end_date). Dal momento che stai basando su una sottoquery, questo potrebbe o non potrebbe essere possibile raggiungere.

L'uso di funzioni di restituzione come generate_series()nella SELECTlista non è generalmente consigliabile nelle versioni di Postgres prima delle 10 (a meno che non si sappia esattamente cosa si sta facendo). Vedere:

• Qual è il comportamento previsto per più funzioni di restituzione di set nella clausola select?

Se hai molte combinazioni con poche o nessuna riga, questo modulo equivalente potrebbe essere più veloce:

SELECT k.kind, d.as_of_date, count(dr.kind)::int AS n
FROM  (SELECT DISTINCT kind FROM dates_ranges) k
CROSS JOIN (
   SELECT d::date AS as_of_date
   FROM   generate_series(timestamp '2018-01-01', timestamp '2018-01-03', interval '1 day') d
   ) d
LEFT   JOIN dates_ranges dr ON dr.kind = k.kind
                           AND d.as_of_date BETWEEN dr.start_date AND dr.end_date
GROUP  BY 1, 2
ORDER  BY 1, 2;

Usando il daterangetipo

PostgreSQL ha un daterange. Usarlo è piuttosto semplice. A partire dai dati di esempio, ci spostiamo per utilizzare il tipo nella tabella.

BEGIN;
  ALTER TABLE dates_ranges ADD COLUMN myrange daterange;
  UPDATE dates_ranges
    SET myrange = daterange(start_date, end_date, '[]');
  ALTER TABLE dates_ranges
    DROP COLUMN start_date,
    DROP COLUMN end_date;
COMMIT;

-- Now you can create GIST index on it...
CREATE INDEX ON dates_ranges USING gist (myrange);

TABLE dates_ranges;
 kind |         myrange         
------+-------------------------
    1 | [2018-01-01,2018-02-01)
    1 | [2018-01-01,2018-01-06)
    1 | [2018-01-03,2018-01-07)
    2 | [2018-01-01,2018-01-02)
    2 | [2018-01-01,2018-01-03)
    3 | [2018-01-02,2018-01-09)
    3 | [2018-01-05,2018-01-11)
(7 rows)

Voglio calcolare per le date date e per ogni tipo, in quante righe da date_ranges cade ogni data.

Ora per interrogarlo, invertiamo la procedura e generiamo una serie di date, ma ecco il problema che la query stessa può usare l' @>operatore contenimento ( ) per verificare che le date siano nell'intervallo, usando un indice.

Nota che usiamo timestamp without time zone(per fermare i rischi dell'ora legale)

SELECT d1.kind, day::date, count(d2.kind)
FROM dates_ranges AS d1
CROSS JOIN LATERAL generate_series(
  lower(myrange)::timestamp without time zone,
  upper(myrange)::timestamp without time zone,
  '1 day'
) AS gs(day)
INNER JOIN dates_ranges AS d2
  ON d2.myrange @> day::date
GROUP BY d1.kind, day;

Qual è la sovrapposizione giornaliera dettagliata sull'indice.

Come bonus laterale, con il tipo daterange puoi interrompere l' inserimento di intervalli che si sovrappongono ad altri usando unEXCLUDE CONSTRAINT