delayed 2.0.1 → 2.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. checksums.yaml +4 -4
  2. data/lib/delayed/helpers/migration.rb +13 -18
  3. data/lib/delayed/monitor.rb +30 -21
  4. data/lib/delayed/version.rb +1 -1
  5. data/spec/delayed/__snapshots__/monitor_spec.rb.snap +687 -309
  6. data/spec/delayed/helpers/migration_spec.rb +33 -18
  7. data/spec/helper.rb +2 -0
  8. metadata +2 -2
data/spec/delayed/__snapshots__/monitor_spec.rb.snap CHANGED
@@ -1,969 +1,1347 @@
1
1
  snapshots["runs the expected postgresql query for count 1"] = <<-SNAP
2
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
2
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
3
3
  AND priority < 10 THEN 0 WHEN priority >= 10
4
4
  AND priority < 20 THEN 10 WHEN priority >= 20
5
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
5
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
6
+ FROM (SELECT priority, queue, COUNT(*) AS count
6
7
  FROM \"delayed_jobs\"
7
8
  WHERE \"delayed_jobs\".\"failed_at\" IS NOT NULL
9
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
8
10
  GROUP BY CASE WHEN priority >= 0
9
11
  AND priority < 10 THEN 0 WHEN priority >= 10
10
12
  AND priority < 20 THEN 10 WHEN priority >= 20
11
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
12
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
13
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
14
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
13
15
  AND priority < 10 THEN 0 WHEN priority >= 10
14
16
  AND priority < 20 THEN 10 WHEN priority >= 20
15
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
17
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
18
+ FROM (SELECT priority, queue, COUNT(*) AS count
16
19
  FROM \"delayed_jobs\"
17
20
  WHERE \"delayed_jobs\".\"failed_at\" IS NULL
21
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
18
22
  GROUP BY CASE WHEN priority >= 0
19
23
  AND priority < 10 THEN 0 WHEN priority >= 10
20
24
  AND priority < 20 THEN 10 WHEN priority >= 20
21
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
25
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
22
26
  SNAP
23
27
 
24
28
  snapshots["produces the expected postgresql query plan for count 1"] = <<-SNAP
25
29
  GroupAggregate (cost=...)
26
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
27
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
30
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
31
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
28
32
  -> Sort (cost=...)
29
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
30
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
31
- -> Index Only Scan using idx_delayed_jobs_failed on public.delayed_jobs (cost=...)
32
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
33
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
34
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
35
+ -> Subquery Scan on subquery (cost=...)
36
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
37
+ -> GroupAggregate (cost=...)
38
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
39
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
40
+ -> Index Only Scan using idx_delayed_jobs_failed on public.delayed_jobs (cost=...)
41
+ Output: delayed_jobs.priority, delayed_jobs.queue
33
42
  GroupAggregate (cost=...)
34
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
35
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
43
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
44
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
36
45
  -> Sort (cost=...)
37
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
38
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
39
- -> Index Only Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
40
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
46
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
47
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
48
+ -> Subquery Scan on subquery (cost=...)
49
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
50
+ -> GroupAggregate (cost=...)
51
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
52
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
53
+ -> Sort (cost=...)
54
+ Output: delayed_jobs.priority, delayed_jobs.queue
55
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
56
+ -> Index Only Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
57
+ Output: delayed_jobs.priority, delayed_jobs.queue
41
58
  SNAP
42
59
 
43
60
  snapshots["[legacy index] produces the expected postgresql query plan for count 1"] = <<-SNAP
44
61
  GroupAggregate (cost=...)
45
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
46
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
62
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
63
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
47
64
  -> Sort (cost=...)
48
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
49
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
50
- -> Seq Scan on public.delayed_jobs (cost=...)
51
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
52
- Filter: (delayed_jobs.failed_at IS NOT NULL)
65
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
66
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
67
+ -> Subquery Scan on subquery (cost=...)
68
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
69
+ -> GroupAggregate (cost=...)
70
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
71
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
72
+ -> Sort (cost=...)
73
+ Output: delayed_jobs.priority, delayed_jobs.queue
74
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
75
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
76
+ Output: delayed_jobs.priority, delayed_jobs.queue
77
+ Filter: (delayed_jobs.failed_at IS NOT NULL)
53
78
  GroupAggregate (cost=...)
54
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
55
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
79
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
80
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
56
81
  -> Sort (cost=...)
57
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
58
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
59
- -> Seq Scan on public.delayed_jobs (cost=...)
60
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
61
- Filter: (delayed_jobs.failed_at IS NULL)
82
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
83
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
84
+ -> Subquery Scan on subquery (cost=...)
85
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
86
+ -> GroupAggregate (cost=...)
87
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
88
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
89
+ -> Sort (cost=...)
90
+ Output: delayed_jobs.priority, delayed_jobs.queue
91
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
92
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
93
+ Output: delayed_jobs.priority, delayed_jobs.queue
94
+ Filter: (delayed_jobs.failed_at IS NULL)
62
95
  SNAP
63
96
 
64
97
  snapshots["runs the expected postgresql query for future_count 1"] = <<-SNAP
65
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
98
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
66
99
  AND priority < 10 THEN 0 WHEN priority >= 10
67
100
  AND priority < 20 THEN 10 WHEN priority >= 20
68
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
101
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
102
+ FROM (SELECT priority, queue, COUNT(*) AS count
69
103
  FROM \"delayed_jobs\"
70
104
  WHERE \"delayed_jobs\".\"failed_at\" IS NULL
71
105
  AND \"delayed_jobs\".\"run_at\" > '2025-11-10 17:20:13'
106
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
72
107
  GROUP BY CASE WHEN priority >= 0
73
108
  AND priority < 10 THEN 0 WHEN priority >= 10
74
109
  AND priority < 20 THEN 10 WHEN priority >= 20
75
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
110
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
76
111
  SNAP
77
112
 
78
113
  snapshots["produces the expected postgresql query plan for future_count 1"] = <<-SNAP
79
114
  GroupAggregate (cost=...)
80
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
81
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
115
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
116
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
82
117
  -> Sort (cost=...)
83
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
84
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
85
- -> Index Only Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
86
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
87
- Index Cond: (delayed_jobs.run_at > '2025-11-10 17:20:13'::timestamp without time zone)
118
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
119
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
120
+ -> Subquery Scan on subquery (cost=...)
121
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
122
+ -> GroupAggregate (cost=...)
123
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
124
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
125
+ -> Sort (cost=...)
126
+ Output: delayed_jobs.priority, delayed_jobs.queue
127
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
128
+ -> Index Only Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
129
+ Output: delayed_jobs.priority, delayed_jobs.queue
130
+ Index Cond: (delayed_jobs.run_at > '2025-11-10 17:20:13'::timestamp without time zone)
88
131
  SNAP
89
132
 
90
133
  snapshots["[legacy index] produces the expected postgresql query plan for future_count 1"] = <<-SNAP
91
134
  GroupAggregate (cost=...)
92
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
93
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
135
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
136
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
94
137
  -> Sort (cost=...)
95
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
96
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
97
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
98
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
99
- Index Cond: (delayed_jobs.run_at > '2025-11-10 17:20:13'::timestamp without time zone)
100
- Filter: (delayed_jobs.failed_at IS NULL)
138
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
139
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
140
+ -> Subquery Scan on subquery (cost=...)
141
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
142
+ -> GroupAggregate (cost=...)
143
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
144
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
145
+ -> Sort (cost=...)
146
+ Output: delayed_jobs.priority, delayed_jobs.queue
147
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
148
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
149
+ Output: delayed_jobs.priority, delayed_jobs.queue
150
+ Index Cond: (delayed_jobs.run_at > '2025-11-10 17:20:13'::timestamp without time zone)
151
+ Filter: (delayed_jobs.failed_at IS NULL)
101
152
  SNAP
102
153
 
103
154
  snapshots["runs the expected postgresql query for locked_count 1"] = <<-SNAP
104
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
155
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
105
156
  AND priority < 10 THEN 0 WHEN priority >= 10
106
157
  AND priority < 20 THEN 10 WHEN priority >= 20
107
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
158
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
159
+ FROM (SELECT priority, queue, COUNT(*) AS count
108
160
  FROM \"delayed_jobs\"
109
161
  WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
110
162
  AND \"delayed_jobs\".\"failed_at\" IS NULL
111
163
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
164
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
112
165
  GROUP BY CASE WHEN priority >= 0
113
166
  AND priority < 10 THEN 0 WHEN priority >= 10
114
167
  AND priority < 20 THEN 10 WHEN priority >= 20
115
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
168
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
116
169
  SNAP
117
170
 
118
171
  snapshots["produces the expected postgresql query plan for locked_count 1"] = <<-SNAP
119
172
  GroupAggregate (cost=...)
120
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
121
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
173
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
174
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
122
175
  -> Sort (cost=...)
123
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
124
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
125
- -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
126
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
127
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
128
- Filter: (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone)
176
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
177
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
178
+ -> Subquery Scan on subquery (cost=...)
179
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
180
+ -> GroupAggregate (cost=...)
181
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
182
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
183
+ -> Sort (cost=...)
184
+ Output: delayed_jobs.priority, delayed_jobs.queue
185
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
186
+ -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
187
+ Output: delayed_jobs.priority, delayed_jobs.queue
188
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
189
+ Filter: (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone)
129
190
  SNAP
130
191
 
131
192
  snapshots["[legacy index] produces the expected postgresql query plan for locked_count 1"] = <<-SNAP
132
193
  GroupAggregate (cost=...)
133
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
134
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
194
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
195
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
135
196
  -> Sort (cost=...)
136
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
137
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
138
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
139
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
140
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
141
- Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone))
197
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
198
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
199
+ -> Subquery Scan on subquery (cost=...)
200
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
201
+ -> GroupAggregate (cost=...)
202
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
203
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
204
+ -> Sort (cost=...)
205
+ Output: delayed_jobs.priority, delayed_jobs.queue
206
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
207
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
208
+ Output: delayed_jobs.priority, delayed_jobs.queue
209
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
210
+ Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone))
142
211
  SNAP
