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