iddqueue 0.13.0rc1__py3-none-any.whl

iddqueue/history.py

@@ -0,0 +1,70 @@
+"""Optional per-execution diagnostics, independent of queue/result retention."""
+from uuid import uuid4
+
+from dramatiq.middleware import Middleware
+from psycopg import sql
+
+from .utils import transaction
+
+
+def attempt_table(schema, prefix):
+    return sql.Identifier(schema, prefix + "attempts")
+
+
+class AttemptHistory(Middleware):
+    def before_process_message(self, broker, message):
+        attempt_id = uuid4()
+        with transaction(broker.pool) as curs:
+            curs.execute(sql.SQL(
+                "INSERT INTO {} (attempt_id, message_id, queue_name, actor_name) VALUES (%s, %s, %s, %s)"
+            ).format(attempt_table(broker.queries.schema, broker.queries.prefix)),
+                         (attempt_id, message.message_id, message.queue_name, message.actor_name))
+        message._pg_attempt_id = attempt_id
+
+    def after_process_message(self, broker, message, *, result=None, exception=None):
+        attempt_id = getattr(message, "_pg_attempt_id", None)
+        if attempt_id is None:
+            return
+        with transaction(broker.pool) as curs:
+            curs.execute(sql.SQL(
+                "UPDATE {} SET finished_at = clock_timestamp(), outcome = %s, error_type = %s, "
+                "error_text = %s WHERE attempt_id = %s"
+            ).format(attempt_table(broker.queries.schema, broker.queries.prefix)),
+                         ("successful" if exception is None else "failed",
+                          type(exception).__name__ if exception is not None else None,
+                          str(exception)[:2000] if exception is not None else None, attempt_id))
+
+
+def list_attempts(pool, message_id, *, schema="dramatiq", prefix="", limit=50, after=None):
+    if not 1 <= limit <= 1000:
+        raise ValueError("limit must be between 1 and 1000")
+    with transaction(pool) as curs:
+        curs.execute(sql.SQL(
+            "SELECT attempt_id, message_id, queue_name, actor_name, started_at, finished_at, "
+            "COALESCE(outcome, 'incomplete'), error_type, error_text FROM {} "
+            "WHERE message_id = %s AND (%s::uuid IS NULL OR attempt_id > %s) "
+            "ORDER BY attempt_id LIMIT %s"
+        ).format(attempt_table(schema, prefix)), (message_id, after, after, limit + 1))
+        rows = curs.fetchall()
+    names = ("attempt_id", "message_id", "queue", "actor", "started_at", "finished_at",
+             "outcome", "error_type", "error_text")
+    items = []
+    for row in rows[:limit]:
+        item = dict(zip(names, row))
+        item["duration_ms"] = (row[5] - row[4]).total_seconds() * 1000 if row[5] else None
+        for key in ("attempt_id", "message_id"):
+            item[key] = str(item[key])
+        for key in ("started_at", "finished_at"):
+            item[key] = item[key].isoformat() if item[key] else None
+        items.append(item)
+    return dict(items=items, next_after=items[-1]["attempt_id"] if len(rows) > limit else None)
+
+
+def purge_attempts(pool, maxage="30 days", *, schema="dramatiq", prefix=""):
+    with transaction(pool) as curs:
+        curs.execute("SELECT %s::interval > interval '0'", (maxage,))
+        if not curs.fetchone()[0]:
+            raise ValueError("maxage must be positive")
+        curs.execute(sql.SQL("DELETE FROM {} WHERE started_at < clock_timestamp() - %s::interval")
+                     .format(attempt_table(schema, prefix)), (maxage,))
+        return curs.rowcount

iddqueue/history.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS :"schema".:"attempts" (
+    attempt_id UUID PRIMARY KEY,
+    message_id UUID NOT NULL,
+    queue_name TEXT NOT NULL,
+    actor_name TEXT NOT NULL,
+    started_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
+    finished_at TIMESTAMPTZ,
+    outcome TEXT CHECK (outcome IN ('successful', 'failed')),
+    error_type TEXT,
+    error_text TEXT CHECK (length(error_text) <= 2000)
+);
+CREATE INDEX IF NOT EXISTS :"attempts_message" ON :"schema".:"attempts" (message_id, attempt_id);
+CREATE INDEX IF NOT EXISTS :"attempts_age" ON :"schema".:"attempts" (started_at);