143
212
 
144
213
  snapshots["runs the expected postgresql query for erroring_count 1"] = <<-SNAP
145
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
214
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
146
215
  AND priority < 10 THEN 0 WHEN priority >= 10
147
216
  AND priority < 20 THEN 10 WHEN priority >= 20
148
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
217
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
218
+ FROM (SELECT priority, queue, COUNT(*) AS count
149
219
  FROM \"delayed_jobs\"
150
220
  WHERE \"delayed_jobs\".\"attempts\" > 0
151
221
  AND \"delayed_jobs\".\"failed_at\" IS NULL
222
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
152
223
  GROUP BY CASE WHEN priority >= 0
153
224
  AND priority < 10 THEN 0 WHEN priority >= 10
154
225
  AND priority < 20 THEN 10 WHEN priority >= 20
155
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
226
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
156
227
  SNAP
157
228
 
158
229
  snapshots["produces the expected postgresql query plan for erroring_count 1"] = <<-SNAP
159
230
  GroupAggregate (cost=...)
160
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
161
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
231
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
232
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
162
233
  -> Sort (cost=...)
163
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
164
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
165
- -> Index Only Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
166
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
167
- Index Cond: (delayed_jobs.attempts > 0)
234
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
235
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
236
+ -> Subquery Scan on subquery (cost=...)
237
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
238
+ -> GroupAggregate (cost=...)
239
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
240
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
241
+ -> Sort (cost=...)
242
+ Output: delayed_jobs.priority, delayed_jobs.queue
243
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
244
+ -> Index Only Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
245
+ Output: delayed_jobs.priority, delayed_jobs.queue
246
+ Index Cond: (delayed_jobs.attempts > 0)
168
247
  SNAP
169
248
 
170
249
  snapshots["[legacy index] produces the expected postgresql query plan for erroring_count 1"] = <<-SNAP
171
250
  GroupAggregate (cost=...)
172
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
173
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
251
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
252
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
174
253
  -> Sort (cost=...)
175
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
176
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
177
- -> Seq Scan on public.delayed_jobs (cost=...)
178
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
179
- Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.attempts > 0))
254
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
255
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
256
+ -> Subquery Scan on subquery (cost=...)
257
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
258
+ -> GroupAggregate (cost=...)
259
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
260
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
261
+ -> Sort (cost=...)
262
+ Output: delayed_jobs.priority, delayed_jobs.queue
263
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
264
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
265
+ Output: delayed_jobs.priority, delayed_jobs.queue
266
+ Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.attempts > 0))
180
267
  SNAP
181
268
 
182
269
  snapshots["runs the expected postgresql query for failed_count 1"] = <<-SNAP
183
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
270
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
184
271
  AND priority < 10 THEN 0 WHEN priority >= 10
185
272
  AND priority < 20 THEN 10 WHEN priority >= 20
186
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
273
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
274
+ FROM (SELECT priority, queue, COUNT(*) AS count
187
275
  FROM \"delayed_jobs\"
188
276
  WHERE \"delayed_jobs\".\"failed_at\" IS NOT NULL
277
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
189
278
  GROUP BY CASE WHEN priority >= 0
190
279
  AND priority < 10 THEN 0 WHEN priority >= 10
191
280
  AND priority < 20 THEN 10 WHEN priority >= 20
192
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
281
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
193
282
  SNAP
194
283
 
195
284
  snapshots["produces the expected postgresql query plan for failed_count 1"] = <<-SNAP
196
285
  GroupAggregate (cost=...)
197
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
198
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
286
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
287
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
199
288
  -> Sort (cost=...)
200
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
201
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
202
- -> Index Only Scan using idx_delayed_jobs_failed on public.delayed_jobs (cost=...)
203
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
289
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
290
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
291
+ -> Subquery Scan on subquery (cost=...)
292
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
293
+ -> GroupAggregate (cost=...)
294
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
295
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
296
+ -> Index Only Scan using idx_delayed_jobs_failed on public.delayed_jobs (cost=...)
297
+ Output: delayed_jobs.priority, delayed_jobs.queue
204
298
  SNAP
205
299
 
206
300
  snapshots["[legacy index] produces the expected postgresql query plan for failed_count 1"] = <<-SNAP
207
301
  GroupAggregate (cost=...)
208
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
209
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
302
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
303
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
210
304
  -> Sort (cost=...)
211
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
212
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
213
- -> Seq Scan on public.delayed_jobs (cost=...)
214
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
215
- Filter: (delayed_jobs.failed_at IS NOT NULL)
305
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
306
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
307
+ -> Subquery Scan on subquery (cost=...)
308
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
309
+ -> GroupAggregate (cost=...)
310
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
311
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
312
+ -> Sort (cost=...)
313
+ Output: delayed_jobs.priority, delayed_jobs.queue
314
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
315
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
316
+ Output: delayed_jobs.priority, delayed_jobs.queue
317
+ Filter: (delayed_jobs.failed_at IS NOT NULL)
216
318
  SNAP
217
319
 
218
320
  snapshots["runs the expected postgresql query for max_lock_age 1"] = <<-SNAP
219
- SELECT CASE WHEN priority >= 0
321
+ SELECT MIN(locked_at) AS minimum_locked_at, CASE WHEN priority >= 0
220
322
  AND priority < 10 THEN 0 WHEN priority >= 10
221
323
  AND priority < 20 THEN 10 WHEN priority >= 20
222
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS priority, queue, MIN(locked_at) AS locked_at
324
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
325
+ FROM (SELECT priority, queue, MIN(locked_at) AS locked_at
223
326
  FROM \"delayed_jobs\"
224
327
  WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
225
328
  AND \"delayed_jobs\".\"failed_at\" IS NULL
226
329
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
330
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
227
331
  GROUP BY CASE WHEN priority >= 0
228
332
  AND priority < 10 THEN 0 WHEN priority >= 10
229
333
  AND priority < 20 THEN 10 WHEN priority >= 20
230
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
334
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
231
335
  SNAP
232
336
 
233
337
  snapshots["produces the expected postgresql query plan for max_lock_age 1"] = <<-SNAP
234
338
  GroupAggregate (cost=...)
235
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, min(locked_at)
236
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
339
+ Output: min(subquery.locked_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
340
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
237
341
  -> Sort (cost=...)
238
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, locked_at
239
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
240
- -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
241
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue, locked_at
242
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
243
- Filter: (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone)
342
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.locked_at
343
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
344
+ -> Subquery Scan on subquery (cost=...)
345
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.locked_at
346
+ -> GroupAggregate (cost=...)
347
+ Output: delayed_jobs.priority, delayed_jobs.queue, min(delayed_jobs.locked_at)
348
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
349
+ -> Sort (cost=...)
350
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.locked_at
351
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
352
+ -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
353
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.locked_at
354
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
355
+ Filter: (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone)
244
356
  SNAP
245
357
 
246
358
  snapshots["[legacy index] produces the expected postgresql query plan for max_lock_age 1"] = <<-SNAP
247
359
  GroupAggregate (cost=...)
248
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, min(locked_at)
249
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
360
+ Output: min(subquery.locked_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
361
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
250
362
  -> Sort (cost=...)
251
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, locked_at
252
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
253
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
254
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue, locked_at
255
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
256
- Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone))
363
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.locked_at
364
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
365
+ -> Subquery Scan on subquery (cost=...)
366
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.locked_at
367
+ -> GroupAggregate (cost=...)
368
+ Output: delayed_jobs.priority, delayed_jobs.queue, min(delayed_jobs.locked_at)
369
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
370
+ -> Sort (cost=...)
371
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.locked_at
372
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
373
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
374
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.locked_at
375
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
376
+ Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone))
257
377
  SNAP
258
378
 
259
379
  snapshots["runs the expected postgresql query for max_age 1"] = <<-SNAP
