Totaal aantal records per week

De eenvoudige aanpak zou zijn om dit op te lossen met een CROSS JOIN zoals aangetoond door @jpw. Er zijn echter enkele verborgen problemen :

1. De uitvoering van een onvoorwaardelijke CROSS JOIN verslechtert snel met groeiend aantal rijen. Het totale aantal rijen wordt vermenigvuldigd met het aantal weken waarvoor u test, voordat deze enorme afgeleide tabel in de aggregatie kan worden verwerkt. Indexen kunnen niet helpen.

2. Het starten van weken met 1 januari leidt tot inconsistenties. ISO-weken misschien een alternatief zijn. Zie hieronder.

Alle volgende zoekopdrachten maken intensief gebruik van een index op exam_date . Zorg ervoor dat je er een hebt.

Alleen deelnemen aan relevante rijen

Moet veel sneller zijn :

SELECT d.day, d.thisyr
     , count(t.exam_date) AS lastyr
FROM  (
   SELECT d.day::date, (d.day - '1 year'::interval)::date AS day0  -- for 2nd join
        , count(t.exam_date) AS thisyr
   FROM   generate_series('2013-01-01'::date
                        , '2013-01-31'::date  -- last week overlaps with Feb.
                        , '7 days'::interval) d(day)  -- returns timestamp
   LEFT   JOIN tbl t ON t.exam_date >= d.day::date
                    AND t.exam_date <  d.day::date + 7
   GROUP  BY d.day
   ) d
LEFT   JOIN tbl t ON t.exam_date >= d.day0      -- repeat with last year
                 AND t.exam_date <  d.day0 + 7
GROUP  BY d.day, d.thisyr
ORDER  BY d.day;

Dit is met weken vanaf 1 januari, zoals in je origineel. Zoals opgemerkt, levert dit een aantal inconsistenties op:Weken beginnen elk jaar op een andere dag en aangezien we aan het einde van het jaar afbreken, bestaat de laatste week van het jaar uit slechts 1 of 2 dagen (schrikkeljaar).

Hetzelfde met ISO-weken

Overweeg, afhankelijk van de vereisten, ISO-weken in plaats daarvan, die op maandag beginnen en altijd 7 dagen beslaan. Maar ze overschrijden de grens tussen jaren. Per documentatie op EXTRACT() :

Bovenstaande query herschreven met ISO-weken:

SELECT w AS isoweek
     , day::text  AS thisyr_monday, thisyr_ct
     , day0::text AS lastyr_monday, count(t.exam_date) AS lastyr_ct
FROM  (
   SELECT w, day
        , date_trunc('week', '2012-01-04'::date)::date + 7 * w AS day0
        , count(t.exam_date) AS thisyr_ct
   FROM  (
      SELECT w
           , date_trunc('week', '2013-01-04'::date)::date + 7 * w AS day
      FROM   generate_series(0, 4) w
      ) d
   LEFT   JOIN tbl t ON t.exam_date >= d.day
                    AND t.exam_date <  d.day + 7
   GROUP  BY d.w, d.day
   ) d
LEFT   JOIN tbl t ON t.exam_date >= d.day0     -- repeat with last year
                 AND t.exam_date <  d.day0 + 7
GROUP  BY d.w, d.day, d.day0, d.thisyr_ct
ORDER  BY d.w, d.day;

4 januari valt altijd in de eerste ISO-week van het jaar. Dus deze uitdrukking krijgt de datum van maandag van de eerste ISO-week van het gegeven jaar:

date_trunc('week', '2012-01-04'::date)::date

Vereenvoudig met EXTRACT()

Aangezien ISO-weken samenvallen met de weeknummers die worden geretourneerd door EXTRACT() , kunnen we de query vereenvoudigen. Eerst een korte en eenvoudige vorm:

SELECT w AS isoweek
     , COALESCE(thisyr_ct, 0) AS thisyr_ct
     , COALESCE(lastyr_ct, 0) AS lastyr_ct
FROM   generate_series(1, 5) w
LEFT   JOIN (
   SELECT EXTRACT(week FROM exam_date)::int AS w, count(*) AS thisyr_ct
   FROM   tbl
   WHERE  EXTRACT(isoyear FROM exam_date)::int = 2013
   GROUP  BY 1
   ) t13  USING (w)
LEFT   JOIN (
   SELECT EXTRACT(week FROM exam_date)::int AS w, count(*) AS lastyr_ct
   FROM   tbl
   WHERE  EXTRACT(isoyear FROM exam_date)::int = 2012
   GROUP  BY 1
   ) t12  USING (w);

Geoptimaliseerde zoekopdracht

Hetzelfde met meer details en geoptimaliseerd voor prestaties

WITH params AS (          -- enter parameters here, once 
   SELECT date_trunc('week', '2012-01-04'::date)::date AS last_start
        , date_trunc('week', '2013-01-04'::date)::date AS this_start
        , date_trunc('week', '2014-01-04'::date)::date AS next_start
        , 1 AS week_1
        , 5 AS week_n     -- show weeks 1 - 5
   )
SELECT w.w AS isoweek
     , p.this_start + 7 * (w - 1) AS thisyr_monday
     , COALESCE(t13.ct, 0) AS thisyr_ct
     , p.last_start + 7 * (w - 1) AS lastyr_monday
     , COALESCE(t12.ct, 0) AS lastyr_ct
FROM params p
   , generate_series(p.week_1, p.week_n) w(w)
LEFT   JOIN (
   SELECT EXTRACT(week FROM t.exam_date)::int AS w, count(*) AS ct
   FROM   tbl t, params p
   WHERE  t.exam_date >= p.this_start      -- only relevant dates
   AND    t.exam_date <  p.this_start + 7 * (p.week_n - p.week_1 + 1)::int
-- AND    t.exam_date <  p.next_start      -- don't cross over into next year
   GROUP  BY 1
   ) t13  USING (w)
LEFT   JOIN (                              -- same for last year
   SELECT EXTRACT(week FROM t.exam_date)::int AS w, count(*) AS ct
   FROM   tbl t, params p
   WHERE  t.exam_date >= p.last_start
   AND    t.exam_date <  p.last_start + 7 * (p.week_n - p.week_1 + 1)::int
-- AND    t.exam_date <  p.this_start
   GROUP  BY 1
   ) t12  USING (w);

Dit zou zeer snel moeten zijn met indexondersteuning en kan gemakkelijk worden aangepast aan intervallen naar keuze. De impliciete JOIN LATERAL voor generate_series() in de laatste zoekopdracht is Postgres 9.3 . vereist .

SQL Fiddle.