iddqueue/metrics.py

@@ -0,0 +1,68 @@
+"""Queue snapshots; Prometheus is imported only when collecting metrics."""
+
+from psycopg import sql
+
+from .utils import transaction
+
+STATES = ("queued", "consumed", "done", "rejected", "cancelled")
+
+
+def statistics_query(schema="dramatiq", prefix=""):
+    return sql.SQL("""
+        SELECT queue_name,
+            count(*) FILTER (WHERE state = 'queued'),
+            count(*) FILTER (WHERE state = 'consumed'),
+            count(*) FILTER (WHERE state = 'done'),
+            count(*) FILTER (WHERE state = 'rejected'),
+            count(*) FILTER (WHERE state = 'cancelled'),
+            count(*) FILTER (WHERE state = 'queued' AND ready_at <= now()),
+            count(*) FILTER (WHERE state IN ('queued', 'consumed') AND ready_at > now()),
+            coalesce(greatest(0, extract(epoch FROM now() - min(ready_at)
+                FILTER (WHERE state = 'queued' AND ready_at <= now()))), 0)
+        FROM (
+            SELECT *, greatest(mtime,
+                to_timestamp(coalesce((message->'options'->>'eta')::double precision / 1000, 0))) AS ready_at
+            FROM {} WHERE (%s::text IS NULL OR queue_name = %s)
+        ) AS messages GROUP BY queue_name ORDER BY queue_name
+    """).format(sql.Identifier(schema, prefix + "queue"))
+
+
+def queue_statistics(pool, *, schema="dramatiq", prefix="", queue=None):
+    with transaction(pool) as cursor:
+        cursor.execute(statistics_query(schema, prefix), (queue, queue))
+        rows = cursor.fetchall()
+    snapshots = [dict(queue=row[0], counts=dict(zip(STATES, row[1:6])),
+                      ready=row[6], scheduled=row[7], oldest_ready_seconds=float(row[8]))
+                 for row in rows]
+    if not snapshots and queue is not None:
+        snapshots.append(dict(queue=queue, counts=dict.fromkeys(STATES, 0),
+                              ready=0, scheduled=0, oldest_ready_seconds=0.0))
+    return snapshots
+
+
+class PostgresQueueCollector:
+    """Register in an exporter process; the caller owns the pool."""
+
+    def __init__(self, pool, *, schema="dramatiq", prefix="", queue=None):
+        self.pool = pool
+        self.options = dict(schema=schema, prefix=prefix, queue=queue)
+
+    def describe(self):
+        # Avoid database access during registry registration.
+        return iter(())
+
+    def collect(self):
+        from prometheus_client.core import GaugeMetricFamily
+
+        counts = GaugeMetricFamily("iddqueue_queue_messages", "Stored messages by state", labels=["queue", "state"])
+        ready = GaugeMetricFamily("iddqueue_queue_ready", "Ready queued messages", labels=["queue"])
+        scheduled = GaugeMetricFamily("iddqueue_queue_scheduled", "Future delayed messages, including prefetched", labels=["queue"])
+        age = GaugeMetricFamily("iddqueue_queue_oldest_ready_seconds", "Age of oldest ready queued message", labels=["queue"])
+        for snapshot in queue_statistics(self.pool, **self.options):
+            queue = snapshot["queue"]
+            for state, count in snapshot["counts"].items():
+                counts.add_metric([queue, state], count)
+            ready.add_metric([queue], snapshot["ready"])
+            scheduled.add_metric([queue], snapshot["scheduled"])
+            age.add_metric([queue], snapshot["oldest_ready_seconds"])
+        yield from (counts, ready, scheduled, age)

iddqueue/rate_limits.py