260
- SELECT (CASE WHEN priority >= 0
380
+ SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
261
381
  AND priority < 10 THEN 0 WHEN priority >= 10
262
382
  AND priority < 20 THEN 10 WHEN priority >= 20
263
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at
383
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
384
+ FROM (SELECT priority, queue, MIN(run_at) AS run_at
264
385
  FROM \"delayed_jobs\"
265
386
  WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
266
387
  OR \"delayed_jobs\".\"locked_at\" < '2025-11-10 16:59:43')
267
388
  AND \"delayed_jobs\".\"failed_at\" IS NULL
268
389
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
390
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
269
391
  GROUP BY CASE WHEN priority >= 0
270
392
  AND priority < 10 THEN 0 WHEN priority >= 10
271
393
  AND priority < 20 THEN 10 WHEN priority >= 20
272
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
394
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
273
395
  SNAP
274
396
 
275
397
  snapshots["produces the expected postgresql query plan for max_age 1"] = <<-SNAP
276
398
  GroupAggregate (cost=...)
277
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, min(run_at)
278
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
399
+ Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
400
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
279
401
  -> Sort (cost=...)
280
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, run_at
281
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
282
- -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
283
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue, run_at
284
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
285
- Filter: ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone))
402
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
403
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
404
+ -> Subquery Scan on subquery (cost=...)
405
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.run_at
406
+ -> GroupAggregate (cost=...)
407
+ Output: delayed_jobs.priority, delayed_jobs.queue, min(delayed_jobs.run_at)
408
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
409
+ -> Sort (cost=...)
410
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
411
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
412
+ -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
413
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
414
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
415
+ Filter: ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone))
286
416
  SNAP
287
417
 
288
418
  snapshots["[legacy index] produces the expected postgresql query plan for max_age 1"] = <<-SNAP
289
419
  GroupAggregate (cost=...)
290
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, min(run_at)
291
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
420
+ Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
421
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
292
422
  -> Sort (cost=...)
293
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, run_at
294
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
295
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
296
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue, run_at
297
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
298
- Filter: ((delayed_jobs.failed_at IS NULL) AND ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone)))
423
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
424
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
425
+ -> Subquery Scan on subquery (cost=...)
426
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.run_at
427
+ -> GroupAggregate (cost=...)
428
+ Output: delayed_jobs.priority, delayed_jobs.queue, min(delayed_jobs.run_at)
429
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
430
+ -> Sort (cost=...)
431
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
432
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
433
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
434
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
435
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
436
+ Filter: ((delayed_jobs.failed_at IS NULL) AND ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone)))
299
437
  SNAP
300
438
 
301
439
  snapshots["runs the expected postgresql query for working_count 1"] = <<-SNAP
302
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
440
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
303
441
  AND priority < 10 THEN 0 WHEN priority >= 10
304
442
  AND priority < 20 THEN 10 WHEN priority >= 20
305
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
443
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
444
+ FROM (SELECT priority, queue, COUNT(*) AS count
306
445
  FROM \"delayed_jobs\"
307
446
  WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
308
447
  AND \"delayed_jobs\".\"failed_at\" IS NULL
309
448
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
449
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
310
450
  GROUP BY CASE WHEN priority >= 0
311
451
  AND priority < 10 THEN 0 WHEN priority >= 10
312
452
  AND priority < 20 THEN 10 WHEN priority >= 20
313
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
453
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
314
454
  SNAP
315
455
 
316
456
  snapshots["produces the expected postgresql query plan for working_count 1"] = <<-SNAP
317
457
  GroupAggregate (cost=...)
318
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
319
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
458
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
459
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
320
460
  -> Sort (cost=...)
321
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
322
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
323
- -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
324
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
325
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
326
- Filter: (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone)
461
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
462
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
463
+ -> Subquery Scan on subquery (cost=...)
464
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
465
+ -> GroupAggregate (cost=...)
466
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
467
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
468
+ -> Sort (cost=...)
469
+ Output: delayed_jobs.priority, delayed_jobs.queue
470
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
471
+ -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
472
+ Output: delayed_jobs.priority, delayed_jobs.queue
473
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
474
+ Filter: (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone)
327
475
  SNAP
328
476
 
329
477
  snapshots["[legacy index] produces the expected postgresql query plan for working_count 1"] = <<-SNAP
330
478
  GroupAggregate (cost=...)
331
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
332
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
479
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
480
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
333
481
  -> Sort (cost=...)
334
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
335
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
336
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
337
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
338
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
339
- Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone))
482
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
483
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
484
+ -> Subquery Scan on subquery (cost=...)
485
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
486
+ -> GroupAggregate (cost=...)
487
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
488
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
489
+ -> Sort (cost=...)
490
+ Output: delayed_jobs.priority, delayed_jobs.queue
491
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
492
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
493
+ Output: delayed_jobs.priority, delayed_jobs.queue
494
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
495
+ Filter: ((delayed_jobs.failed_at IS NULL) AND (delayed_jobs.locked_at >= '2025-11-10 16:59:43'::timestamp without time zone))
340
496
  SNAP
341
497
 
342
498
  snapshots["runs the expected postgresql query for workable_count 1"] = <<-SNAP
343
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
499
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
344
500
  AND priority < 10 THEN 0 WHEN priority >= 10
345
501
  AND priority < 20 THEN 10 WHEN priority >= 20
346
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
502
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
503
+ FROM (SELECT priority, queue, COUNT(*) AS count
347
504
  FROM \"delayed_jobs\"
348
505
  WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
349
506
  OR \"delayed_jobs\".\"locked_at\" < '2025-11-10 16:59:43')
350
507
  AND \"delayed_jobs\".\"failed_at\" IS NULL
351
508
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
509
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
352
510
  GROUP BY CASE WHEN priority >= 0
353
511
  AND priority < 10 THEN 0 WHEN priority >= 10
354
512
  AND priority < 20 THEN 10 WHEN priority >= 20
355
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
513
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
356
514
  SNAP
357
515
 
358
516
  snapshots["produces the expected postgresql query plan for workable_count 1"] = <<-SNAP
359
517
  GroupAggregate (cost=...)
360
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
361
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
518
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
519
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
362
520
  -> Sort (cost=...)
363
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
364
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
365
- -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
366
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
367
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
368
- Filter: ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone))
521
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
522
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
523
+ -> Subquery Scan on subquery (cost=...)
524
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
525
+ -> GroupAggregate (cost=...)
526
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
527
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
528
+ -> Sort (cost=...)
529
+ Output: delayed_jobs.priority, delayed_jobs.queue
530
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
531
+ -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
532
+ Output: delayed_jobs.priority, delayed_jobs.queue
533
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
534
+ Filter: ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone))
369
535
  SNAP
370
536
 
371
537
  snapshots["[legacy index] produces the expected postgresql query plan for workable_count 1"] = <<-SNAP
372
538
  GroupAggregate (cost=...)
373
- Output: count(*), (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
374
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
539
+ Output: sum(subquery.count), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
540
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
375
541
  -> Sort (cost=...)
376
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue
377
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
378
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
379
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue
380
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
381
- Filter: ((delayed_jobs.failed_at IS NULL) AND ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone)))
542
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.count
543
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
544
+ -> Subquery Scan on subquery (cost=...)
545
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.count
546
+ -> GroupAggregate (cost=...)
547
+ Output: delayed_jobs.priority, delayed_jobs.queue, count(*)
548
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
549
+ -> Sort (cost=...)
550
+ Output: delayed_jobs.priority, delayed_jobs.queue
551
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
552
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
553
+ Output: delayed_jobs.priority, delayed_jobs.queue
554
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
555
+ Filter: ((delayed_jobs.failed_at IS NULL) AND ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone)))
382
556
  SNAP
383
557
 
384
558
  snapshots["runs the expected postgresql query for alert_age_percent 1"] = <<-SNAP
385
- SELECT (CASE WHEN priority >= 0
559
+ SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
386
560
  AND priority < 10 THEN 0 WHEN priority >= 10
387
561
  AND priority < 20 THEN 10 WHEN priority >= 20
388
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at
562
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
563
+ FROM (SELECT priority, queue, MIN(run_at) AS run_at
389
564
  FROM \"delayed_jobs\"
390
565
  WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
391
566
  OR \"delayed_jobs\".\"locked_at\" < '2025-11-10 16:59:43')
392
567
  AND \"delayed_jobs\".\"failed_at\" IS NULL
393
568
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
569
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
394
570
  GROUP BY CASE WHEN priority >= 0
395
571
  AND priority < 10 THEN 0 WHEN priority >= 10
396
572
  AND priority < 20 THEN 10 WHEN priority >= 20
397
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
573
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
398
574
  SNAP
399
575
 
400
576
  snapshots["produces the expected postgresql query plan for alert_age_percent 1"] = <<-SNAP
401
577
  GroupAggregate (cost=...)
402
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, min(run_at)
403
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
578
+ Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
579
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
404
580
  -> Sort (cost=...)
405
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, run_at
406
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
407
- -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
408
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue, run_at
409
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
410
- Filter: ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone))
581
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
582
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
583
+ -> Subquery Scan on subquery (cost=...)
584
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.run_at
585
+ -> GroupAggregate (cost=...)
586
+ Output: delayed_jobs.priority, delayed_jobs.queue, min(delayed_jobs.run_at)
587
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
588
+ -> Sort (cost=...)
589
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
590
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
591
+ -> Index Scan using idx_delayed_jobs_live on public.delayed_jobs (cost=...)
592
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
593
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
594
+ Filter: ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone))
411
595
  SNAP
