Tôi có một bảng (trong PostgreQuery 9.4) trông như thế này:

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

Bây giờ tôi muốn tính toán cho các ngày đã cho và cho mọi loại, vào bao nhiêu hàng từ dates_rangesmỗi ngày rơi. Zeros có thể được bỏ qua.

Kết quả như ý:

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

Tôi đã đưa ra hai giải pháp, một với LEFT JOINvàGROUP 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

và một với LATERAL, nhanh hơn một chút:

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

Tôi tự hỏi có cách nào tốt hơn để viết truy vấn này không? Và làm thế nào để bao gồm các cặp ngày loại với số đếm 0?

Trong thực tế, có một vài loại khác nhau, thời gian lên tới năm năm (1800 ngày) và ~ 30k hàng trong dates_rangesbảng (nhưng nó có thể tăng trưởng đáng kể).

Không có chỉ số. Nói chính xác trong trường hợp của tôi, đó là kết quả của việc truy vấn phụ, nhưng tôi muốn giới hạn câu hỏi trong một vấn đề, vì vậy nó mang tính tổng quát hơn.

Truy vấn sau đây cũng hoạt động nếu "thiếu số không" là 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;

nhưng nó không nhanh hơn lateralphiên bản với bộ dữ liệu nhỏ. Mặc dù vậy, nó có thể mở rộng tốt hơn, vì không cần tham gia, nhưng phiên bản trên tổng hợp trên tất cả các hàng, do đó, nó có thể bị mất ở đó một lần nữa.

Truy vấn sau đây cố gắng tránh các công việc không cần thiết bằng cách xóa bất kỳ chuỗi nào không trùng lặp:

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;

- và tôi đã sử dụng overlapstoán tử! Lưu ý rằng bạn phải thêm interval '1 day'vào bên phải vì toán tử chồng lấp coi các khoảng thời gian được mở ở bên phải (điều này khá hợp lý vì ngày thường được coi là dấu thời gian với thành phần thời gian là nửa đêm).

Và làm thế nào để bao gồm các cặp ngày loại với số đếm 0?

Xây dựng một lưới tất cả các kết hợp sau đó LATERAL tham gia vào bảng của bạn, như thế này:

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;

Cũng nên nhanh nhất có thể.

Tôi đã có LEFT JOIN LATERAL ... on truelúc đầu, nhưng có một tổng hợp trong truy vấn con c, vì vậy chúng tôi luôn nhận được một hàng và cũng có thể sử dụng CROSS JOIN. Không có sự khác biệt trong hiệu suất.

Nếu bạn có một bảng chứa tất cả các loại có liên quan , hãy sử dụng bảng đó thay vì tạo danh sách với truy vấn con k.

Các diễn viên integerlà tùy chọn. Khác bạn nhận được bigint.

Các chỉ mục sẽ giúp ích, đặc biệt là một chỉ số nhiều màu trên (kind, start_date, end_date). Vì bạn đang xây dựng trên một truy vấn con, điều này có thể hoặc không thể đạt được.

Việc sử dụng các hàm trả về tập hợp như generate_series()trong SELECTdanh sách thường không được khuyến khích trong các phiên bản Postgres trước 10 (trừ khi bạn biết chính xác những gì bạn đang làm). Xem:

• Hành vi dự kiến ​​cho nhiều hàm trả về tập hợp trong mệnh đề chọn là gì?

Nếu bạn có nhiều kết hợp có ít hoặc không có hàng, hình thức tương đương này có thể nhanh hơn:

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;

Sử dụng daterangeloại

PostgreSQL có một daterange. Sử dụng nó khá đơn giản. Bắt đầu với dữ liệu mẫu của bạn, chúng tôi chuyển sang sử dụng loại trên bảng.

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)

Tôi muốn tính toán cho các ngày đã cho và cho mọi loại, vào bao nhiêu hàng từ date_ranges mỗi ngày rơi.

Bây giờ để truy vấn nó, chúng tôi đảo ngược thủ tục và tạo một chuỗi ngày nhưng ở đây, chính truy vấn có thể sử dụng @>toán tử ngăn chặn ( ) để kiểm tra xem ngày có nằm trong phạm vi hay không, sử dụng chỉ mục.

Lưu ý chúng tôi sử dụng timestamp without time zone(để ngăn chặn các mối nguy DST)

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;

Đó là sự chồng chéo ngày được ghi thành từng khoản trên chỉ mục.

Là một phần thưởng phụ, với loại daterange, bạn có thể dừng chèn các phạm vi trùng lặp với các phạm vi khác bằng cách sử dụng mộtEXCLUDE CONSTRAINT