@@ -0,0 +1,122 @@
+"""PostgreSQL storage for Dramatiq's standard limiters and barriers."""
+
+import hashlib
+import time
+
+from dramatiq.rate_limits.backend import RateLimiterBackend
+from psycopg import sql
+
+from .utils import make_pool, storage_namespace, transaction, wait_for_notifies
+
+
+class PostgresRateLimiterBackend(RateLimiterBackend):
+    def __init__(self, *, url=None, pool=None, schema="dramatiq", prefix=""):
+        if pool is not None and url:
+            raise ValueError("You can't set both pool and URL!")
+        self._owns_pool = pool is None
+        self.pool = make_pool(url or "") if pool is None else pool
+        self.table = sql.Identifier(schema, prefix + "coordination")
+        self.namespace = storage_namespace(schema, prefix)
+
+    def close(self):
+        if self._owns_pool:
+            self.pool.close()
+
+    def _digest(self, key):
+        return hashlib.sha256((self.namespace + key).encode()).digest()
+
+    def _lock(self, curs, keys):
+        # Every counter mutation uses the same locks, including missing rows.
+        locks = {int.from_bytes(self._digest(key)[:8], "big", signed=True) for key in keys}
+        for lock in sorted(locks):
+            curs.execute("SELECT pg_advisory_xact_lock(%s)", (lock,))
+
+    def _values(self, curs, keys):
+        curs.execute(sql.SQL(
+            "SELECT key, value FROM {} WHERE key = ANY(%s) "
+            "AND expires_at > clock_timestamp()"
+        ).format(self.table), (list(keys),))
+        return dict(curs.fetchall())
+
+    def _put(self, curs, key, value, ttl):
+        curs.execute(sql.SQL(
+            "INSERT INTO {} AS target (key, value, expires_at) "
+            "VALUES (%s, %s, clock_timestamp() + %s * interval '1 millisecond') "
+            "ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, "
+            "expires_at = EXCLUDED.expires_at"
+        ).format(self.table), (key, value, ttl))
+
+    def add(self, key, value, ttl):
+        with transaction(self.pool) as curs:
+            self._lock(curs, [key])
+            if key in self._values(curs, [key]):
+                return False
+            self._put(curs, key, value, ttl)
+            return True
+
+    def _change(self, key, amount, bound, ttl, *, decrement=False):
+        with transaction(self.pool) as curs:
+            self._lock(curs, [key])
+            value = self._values(curs, [key]).get(key, 0) + amount
+            if (value < bound) if decrement else (value > bound):
+                return False
+            self._put(curs, key, value, ttl)
+            return True
+
+    def incr(self, key, amount, maximum, ttl):
+        return self._change(key, amount, maximum, ttl)
+
+    def decr(self, key, amount, minimum, ttl):
+        return self._change(key, -amount, minimum, ttl, decrement=True)
+
+    def incr_and_sum(self, key, keys, amount, maximum, ttl):
+        while True:
+            with transaction(self.pool) as curs:
+                window_keys = list(keys())
+                self._lock(curs, [key, *window_keys])
+                # The window may advance while this transaction waits for locks.
+                # Restart to lock its new keys in the same global order.
+                if list(keys()) != window_keys:
+                    continue
+                values = self._values(curs, [key, *window_keys])
+                value = values.get(key, 0) + amount
+                if value > maximum or amount + sum(values.get(k, 0) for k in window_keys) > maximum:
+                    return False
+                self._put(curs, key, value, ttl)
+                return True
+
+    def _channel(self, key):
+        return "dpg.c." + self._digest(key).hex()[:48]
+
+    def wait(self, key, timeout):
+        deadline = None if timeout is None else time.monotonic() + timeout / 1000
+        with transaction(self.pool, listen=self._channel(key)) as curs:
+            while True:
+                curs.execute(sql.SQL(
+                    "SELECT 1 FROM {} WHERE key = %s "
+                    "AND event_expires_at > clock_timestamp()"
+                ).format(self.table), (key,))
+                if curs.fetchone() is not None:
+                    return True
+                remaining = None if deadline is None else deadline - time.monotonic()
+                if remaining is not None and remaining <= 0:
+                    return False
+                wait_for_notifies(curs.connection, timeout=remaining)
+
+    def wait_notify(self, key, ttl):
+        with transaction(self.pool) as curs:
+            curs.execute(sql.SQL(
+                "INSERT INTO {} (key, event_expires_at) "
+                "VALUES (%s, clock_timestamp() + %s * interval '1 millisecond') "
+                "ON CONFLICT (key) DO UPDATE SET event_expires_at = EXCLUDED.event_expires_at"
+            ).format(self.table), (key, ttl))
+            curs.execute("SELECT pg_notify(%s, '')", (self._channel(key),))
+
+    def purge(self):
+        """Remove expired counters and events; schedule periodically."""
+        with transaction(self.pool) as curs:
+            curs.execute(sql.SQL(
+                "DELETE FROM {} WHERE expires_at <= clock_timestamp() "
+                "AND event_expires_at <= clock_timestamp()"
+            ).format(self.table))
+            return curs.rowcount