412
596
 
413
597
  snapshots["[legacy index] produces the expected postgresql query plan for alert_age_percent 1"] = <<-SNAP
414
598
  GroupAggregate (cost=...)
415
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, min(run_at)
416
- Group Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
599
+ Output: min(subquery.run_at), (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
600
+ Group Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
417
601
  -> Sort (cost=...)
418
- Output: (CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END), queue, run_at
419
- Sort Key: (CASE WHEN ((delayed_jobs.priority >= 0) AND (delayed_jobs.priority < 10)) THEN 0 WHEN ((delayed_jobs.priority >= 10) AND (delayed_jobs.priority < 20)) THEN 10 WHEN ((delayed_jobs.priority >= 20) AND (delayed_jobs.priority < 30)) THEN 20 WHEN (delayed_jobs.priority >= 30) THEN 30 ELSE NULL::integer END), delayed_jobs.queue
420
- -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
421
- Output: CASE WHEN ((priority >= 0) AND (priority < 10)) THEN 0 WHEN ((priority >= 10) AND (priority < 20)) THEN 10 WHEN ((priority >= 20) AND (priority < 30)) THEN 20 WHEN (priority >= 30) THEN 30 ELSE NULL::integer END, queue, run_at
422
- Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
423
- Filter: ((delayed_jobs.failed_at IS NULL) AND ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone)))
602
+ Output: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue, subquery.run_at
603
+ Sort Key: (CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END), subquery.queue
604
+ -> Subquery Scan on subquery (cost=...)
605
+ Output: CASE WHEN ((subquery.priority >= 0) AND (subquery.priority < 10)) THEN 0 WHEN ((subquery.priority >= 10) AND (subquery.priority < 20)) THEN 10 WHEN ((subquery.priority >= 20) AND (subquery.priority < 30)) THEN 20 WHEN (subquery.priority >= 30) THEN 30 ELSE NULL::integer END, subquery.queue, subquery.run_at
606
+ -> GroupAggregate (cost=...)
607
+ Output: delayed_jobs.priority, delayed_jobs.queue, min(delayed_jobs.run_at)
608
+ Group Key: delayed_jobs.priority, delayed_jobs.queue
609
+ -> Sort (cost=...)
610
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
611
+ Sort Key: delayed_jobs.priority, delayed_jobs.queue
612
+ -> Index Scan using delayed_jobs_priority on public.delayed_jobs (cost=...)
613
+ Output: delayed_jobs.priority, delayed_jobs.queue, delayed_jobs.run_at
614
+ Index Cond: (delayed_jobs.run_at <= '2025-11-10 17:20:13'::timestamp without time zone)
615
+ Filter: ((delayed_jobs.failed_at IS NULL) AND ((delayed_jobs.locked_at IS NULL) OR (delayed_jobs.locked_at < '2025-11-10 16:59:43'::timestamp without time zone)))
424
616
  SNAP
425
617
 
426
618
  snapshots["runs the expected sqlite3 query for count 1"] = <<-SNAP
427
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
619
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
428
620
  AND priority < 10 THEN 0 WHEN priority >= 10
429
621
  AND priority < 20 THEN 10 WHEN priority >= 20