iddqueue/results.py

@@ -0,0 +1,118 @@
+#
+#       R E S U L T S
+#
+# Implements a result backend using Postgres. See
+# https://dramatiq.io/cookbook.html#results.
+#
+
+import logging
+import time
+from textwrap import dedent
+
+from dramatiq.results import ResultBackend, ResultMissing, ResultTimeout
+from psycopg.types.json import Jsonb
+
+from .cancellation import ResultCancelled
+from .utils import (
+    QueryManager,
+    make_pool,
+    retry_pg,
+    tidy4json,
+    transaction,
+    wait_for_notifies,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class PostgresBackend(ResultBackend):
+    def __init__(self, *, url=None, pool=None, schema=None, prefix=None, **kw):
+        if kw.get("use_namespace_prefix_keys"):
+            raise ValueError("use_namespace_prefix_keys is unsupported for UUID results; use schema/prefix isolation")
+        super().__init__(**kw)
+
+        if pool is not None and url:
+            raise ValueError("You can't set both pool and URL!")
+        self._owns_pool = pool is None
+        self.pool = make_pool(url or "") if pool is None else pool
+
+        self.queries = QueryManager(QUERIES.queries, schema or "dramatiq", prefix or "")
+
+    def close(self):
+        if self._owns_pool:
+            self.pool.close()
+
+    def build_message_key(self, message):
+        # Just use message_id, it's UNIQUE in table.
+        return str(message.message_id)
+
+    @retry_pg
+    def get_result(self, message, *, block=False, timeout=None):
+        key = self.build_message_key(message)
+
+        timeout = 300_000 if timeout is None else timeout
+        deadline = time.monotonic() + timeout / 1000
+        channel = self.queries.channel(key, "results")
+        with transaction(self.pool, listen=channel) as curs:
+            while True:
+                curs.execute(self.queries.GET, (key,))
+                row = curs.fetchone()
+                if row is not None:
+                    if row[1] == "cancelled":
+                        raise ResultCancelled(str(message))
+                    return self.unwrap_result(row[0])
+                if not block:
+                    raise ResultMissing(message)
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise ResultTimeout(message)
+                wait_for_notifies(curs.connection, timeout=remaining)
+
+    @retry_pg
+    def _store(self, key, result, ttl):
+        with transaction(self.pool) as curs:
+            logger.debug("Storing result for %s.", key)
+            curs.execute(
+                self.queries.STORE,
+                (
+                    key,
+                    Jsonb(tidy4json(result)),
+                    f"{ttl} ms",
+                    self.queries.channel(key, "results"),
+                ),
+            )
+            if 0 == curs.rowcount:
+                raise Exception(f"Can't store result of message {key}.")
+
+
+QUERIES = QueryManager(
+    dict(
+        GET=dedent(
+            """\
+    SELECT result, state::text
+        FROM {schema}.{tablename}
+        WHERE message_id = %s AND (state::text = 'cancelled' OR
+          (result IS NOT NULL AND result_ttl > NOW()));
+    """
+        ),
+        STORE=dedent(
+            """\
+    WITH stored AS (
+        INSERT INTO {schema}.{tablename}
+                    (queue_name, message_id, "state", result, result_ttl)
+            VALUES ('__RQ__', %s, 'done',
+                    %s, NOW() + %s::interval)
+        ON CONFLICT (message_id)
+        DO UPDATE SET mtime = NOW(),
+                        result = EXCLUDED.result,
+                        result_ttl = EXCLUDED.result_ttl
+        WHERE {schema}.{tablename}.state <> 'cancelled'
+        RETURNING queue_name, message_id, result
+    )
+    SELECT
+        pg_notify(%s, message_id::text)
+    FROM stored;
+    """
+        ),
+    )
+)

iddqueue/scheduler.py

@@ -0,0 +1,75 @@
+"""Fixed intervals; PostgreSQL owns time and the occurrence commit boundary."""
+from datetime import timezone
+from uuid import uuid4, uuid5
+
+from dramatiq import Message
+from psycopg import sql
+from psycopg.types.json import Jsonb
+
+from .utils import tidy4json, transaction
+
+
+class PostgresScheduler:
+    def __init__(self, broker):
+        self.broker = broker
+        self.table = sql.Identifier(broker.queries.schema, broker.queries.prefix + "schedules")
+
+    def create(self, name, message, *, interval_ms, start_at=None):
+        if not isinstance(name, str) or not name:
+            raise ValueError("schedule name must be nonempty")
+        if type(interval_ms) is not int or not 0 < interval_ms <= 2**63 - 1:
+            raise ValueError("interval_ms must be positive bigint milliseconds")
+        if start_at is not None and (start_at.tzinfo is None or start_at.utcoffset() is None):
+            raise ValueError("start_at must include a timezone")
+        schedule_id = uuid4()
+        with transaction(self.broker.pool) as curs:
+            curs.execute(sql.SQL(
+                "INSERT INTO {} (schedule_id, name, message, interval_ms, next_run) "
+                "VALUES (%s, %s, %s, %s, COALESCE(%s::timestamptz, clock_timestamp()))"
+            ).format(self.table), (schedule_id, name, Jsonb(tidy4json(message)), interval_ms, start_at))
+        return str(schedule_id)
+
+    def list(self):
+        with transaction(self.broker.pool) as curs:
+            curs.execute(sql.SQL(
+                "SELECT schedule_id, name, message->>'actor_name', message->>'queue_name', "
+                "interval_ms, next_run, enabled FROM {} ORDER BY name"
+            ).format(self.table))
+            rows = curs.fetchall()
+        return [dict(schedule_id=str(i), name=n, actor=a, queue=q, interval_ms=interval,
+                     next_run=due.astimezone(timezone.utc).isoformat(), enabled=enabled)
+                for i, n, a, q, interval, due, enabled in rows]
+
+    def disable(self, name):
+        with transaction(self.broker.pool) as curs:
+            curs.execute(sql.SQL("UPDATE {} SET enabled = FALSE WHERE name = %s").format(self.table), (name,))
+            return bool(curs.rowcount)
+
+    def tick(self, *, limit=100):
+        """Publish due rows once, coalescing missed intervals; no automatic retry."""
+        if type(limit) is not int or not 1 <= limit <= 1000:
+            raise ValueError("limit must be between 1 and 1000")
+        published = []
+        with transaction(self.broker.pool) as curs:
+            curs.execute("SELECT clock_timestamp()")
+            now = curs.fetchone()[0]
+            curs.execute(sql.SQL(
+                "SELECT schedule_id, message, next_run FROM {} WHERE enabled AND next_run <= %s "
+                "ORDER BY next_run, schedule_id LIMIT %s FOR UPDATE SKIP LOCKED"
+            ).format(self.table), (now, limit))
+            for schedule_id, payload, due in curs.fetchall():
+                occurrence = due.astimezone(timezone.utc).isoformat()
+                message = Message(**payload).copy(
+                    message_id=str(uuid5(schedule_id, occurrence)), message_timestamp=int(now.timestamp() * 1000))
+                message = self.broker.enqueue_in_transaction(
+                    message, connection=curs.connection,
+                    deduplication_key=f"iddqueue:schedule:{schedule_id}:{occurrence}",
+                    deduplication_ttl=7 * 24 * 60 * 60 * 1000)
+                curs.execute(sql.SQL(
+                    "WITH tick AS (SELECT clock_timestamp() AS now) UPDATE {} "
+                    "SET next_run = next_run + (floor(extract(epoch FROM (tick.now - next_run)) "
+                    "* 1000 / interval_ms) + 1) * interval_ms * interval '1 millisecond' "
+                    "FROM tick WHERE schedule_id = %s"
+                ).format(self.table), (schedule_id,))
+                published.append(message)
+        return published

iddqueue/scheduler.sql

@@ -0,0 +1,9 @@
+CREATE TABLE IF NOT EXISTS :"schema".:"schedules" (
+    schedule_id UUID PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE CHECK (name <> ''),
+    message JSONB NOT NULL,
+    interval_ms BIGINT NOT NULL CHECK (interval_ms > 0),
+    next_run TIMESTAMPTZ NOT NULL,
+    enabled BOOLEAN NOT NULL DEFAULT TRUE
+);
+CREATE INDEX IF NOT EXISTS :"schedules_due" ON :"schema".:"schedules" (next_run) WHERE enabled;

iddqueue/schema.py

@@ -0,0 +1,55 @@
+import os.path
+
+from .utils import quote_ident
+
+
+def process_psql_lines(raw_lines, schema, prefix):
+    schema = quote_ident(schema)
+    tablename = quote_ident(prefix + "queue")
+    statename = quote_ident(prefix + "state")
+
+    for line in raw_lines:
+        if line.startswith("\\"):
+            continue
+        yield (
+            line.replace(':"schema"', schema)
+            .replace(':"state"', statename)
+            .replace(':"queue"', tablename)
+            .replace(':"schedules"', quote_ident(prefix + "schedules"))
+            .replace(':"schedules_due"', quote_ident(prefix + "schedules_due"))
+            .replace(':"attempts"', quote_ident(prefix + "attempts"))
+            .replace(':"attempts_message"', quote_ident(prefix + "attempts_message"))
+            .replace(':"attempts_age"', quote_ident(prefix + "attempts_age"))
+            .replace(':"coordination"', quote_ident(prefix + "coordination"))
+            .replace(':"queue_control"', quote_ident(prefix + "queue_control"))
+            .replace(':"deduplication"', quote_ident(prefix + "deduplication"))
+            .replace(':"deduplication_expiry"', quote_ident(prefix + "deduplication_expiry"))
+        )
+
+
+def generate_init_sql(schema="dramatiq", prefix=""):
+    """Returns SQL for schema initialisation
+
+    Interpolate schema and prefix and return a single SQL string for execution
+    on a PostgreSQL connection.
+    """
+
+    path = os.path.dirname(__file__) + "/schema.sql"
+    with open(path) as fo:
+        return "\n".join(process_psql_lines(fo, schema, prefix)) + "\n" + generate_upgrade_sql(schema, prefix)
+
+
+def generate_coordination_sql(schema="dramatiq", prefix=""):
+    """Idempotent upgrade for existing databases; leaves queue data intact."""
+    path = os.path.join(os.path.dirname(__file__), "coordination.sql")
+    with open(path) as fo:
+        return "\n".join(process_psql_lines(fo, schema, prefix))
+
+
+def generate_upgrade_sql(schema="dramatiq", prefix=""):
+    """Add optional storage without changing existing queue data."""
+    parts = [generate_coordination_sql(schema, prefix)]
+    for name in ("deduplication.sql", "control.sql", "cancellation.sql", "history.sql", "scheduler.sql"):
+        with open(os.path.join(os.path.dirname(__file__), name)) as fo:
+            parts.append("\n".join(process_psql_lines(fo, schema, prefix)))
+    return "\n".join(parts)

iddqueue/schema.sql

@@ -0,0 +1,31 @@
+\set ON_ERROR_STOP on
+\set schema 'dramatiq'
+\set state 'state'
+\set queue 'queue'
+
+CREATE SCHEMA IF NOT EXISTS :"schema";
+
+CREATE TYPE :"schema".:"state" AS ENUM (
+  'queued',
+  'consumed',
+  'rejected',
+  'cancelled',
+  'done'
+);
+
+CREATE TABLE :"schema".:"queue"(
+  message_id uuid PRIMARY KEY,
+  started BOOLEAN NOT NULL DEFAULT FALSE,
+  cancel_requested BOOLEAN NOT NULL DEFAULT FALSE,
+  queue_name TEXT NOT NULL DEFAULT 'default',
+  "state" :"schema".:"state",
+  mtime TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+  -- message as encoded by dramatiq.
+  message JSONB,
+  "result" JSONB,
+  result_ttl  TIMESTAMP WITH TIME ZONE
+);
+
+-- Index state and mtime together to speed up deletion. This can also speed up
+-- statistics when VACUUM ANALYZE is recent enough.
+CREATE INDEX ON :"schema".:"queue"("state", mtime);