430
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
622
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
623
+ FROM (SELECT priority, queue, COUNT(*) AS count
431
624
  FROM \"delayed_jobs\"
432
625
  WHERE \"delayed_jobs\".\"failed_at\" IS NOT NULL
626
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
433
627
  GROUP BY CASE WHEN priority >= 0
434
628
  AND priority < 10 THEN 0 WHEN priority >= 10
435
629
  AND priority < 20 THEN 10 WHEN priority >= 20
436
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
437
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
630
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
631
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
438
632
  AND priority < 10 THEN 0 WHEN priority >= 10
439
633
  AND priority < 20 THEN 10 WHEN priority >= 20
440
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
634
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
635
+ FROM (SELECT priority, queue, COUNT(*) AS count
441
636
  FROM \"delayed_jobs\"
442
637
  WHERE \"delayed_jobs\".\"failed_at\" IS NULL
638
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
443
639
  GROUP BY CASE WHEN priority >= 0
444
640
  AND priority < 10 THEN 0 WHEN priority >= 10
445
641
  AND priority < 20 THEN 10 WHEN priority >= 20
446
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
642
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
447
643
  SNAP
448
644
 
449
645
  snapshots["produces the expected sqlite3 query plan for count 1"] = <<-SNAP
646
+ CO-ROUTINE subquery
450
647
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_failed
648
+ SCAN subquery
451
649
  USE TEMP B-TREE FOR GROUP BY
650
+ CO-ROUTINE subquery
452
651
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
453
652
  USE TEMP B-TREE FOR GROUP BY
653
+ SCAN subquery
654
+ USE TEMP B-TREE FOR GROUP BY
454
655
  SNAP
455
656
 
456
657
  snapshots["[legacy index] produces the expected sqlite3 query plan for count 1"] = <<-SNAP
457
- SCAN delayed_jobs
658
+ CO-ROUTINE subquery
659
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
660
+ USE TEMP B-TREE FOR GROUP BY
661
+ SCAN subquery
662
+ USE TEMP B-TREE FOR GROUP BY
663
+ CO-ROUTINE subquery
664
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
458
665
  USE TEMP B-TREE FOR GROUP BY
459
- SCAN delayed_jobs
666
+ SCAN subquery
460
667
  USE TEMP B-TREE FOR GROUP BY
461
668
  SNAP
462
669
 
463
670
  snapshots["runs the expected sqlite3 query for future_count 1"] = <<-SNAP
464
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
671
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
465
672
  AND priority < 10 THEN 0 WHEN priority >= 10
466
673
  AND priority < 20 THEN 10 WHEN priority >= 20
467
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
674
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
675
+ FROM (SELECT priority, queue, COUNT(*) AS count
468
676
  FROM \"delayed_jobs\"
469
677
  WHERE \"delayed_jobs\".\"failed_at\" IS NULL
470
678
  AND \"delayed_jobs\".\"run_at\" > '2025-11-10 17:20:13'
679
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
471
680
  GROUP BY CASE WHEN priority >= 0
472
681
  AND priority < 10 THEN 0 WHEN priority >= 10
473
682
  AND priority < 20 THEN 10 WHEN priority >= 20
474
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
683
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
475
684
  SNAP
476
685
 
477
686
  snapshots["produces the expected sqlite3 query plan for future_count 1"] = <<-SNAP
687
+ CO-ROUTINE subquery
478
688
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
479
689
  USE TEMP B-TREE FOR GROUP BY
690
+ SCAN subquery
691
+ USE TEMP B-TREE FOR GROUP BY
480
692
  SNAP
481
693
 
482
694
  snapshots["[legacy index] produces the expected sqlite3 query plan for future_count 1"] = <<-SNAP
483
- SCAN delayed_jobs
695
+ CO-ROUTINE subquery
696
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
697
+ USE TEMP B-TREE FOR GROUP BY
698
+ SCAN subquery
484
699
  USE TEMP B-TREE FOR GROUP BY
485
700
  SNAP
486
701
 
487
702
  snapshots["runs the expected sqlite3 query for locked_count 1"] = <<-SNAP
488
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
703
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
489
704
  AND priority < 10 THEN 0 WHEN priority >= 10
490
705
  AND priority < 20 THEN 10 WHEN priority >= 20
491
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
706
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
707
+ FROM (SELECT priority, queue, COUNT(*) AS count
492
708
  FROM \"delayed_jobs\"
493
709
  WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
494
710
  AND \"delayed_jobs\".\"failed_at\" IS NULL
495
711
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
712
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
496
713
  GROUP BY CASE WHEN priority >= 0
497
714
  AND priority < 10 THEN 0 WHEN priority >= 10
498
715
  AND priority < 20 THEN 10 WHEN priority >= 20
499
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
716
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
500
717
  SNAP
501
718
 
502
719
  snapshots["produces the expected sqlite3 query plan for locked_count 1"] = <<-SNAP
720
+ CO-ROUTINE subquery
503
721
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
504
722
  USE TEMP B-TREE FOR GROUP BY
723
+ SCAN subquery
724
+ USE TEMP B-TREE FOR GROUP BY
505
725
  SNAP
506
726
 
507
727
  snapshots["[legacy index] produces the expected sqlite3 query plan for locked_count 1"] = <<-SNAP
508
- SCAN delayed_jobs
728
+ CO-ROUTINE subquery
729
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
730
+ USE TEMP B-TREE FOR GROUP BY
731
+ SCAN subquery
509
732
  USE TEMP B-TREE FOR GROUP BY
510
733
  SNAP
511
734
 
512
735
  snapshots["runs the expected sqlite3 query for erroring_count 1"] = <<-SNAP
513
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
736
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
514
737
  AND priority < 10 THEN 0 WHEN priority >= 10
515
738
  AND priority < 20 THEN 10 WHEN priority >= 20
516
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
739
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
740
+ FROM (SELECT priority, queue, COUNT(*) AS count
517
741
  FROM \"delayed_jobs\"
518
742
  WHERE \"delayed_jobs\".\"attempts\" > 0
519
743
  AND \"delayed_jobs\".\"failed_at\" IS NULL
744
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
520
745
  GROUP BY CASE WHEN priority >= 0
521
746
  AND priority < 10 THEN 0 WHEN priority >= 10
522
747
  AND priority < 20 THEN 10 WHEN priority >= 20
523
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
748
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
524
749
  SNAP
525
750
 
526
751
  snapshots["produces the expected sqlite3 query plan for erroring_count 1"] = <<-SNAP
752
+ CO-ROUTINE subquery
527
753
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
528
754
  USE TEMP B-TREE FOR GROUP BY
755
+ SCAN subquery
756
+ USE TEMP B-TREE FOR GROUP BY
529
757
  SNAP
530
758
 
531
759
  snapshots["[legacy index] produces the expected sqlite3 query plan for erroring_count 1"] = <<-SNAP
532
- SCAN delayed_jobs
760
+ CO-ROUTINE subquery
761
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
762
+ USE TEMP B-TREE FOR GROUP BY
763
+ SCAN subquery
533
764
  USE TEMP B-TREE FOR GROUP BY
534
765
  SNAP
535
766
 
536
767
  snapshots["runs the expected sqlite3 query for failed_count 1"] = <<-SNAP
537
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
768
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
538
769
  AND priority < 10 THEN 0 WHEN priority >= 10
539
770
  AND priority < 20 THEN 10 WHEN priority >= 20
540
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
771
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
772
+ FROM (SELECT priority, queue, COUNT(*) AS count
541
773
  FROM \"delayed_jobs\"
542
774
  WHERE \"delayed_jobs\".\"failed_at\" IS NOT NULL
775
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
543
776
  GROUP BY CASE WHEN priority >= 0
544
777
  AND priority < 10 THEN 0 WHEN priority >= 10
545
778
  AND priority < 20 THEN 10 WHEN priority >= 20
546
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
779
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
547
780
  SNAP
548
781
 
549
782
  snapshots["produces the expected sqlite3 query plan for failed_count 1"] = <<-SNAP
783
+ CO-ROUTINE subquery
550
784
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_failed
785
+ SCAN subquery
551
786
  USE TEMP B-TREE FOR GROUP BY
552
787
  SNAP
553
788
 
554
789
  snapshots["[legacy index] produces the expected sqlite3 query plan for failed_count 1"] = <<-SNAP
555
- SCAN delayed_jobs
790
+ CO-ROUTINE subquery
791
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
792
+ USE TEMP B-TREE FOR GROUP BY
793
+ SCAN subquery
556
794
  USE TEMP B-TREE FOR GROUP BY
557
795
  SNAP
558
796
 
559
797
  snapshots["runs the expected sqlite3 query for max_lock_age 1"] = <<-SNAP
560
- SELECT CASE WHEN priority >= 0
798
+ SELECT MIN(locked_at) AS minimum_locked_at, CASE WHEN priority >= 0
561
799
  AND priority < 10 THEN 0 WHEN priority >= 10
562
800
  AND priority < 20 THEN 10 WHEN priority >= 20
563
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS priority, queue, MIN(locked_at) AS locked_at
801
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
802
+ FROM (SELECT priority, queue, MIN(locked_at) AS locked_at
564
803
  FROM \"delayed_jobs\"
565
804
  WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
566
805
  AND \"delayed_jobs\".\"failed_at\" IS NULL
567
806
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
807
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
568
808
  GROUP BY CASE WHEN priority >= 0
569
809
  AND priority < 10 THEN 0 WHEN priority >= 10
570
810
  AND priority < 20 THEN 10 WHEN priority >= 20
571
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
811
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
572
812
  SNAP
573
813
 
574
814
  snapshots["produces the expected sqlite3 query plan for max_lock_age 1"] = <<-SNAP
815
+ CO-ROUTINE subquery
575
816
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
576
817
  USE TEMP B-TREE FOR GROUP BY
818
+ SCAN subquery
819
+ USE TEMP B-TREE FOR GROUP BY
577
820
  SNAP
578
821
 
579
822
  snapshots["[legacy index] produces the expected sqlite3 query plan for max_lock_age 1"] = <<-SNAP
580
- SCAN delayed_jobs
823
+ CO-ROUTINE subquery
824
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
825
+ USE TEMP B-TREE FOR GROUP BY
826
+ SCAN subquery
581
827
  USE TEMP B-TREE FOR GROUP BY
582
828
  SNAP
583
829
 
584
830
  snapshots["runs the expected sqlite3 query for max_age 1"] = <<-SNAP
585
- SELECT (CASE WHEN priority >= 0
831
+ SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
586
832
  AND priority < 10 THEN 0 WHEN priority >= 10
587
833
  AND priority < 20 THEN 10 WHEN priority >= 20
588
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at
834
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
835
+ FROM (SELECT priority, queue, MIN(run_at) AS run_at
589
836
  FROM \"delayed_jobs\"
590
837
  WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
591
838
  OR \"delayed_jobs\".\"locked_at\" < '2025-11-10 16:59:43')
592
839
  AND \"delayed_jobs\".\"failed_at\" IS NULL
593
840
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
841
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
594
842
  GROUP BY CASE WHEN priority >= 0
595
843
  AND priority < 10 THEN 0 WHEN priority >= 10
596
844
  AND priority < 20 THEN 10 WHEN priority >= 20
597
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
845
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
598
846
  SNAP
599
847
 
600
848
  snapshots["produces the expected sqlite3 query plan for max_age 1"] = <<-SNAP
849
+ CO-ROUTINE subquery
601
850
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
602
851
  USE TEMP B-TREE FOR GROUP BY
852
+ SCAN subquery
853
+ USE TEMP B-TREE FOR GROUP BY
603
854
  SNAP
604
855
 
605
856
  snapshots["[legacy index] produces the expected sqlite3 query plan for max_age 1"] = <<-SNAP
606
- SCAN delayed_jobs
857
+ CO-ROUTINE subquery
858
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
859
+ USE TEMP B-TREE FOR GROUP BY
860
+ SCAN subquery
607
861
  USE TEMP B-TREE FOR GROUP BY
608
862
  SNAP
609
863
 
610
864
  snapshots["runs the expected sqlite3 query for working_count 1"] = <<-SNAP
611
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
865
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
612
866
  AND priority < 10 THEN 0 WHEN priority >= 10
613
867
  AND priority < 20 THEN 10 WHEN priority >= 20
614
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
868
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
869
+ FROM (SELECT priority, queue, COUNT(*) AS count
615
870
  FROM \"delayed_jobs\"
616
871
  WHERE \"delayed_jobs\".\"locked_at\" >= '2025-11-10 16:59:43'
617
872
  AND \"delayed_jobs\".\"failed_at\" IS NULL
618
873
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
874
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
619
875
  GROUP BY CASE WHEN priority >= 0
620
876
  AND priority < 10 THEN 0 WHEN priority >= 10
621
877
  AND priority < 20 THEN 10 WHEN priority >= 20
622
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
878
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
623
879
  SNAP
624
880
 
625
881
  snapshots["produces the expected sqlite3 query plan for working_count 1"] = <<-SNAP
882
+ CO-ROUTINE subquery
626
883
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
627
884
  USE TEMP B-TREE FOR GROUP BY
885
+ SCAN subquery
886
+ USE TEMP B-TREE FOR GROUP BY
628
887
  SNAP
629
888
 
630
889
  snapshots["[legacy index] produces the expected sqlite3 query plan for working_count 1"] = <<-SNAP
631
- SCAN delayed_jobs
890
+ CO-ROUTINE subquery
891
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
892
+ USE TEMP B-TREE FOR GROUP BY
893
+ SCAN subquery
632
894
  USE TEMP B-TREE FOR GROUP BY
633
895
  SNAP
634
896
 
635
897
  snapshots["runs the expected sqlite3 query for workable_count 1"] = <<-SNAP
636
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
898
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
637
899
  AND priority < 10 THEN 0 WHEN priority >= 10
638
900
  AND priority < 20 THEN 10 WHEN priority >= 20
639
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"delayed_jobs\".\"queue\" AS delayed_jobs_queue
901
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
902
+ FROM (SELECT priority, queue, COUNT(*) AS count
640
903
  FROM \"delayed_jobs\"
641
904
  WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
642
905
  OR \"delayed_jobs\".\"locked_at\" < '2025-11-10 16:59:43')
643
906
  AND \"delayed_jobs\".\"failed_at\" IS NULL
644
907
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
908
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
645
909
  GROUP BY CASE WHEN priority >= 0
646
910
  AND priority < 10 THEN 0 WHEN priority >= 10
647
911
  AND priority < 20 THEN 10 WHEN priority >= 20
648
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
912
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
649
913
  SNAP
650
914
 
651
915
  snapshots["produces the expected sqlite3 query plan for workable_count 1"] = <<-SNAP
916
+ CO-ROUTINE subquery
652
917
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
653
918
  USE TEMP B-TREE FOR GROUP BY
919
+ SCAN subquery
920
+ USE TEMP B-TREE FOR GROUP BY
654
921
  SNAP
655
922
 
656
923
  snapshots["[legacy index] produces the expected sqlite3 query plan for workable_count 1"] = <<-SNAP
657
- SCAN delayed_jobs
924
+ CO-ROUTINE subquery
925
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
926
+ USE TEMP B-TREE FOR GROUP BY
927
+ SCAN subquery
658
928
  USE TEMP B-TREE FOR GROUP BY
659
929
  SNAP
660
930
 
661
931
  snapshots["runs the expected sqlite3 query for alert_age_percent 1"] = <<-SNAP
662
- SELECT (CASE WHEN priority >= 0
932
+ SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
663
933
  AND priority < 10 THEN 0 WHEN priority >= 10
664
934
  AND priority < 20 THEN 10 WHEN priority >= 20
665
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at
935
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, \"queue\" AS queue
936
+ FROM (SELECT priority, queue, MIN(run_at) AS run_at
666
937
  FROM \"delayed_jobs\"
667
938
  WHERE (\"delayed_jobs\".\"locked_at\" IS NULL
668
939
  OR \"delayed_jobs\".\"locked_at\" < '2025-11-10 16:59:43')
669
940
  AND \"delayed_jobs\".\"failed_at\" IS NULL
670
941
  AND \"delayed_jobs\".\"run_at\" <= '2025-11-10 17:20:13'
942
+ GROUP BY \"delayed_jobs\".\"priority\", \"delayed_jobs\".\"queue\") subquery
671
943
  GROUP BY CASE WHEN priority >= 0
672
944
  AND priority < 10 THEN 0 WHEN priority >= 10
673
945
  AND priority < 20 THEN 10 WHEN priority >= 20
674
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"delayed_jobs\".\"queue\"
946
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, \"queue\"
675
947
  SNAP
676
948
 
677
949
  snapshots["produces the expected sqlite3 query plan for alert_age_percent 1"] = <<-SNAP
950
+ CO-ROUTINE subquery
678
951
  SCAN delayed_jobs USING INDEX idx_delayed_jobs_live
679
952
  USE TEMP B-TREE FOR GROUP BY
953
+ SCAN subquery
954
+ USE TEMP B-TREE FOR GROUP BY
680
955
  SNAP
681
956
 
682
957
  snapshots["[legacy index] produces the expected sqlite3 query plan for alert_age_percent 1"] = <<-SNAP
683
- SCAN delayed_jobs
958
+ CO-ROUTINE subquery
959
+ SCAN delayed_jobs USING INDEX delayed_jobs_priority
960
+ USE TEMP B-TREE FOR GROUP BY
961
+ SCAN subquery
684
962
  USE TEMP B-TREE FOR GROUP BY
685
963
  SNAP
686
964
 
687
965
  snapshots["runs the expected mysql2 query for count 1"] = <<-SNAP
688
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
966
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
689
967
  AND priority < 10 THEN 0 WHEN priority >= 10
690
968
  AND priority < 20 THEN 10 WHEN priority >= 20
691
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
969
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
970
+ FROM (SELECT priority, queue, COUNT(*) AS count
692
971
  FROM `delayed_jobs`
972
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
693
973
  GROUP BY CASE WHEN priority >= 0
694
974
  AND priority < 10 THEN 0 WHEN priority >= 10
695
975
  AND priority < 20 THEN 10 WHEN priority >= 20
696
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
976
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
697
977
  SNAP
698
978
 
699
979
  snapshots["produces the expected mysql2 query plan for count 1"] = <<-SNAP
700
980
  -> Table scan on <temporary>
701
981
  -> Aggregate using temporary table
702
- -> Covering index scan on delayed_jobs using idx_delayed_jobs_live (cost=...)
982
+ -> Table scan on subquery (cost=...)
983
+ -> Materialize (cost=...)
984
+ -> Table scan on <temporary>
985
+ -> Aggregate using temporary table
986
+ -> Covering index scan on delayed_jobs using idx_delayed_jobs_live (cost=...)
703
987
  SNAP
704
988
 
705
989
  snapshots["[legacy index] produces the expected mysql2 query plan for count 1"] = <<-SNAP
706
990
  -> Table scan on <temporary>
707
991
  -> Aggregate using temporary table
708
- -> Table scan on delayed_jobs (cost=...)
992
+ -> Table scan on subquery (cost=...)
993
+ -> Materialize (cost=...)
994
+ -> Table scan on <temporary>
995
+ -> Aggregate using temporary table
996
+ -> Table scan on delayed_jobs (cost=...)
709
997
  SNAP
710
998
 
711
999
  snapshots["runs the expected mysql2 query for future_count 1"] = <<-SNAP
712
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
1000
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
713
1001
  AND priority < 10 THEN 0 WHEN priority >= 10
714
1002
  AND priority < 20 THEN 10 WHEN priority >= 20
715
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
1003
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1004
+ FROM (SELECT priority, queue, COUNT(*) AS count
716
1005
  FROM `delayed_jobs`
717
1006
  WHERE `delayed_jobs`.`failed_at` IS NULL
718
1007
  AND `delayed_jobs`.`run_at` > '2025-11-10 17:20:13'
1008
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
719
1009
  GROUP BY CASE WHEN priority >= 0
720
1010
  AND priority < 10 THEN 0 WHEN priority >= 10
721
1011
  AND priority < 20 THEN 10 WHEN priority >= 20
722
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1012
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
723
1013
  SNAP
724
1014
 
725
1015
  snapshots["produces the expected mysql2 query plan for future_count 1"] = <<-SNAP
726
1016
  -> Table scan on <temporary>
727
1017
  -> Aggregate using temporary table
728
- -> Filter: ((delayed_jobs.failed_at is null) and (delayed_jobs.run_at > TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
729
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1018
+ -> Table scan on subquery (cost=...)
1019
+ -> Materialize (cost=...)
1020
+ -> Table scan on <temporary>
1021
+ -> Aggregate using temporary table
1022
+ -> Filter: ((delayed_jobs.failed_at is null) and (delayed_jobs.run_at > TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1023
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
730
1024
  SNAP
731
1025
 
732
1026
  snapshots["[legacy index] produces the expected mysql2 query plan for future_count 1"] = <<-SNAP
733
1027
  -> Table scan on <temporary>
734
1028
  -> Aggregate using temporary table
735
- -> Filter: ((delayed_jobs.failed_at is null) and (delayed_jobs.run_at > TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
736
- -> Table scan on delayed_jobs (cost=...)
1029
+ -> Table scan on subquery (cost=...)
1030
+ -> Materialize (cost=...)
1031
+ -> Table scan on <temporary>
1032
+ -> Aggregate using temporary table
1033
+ -> Filter: ((delayed_jobs.failed_at is null) and (delayed_jobs.run_at > TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1034
+ -> Table scan on delayed_jobs (cost=...)
737
1035
  SNAP
738
1036
 
739
1037
  snapshots["runs the expected mysql2 query for locked_count 1"] = <<-SNAP
740
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
1038
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
741
1039
  AND priority < 10 THEN 0 WHEN priority >= 10
742
1040
  AND priority < 20 THEN 10 WHEN priority >= 20
743
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
1041
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1042
+ FROM (SELECT priority, queue, COUNT(*) AS count
744
1043
  FROM `delayed_jobs`
745
1044
  WHERE `delayed_jobs`.`locked_at` >= '2025-11-10 16:59:43'
746
1045
  AND `delayed_jobs`.`failed_at` IS NULL
747
1046
  AND `delayed_jobs`.`run_at` <= '2025-11-10 17:20:13'
1047
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
748
1048
  GROUP BY CASE WHEN priority >= 0
749
1049
  AND priority < 10 THEN 0 WHEN priority >= 10
750
1050
  AND priority < 20 THEN 10 WHEN priority >= 20
751
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1051
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
752
1052
  SNAP
753
1053
 
754
1054
  snapshots["produces the expected mysql2 query plan for locked_count 1"] = <<-SNAP
755
1055
  -> Table scan on <temporary>
756
1056
  -> Aggregate using temporary table
757
- -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
758
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1057
+ -> Table scan on subquery (cost=...)
1058
+ -> Materialize (cost=...)
1059
+ -> Table scan on <temporary>
1060
+ -> Aggregate using temporary table
1061
+ -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1062
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
759
1063
  SNAP
760
1064
 
761
1065
  snapshots["[legacy index] produces the expected mysql2 query plan for locked_count 1"] = <<-SNAP
762
1066
  -> Table scan on <temporary>
763
1067
  -> Aggregate using temporary table
764
- -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
765
- -> Table scan on delayed_jobs (cost=...)
1068
+ -> Table scan on subquery (cost=...)
1069
+ -> Materialize (cost=...)
1070
+ -> Table scan on <temporary>
1071
+ -> Aggregate using temporary table
1072
+ -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1073
+ -> Table scan on delayed_jobs (cost=...)
766
1074
  SNAP
767
1075
 
768
1076
  snapshots["runs the expected mysql2 query for erroring_count 1"] = <<-SNAP
769
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
1077
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
770
1078
  AND priority < 10 THEN 0 WHEN priority >= 10
771
1079
  AND priority < 20 THEN 10 WHEN priority >= 20
772
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
1080
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1081
+ FROM (SELECT priority, queue, COUNT(*) AS count
773
1082
  FROM `delayed_jobs`
774
1083
  WHERE `delayed_jobs`.`attempts` > 0
775
1084
  AND `delayed_jobs`.`failed_at` IS NULL
1085
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
776
1086
  GROUP BY CASE WHEN priority >= 0
777
1087
  AND priority < 10 THEN 0 WHEN priority >= 10
778
1088
  AND priority < 20 THEN 10 WHEN priority >= 20
779
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1089
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
780
1090
  SNAP
781
1091
 
782
1092
  snapshots["produces the expected mysql2 query plan for erroring_count 1"] = <<-SNAP
783
1093
  -> Table scan on <temporary>
784
1094
  -> Aggregate using temporary table
785
- -> Filter: ((delayed_jobs.attempts > 0) and (delayed_jobs.failed_at is null)) (cost=...)
786
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1095
+ -> Table scan on subquery (cost=...)
1096
+ -> Materialize (cost=...)
1097
+ -> Table scan on <temporary>
1098
+ -> Aggregate using temporary table
1099
+ -> Filter: ((delayed_jobs.attempts > 0) and (delayed_jobs.failed_at is null)) (cost=...)
1100
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
787
1101
  SNAP
788
1102
 
789
1103
  snapshots["[legacy index] produces the expected mysql2 query plan for erroring_count 1"] = <<-SNAP
790
1104
  -> Table scan on <temporary>
791
1105
  -> Aggregate using temporary table
792
- -> Filter: ((delayed_jobs.attempts > 0) and (delayed_jobs.failed_at is null)) (cost=...)
793
- -> Table scan on delayed_jobs (cost=...)
1106
+ -> Table scan on subquery (cost=...)
1107
+ -> Materialize (cost=...)
1108
+ -> Table scan on <temporary>
1109
+ -> Aggregate using temporary table
1110
+ -> Filter: ((delayed_jobs.attempts > 0) and (delayed_jobs.failed_at is null)) (cost=...)
1111
+ -> Table scan on delayed_jobs (cost=...)
794
1112
  SNAP
795
1113
 
796
1114
  snapshots["runs the expected mysql2 query for failed_count 1"] = <<-SNAP
797
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
1115
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
798
1116
  AND priority < 10 THEN 0 WHEN priority >= 10
799
1117
  AND priority < 20 THEN 10 WHEN priority >= 20
800
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
1118
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1119
+ FROM (SELECT priority, queue, COUNT(*) AS count
801
1120
  FROM `delayed_jobs`
802
1121
  WHERE `delayed_jobs`.`failed_at` IS NOT NULL
1122
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
803
1123
  GROUP BY CASE WHEN priority >= 0
804
1124
  AND priority < 10 THEN 0 WHEN priority >= 10
805
1125
  AND priority < 20 THEN 10 WHEN priority >= 20
806
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1126
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
807
1127
  SNAP
808
1128
 
809
1129
  snapshots["produces the expected mysql2 query plan for failed_count 1"] = <<-SNAP
810
1130
  -> Table scan on <temporary>
811
1131
  -> Aggregate using temporary table
812
- -> Filter: (delayed_jobs.failed_at is not null) (cost=...)
813
- -> Covering index range scan on delayed_jobs using idx_delayed_jobs_live over (NULL < failed_at) (cost=...)
1132
+ -> Table scan on subquery (cost=...)
1133
+ -> Materialize (cost=...)
1134
+ -> Table scan on <temporary>
1135
+ -> Aggregate using temporary table
1136
+ -> Filter: (delayed_jobs.failed_at is not null) (cost=...)
1137
+ -> Covering index range scan on delayed_jobs using idx_delayed_jobs_live over (NULL < failed_at) (cost=...)
814
1138
  SNAP
815
1139
 
816
1140
  snapshots["[legacy index] produces the expected mysql2 query plan for failed_count 1"] = <<-SNAP
817
1141
  -> Table scan on <temporary>
818
1142
  -> Aggregate using temporary table
819
- -> Filter: (delayed_jobs.failed_at is not null) (cost=...)
820
- -> Table scan on delayed_jobs (cost=...)
1143
+ -> Table scan on subquery (cost=...)
1144
+ -> Materialize (cost=...)
1145
+ -> Table scan on <temporary>
1146
+ -> Aggregate using temporary table
1147
+ -> Filter: (delayed_jobs.failed_at is not null) (cost=...)
1148
+ -> Table scan on delayed_jobs (cost=...)
821
1149
  SNAP
822
1150
 
823
1151
  snapshots["runs the expected mysql2 query for max_lock_age 1"] = <<-SNAP
824
- SELECT CASE WHEN priority >= 0
1152
+ SELECT MIN(locked_at) AS minimum_locked_at, CASE WHEN priority >= 0
825
1153
  AND priority < 10 THEN 0 WHEN priority >= 10
826
1154
  AND priority < 20 THEN 10 WHEN priority >= 20
827
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS priority, queue, MIN(locked_at) AS locked_at
1155
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1156
+ FROM (SELECT priority, queue, MIN(locked_at) AS locked_at
828
1157
  FROM `delayed_jobs`
829
1158
  WHERE `delayed_jobs`.`locked_at` >= '2025-11-10 16:59:43'
830
1159
  AND `delayed_jobs`.`failed_at` IS NULL
831
1160
  AND `delayed_jobs`.`run_at` <= '2025-11-10 17:20:13'
1161
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
832
1162
  GROUP BY CASE WHEN priority >= 0
833
1163
  AND priority < 10 THEN 0 WHEN priority >= 10
834
1164
  AND priority < 20 THEN 10 WHEN priority >= 20
835
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1165
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
836
1166
  SNAP
837
1167
 
838
1168
  snapshots["produces the expected mysql2 query plan for max_lock_age 1"] = <<-SNAP
839
1169
  -> Table scan on <temporary>
840
1170
  -> Aggregate using temporary table
841
- -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
842
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1171
+ -> Table scan on subquery (cost=...)
1172
+ -> Materialize (cost=...)
1173
+ -> Table scan on <temporary>
1174
+ -> Aggregate using temporary table
1175
+ -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1176
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
843
1177
  SNAP
844
1178
 
845
1179
  snapshots["[legacy index] produces the expected mysql2 query plan for max_lock_age 1"] = <<-SNAP
846
1180
  -> Table scan on <temporary>
847
1181
  -> Aggregate using temporary table
848
- -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
849
- -> Table scan on delayed_jobs (cost=...)
1182
+ -> Table scan on subquery (cost=...)
1183
+ -> Materialize (cost=...)
1184
+ -> Table scan on <temporary>
1185
+ -> Aggregate using temporary table
1186
+ -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1187
+ -> Table scan on delayed_jobs (cost=...)
850
1188
  SNAP
851
1189
 
852
1190
  snapshots["runs the expected mysql2 query for max_age 1"] = <<-SNAP
853
- SELECT (CASE WHEN priority >= 0
1191
+ SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
854
1192
  AND priority < 10 THEN 0 WHEN priority >= 10
855
1193
  AND priority < 20 THEN 10 WHEN priority >= 20
856
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at
1194
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1195
+ FROM (SELECT priority, queue, MIN(run_at) AS run_at
857
1196
  FROM `delayed_jobs`
858
1197
  WHERE (`delayed_jobs`.`locked_at` IS NULL
859
1198
  OR `delayed_jobs`.`locked_at` < '2025-11-10 16:59:43')
860
1199
  AND `delayed_jobs`.`failed_at` IS NULL
861
1200
  AND `delayed_jobs`.`run_at` <= '2025-11-10 17:20:13'
1201
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
862
1202
  GROUP BY CASE WHEN priority >= 0
863
1203
  AND priority < 10 THEN 0 WHEN priority >= 10
864
1204
  AND priority < 20 THEN 10 WHEN priority >= 20
865
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1205
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
866
1206
  SNAP
867
1207
 
868
1208
  snapshots["produces the expected mysql2 query plan for max_age 1"] = <<-SNAP
869
1209
  -> Table scan on <temporary>
870
1210
  -> Aggregate using temporary table
871
- -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
872
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1211
+ -> Table scan on subquery (cost=...)
1212
+ -> Materialize (cost=...)
1213
+ -> Table scan on <temporary>
1214
+ -> Aggregate using temporary table
1215
+ -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1216
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
873
1217
  SNAP
874
1218
 
875
1219
  snapshots["[legacy index] produces the expected mysql2 query plan for max_age 1"] = <<-SNAP
876
1220
  -> Table scan on <temporary>
877
1221
  -> Aggregate using temporary table
878
- -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
879
- -> Table scan on delayed_jobs (cost=...)
1222
+ -> Table scan on subquery (cost=...)
1223
+ -> Materialize (cost=...)
1224
+ -> Table scan on <temporary>
1225
+ -> Aggregate using temporary table
1226
+ -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1227
+ -> Table scan on delayed_jobs (cost=...)
880
1228
  SNAP
881
1229
 
882
1230
  snapshots["runs the expected mysql2 query for working_count 1"] = <<-SNAP
883
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
1231
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
884
1232
  AND priority < 10 THEN 0 WHEN priority >= 10
885
1233
  AND priority < 20 THEN 10 WHEN priority >= 20
886
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
1234
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1235
+ FROM (SELECT priority, queue, COUNT(*) AS count
887
1236
  FROM `delayed_jobs`
888
1237
  WHERE `delayed_jobs`.`locked_at` >= '2025-11-10 16:59:43'
889
1238
  AND `delayed_jobs`.`failed_at` IS NULL
890
1239
  AND `delayed_jobs`.`run_at` <= '2025-11-10 17:20:13'
1240
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
891
1241
  GROUP BY CASE WHEN priority >= 0
892
1242
  AND priority < 10 THEN 0 WHEN priority >= 10
893
1243
  AND priority < 20 THEN 10 WHEN priority >= 20
894
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1244
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
895
1245
  SNAP
896
1246
 
897
1247
  snapshots["produces the expected mysql2 query plan for working_count 1"] = <<-SNAP
898
1248
  -> Table scan on <temporary>
899
1249
  -> Aggregate using temporary table
900
- -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
901
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1250
+ -> Table scan on subquery (cost=...)
1251
+ -> Materialize (cost=...)
1252
+ -> Table scan on <temporary>
1253
+ -> Aggregate using temporary table
1254
+ -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1255
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
902
1256
  SNAP
903
1257
 
904
1258
  snapshots["[legacy index] produces the expected mysql2 query plan for working_count 1"] = <<-SNAP
905
1259
  -> Table scan on <temporary>
906
1260
  -> Aggregate using temporary table
907
- -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
908
- -> Table scan on delayed_jobs (cost=...)
1261
+ -> Table scan on subquery (cost=...)
1262
+ -> Materialize (cost=...)
1263
+ -> Table scan on <temporary>
1264
+ -> Aggregate using temporary table
1265
+ -> Filter: ((delayed_jobs.locked_at >= TIMESTAMP'2025-11-10 16:59:43') and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1266
+ -> Table scan on delayed_jobs (cost=...)
909
1267
  SNAP
910
1268
 
911
1269
  snapshots["runs the expected mysql2 query for workable_count 1"] = <<-SNAP
912
- SELECT COUNT(*) AS count_all, CASE WHEN priority >= 0
1270
+ SELECT SUM(count) AS sum_count, CASE WHEN priority >= 0
913
1271
  AND priority < 10 THEN 0 WHEN priority >= 10
914
1272
  AND priority < 20 THEN 10 WHEN priority >= 20
915
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `delayed_jobs`.`queue` AS delayed_jobs_queue
1273
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1274
+ FROM (SELECT priority, queue, COUNT(*) AS count
916
1275
  FROM `delayed_jobs`
917
1276
  WHERE (`delayed_jobs`.`locked_at` IS NULL
918
1277
  OR `delayed_jobs`.`locked_at` < '2025-11-10 16:59:43')
919
1278
  AND `delayed_jobs`.`failed_at` IS NULL
920
1279
  AND `delayed_jobs`.`run_at` <= '2025-11-10 17:20:13'
1280
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
921
1281
  GROUP BY CASE WHEN priority >= 0
922
1282
  AND priority < 10 THEN 0 WHEN priority >= 10
923
1283
  AND priority < 20 THEN 10 WHEN priority >= 20
924
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1284
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
925
1285
  SNAP
926
1286
 
927
1287
  snapshots["produces the expected mysql2 query plan for workable_count 1"] = <<-SNAP
928
1288
  -> Table scan on <temporary>
929
1289
  -> Aggregate using temporary table
930
- -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
931
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1290
+ -> Table scan on subquery (cost=...)
1291
+ -> Materialize (cost=...)
1292
+ -> Table scan on <temporary>
1293
+ -> Aggregate using temporary table
1294
+ -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1295
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
932
1296
  SNAP
933
1297
 
934
1298
  snapshots["[legacy index] produces the expected mysql2 query plan for workable_count 1"] = <<-SNAP
935
1299
  -> Table scan on <temporary>
936
1300
  -> Aggregate using temporary table
937
- -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
938
- -> Table scan on delayed_jobs (cost=...)
1301
+ -> Table scan on subquery (cost=...)
1302
+ -> Materialize (cost=...)
1303
+ -> Table scan on <temporary>
1304
+ -> Aggregate using temporary table
1305
+ -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1306
+ -> Table scan on delayed_jobs (cost=...)
939
1307
  SNAP
940
1308
 
941
1309
  snapshots["runs the expected mysql2 query for alert_age_percent 1"] = <<-SNAP
942
- SELECT (CASE WHEN priority >= 0
1310
+ SELECT MIN(run_at) AS minimum_run_at, CASE WHEN priority >= 0
943
1311
  AND priority < 10 THEN 0 WHEN priority >= 10
944
1312
  AND priority < 20 THEN 10 WHEN priority >= 20
945
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END) AS priority, queue, MIN(run_at) AS run_at
1313
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END AS case_when_priority_0_and_priority_10_then_0_when_priority_10_an, `queue` AS queue
1314
+ FROM (SELECT priority, queue, MIN(run_at) AS run_at
946
1315
  FROM `delayed_jobs`
947
1316
  WHERE (`delayed_jobs`.`locked_at` IS NULL
948
1317
  OR `delayed_jobs`.`locked_at` < '2025-11-10 16:59:43')
949
1318
  AND `delayed_jobs`.`failed_at` IS NULL
950
1319
  AND `delayed_jobs`.`run_at` <= '2025-11-10 17:20:13'
1320
+ GROUP BY `delayed_jobs`.`priority`, `delayed_jobs`.`queue`) subquery
951
1321
  GROUP BY CASE WHEN priority >= 0
952
1322
  AND priority < 10 THEN 0 WHEN priority >= 10
953
1323
  AND priority < 20 THEN 10 WHEN priority >= 20
954
- AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `delayed_jobs`.`queue`
1324
+ AND priority < 30 THEN 20 WHEN priority >= 30 THEN 30 END, `queue`
955
1325
  SNAP
956
1326
 
957
1327
  snapshots["produces the expected mysql2 query plan for alert_age_percent 1"] = <<-SNAP
958
1328
  -> Table scan on <temporary>
959
1329
  -> Aggregate using temporary table
960
- -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
961
- -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
1330
+ -> Table scan on subquery (cost=...)
1331
+ -> Materialize (cost=...)
1332
+ -> Table scan on <temporary>
1333
+ -> Aggregate using temporary table
1334
+ -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1335
+ -> Covering index lookup on delayed_jobs using idx_delayed_jobs_live (failed_at = NULL) (cost=...)
962
1336
  SNAP
963
1337
 
964
1338
  snapshots["[legacy index] produces the expected mysql2 query plan for alert_age_percent 1"] = <<-SNAP
965
1339
  -> Table scan on <temporary>
966
1340
  -> Aggregate using temporary table
967
- -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
968
- -> Table scan on delayed_jobs (cost=...)
1341
+ -> Table scan on subquery (cost=...)
1342
+ -> Materialize (cost=...)
1343
+ -> Table scan on <temporary>
1344
+ -> Aggregate using temporary table
1345
+ -> Filter: (((delayed_jobs.locked_at is null) or (delayed_jobs.locked_at < TIMESTAMP'2025-11-10 16:59:43')) and (delayed_jobs.failed_at is null) and (delayed_jobs.run_at <= TIMESTAMP'2025-11-10 17:20:13')) (cost=...)
1346
+ -> Table scan on delayed_jobs (cost=...)
969
1347
  SNAP