@sixb/pg 0.1.13 → 0.1.15

package/src/migrations/051-projection-run-supersession.sql

@@ -0,0 +1,43 @@
+-- Projection runs gain the terminal status `superseded`, and a running run may carry the failure
+-- of its last attempt in `error` while the queue retries it.
+
+-- The status checks were unnamed. Drop exactly the two that enumerate the terminal statuses, then
+-- replace them with named ones that admit `superseded`.
+DO $$
+DECLARE status_constraint RECORD;
+BEGIN
+  FOR status_constraint IN
+    SELECT conname
+    FROM pg_constraint
+    WHERE conrelid = 'projection_runs'::regclass
+      AND contype = 'c'
+      AND pg_get_constraintdef(oid) LIKE '%''cancelled''%'
+  LOOP
+    EXECUTE format('ALTER TABLE projection_runs DROP CONSTRAINT %I', status_constraint.conname);
+  END LOOP;
+END $$;
+
+ALTER TABLE projection_runs
+  ADD CONSTRAINT projection_runs_status_check CHECK (
+    status IN ('queued', 'running', 'succeeded', 'failed', 'cancelled', 'superseded')
+  ),
+  ADD CONSTRAINT projection_runs_lifecycle_check CHECK (
+    (status = 'queued' AND attempt = 0 AND started_at IS NULL AND finished_at IS NULL
+      AND error IS NULL)
+    OR (status = 'running' AND attempt >= 1 AND started_at IS NOT NULL AND finished_at IS NULL)
+    OR (
+      status IN ('succeeded', 'failed', 'cancelled', 'superseded')
+      AND finished_at IS NOT NULL
+      AND (
+        (error->>'code' = 'queue.enqueue_failed'
+          AND status = 'failed' AND attempt = 0 AND started_at IS NULL)
+        OR (COALESCE(error->>'code', '') != 'queue.enqueue_failed'
+          AND attempt >= 1 AND started_at IS NOT NULL)
+      )
+    )
+  ),
+  -- A run is superseded instead of materialized, so it carries no failure, and only replacement
+  -- runs can be: telemetry appends readings rather than replace a source.
+  ADD CONSTRAINT projection_runs_superseded_check CHECK (
+    status != 'superseded' OR (error IS NULL AND materialization_protocol = 'replacement')
+  );

package/src/migrations/052-compact-source-storage.sql

@@ -0,0 +1,118 @@
+-- Source versions get a compact surrogate key; roots and rows stop repeating the text triple.
+ALTER TABLE ontology_sources ADD COLUMN version_id BIGINT GENERATED ALWAYS AS IDENTITY;
+ALTER TABLE ontology_sources ADD CONSTRAINT ontology_sources_version_id_key UNIQUE (version_id);
+
+ALTER TABLE ontology_source_rows RENAME TO legacy_ontology_source_rows;
+ALTER TABLE ontology_source_roots RENAME TO legacy_ontology_source_roots;
+-- Index names are schema-wide: free them for the new tables.
+DO $$
+DECLARE
+  legacy record;
+BEGIN
+  FOR legacy IN
+    SELECT index_class.relname AS name
+    FROM pg_index
+    JOIN pg_class AS index_class ON index_class.oid = pg_index.indexrelid
+    JOIN pg_class AS table_class ON table_class.oid = pg_index.indrelid
+    WHERE table_class.relnamespace = current_schema()::regnamespace
+      AND table_class.relname IN ('legacy_ontology_source_rows', 'legacy_ontology_source_roots')
+  LOOP
+    EXECUTE format('ALTER INDEX %I RENAME TO %I', legacy.name, left('legacy_' || legacy.name, 63));
+  END LOOP;
+END $$;
+
+-- A root is live while its version is published (active or superseded), it is not retired and
+-- it is not a deletion. Activation therefore writes only the roots it replaces, never its own.
+-- `root_key` is the canonical key; "C" orders it by its UTF-8 bytes.
+CREATE TABLE ontology_source_roots (
+  id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  version_id BIGINT NOT NULL REFERENCES ontology_sources (version_id) ON DELETE RESTRICT,
+  project_id TEXT NOT NULL,
+  root_key TEXT COLLATE "C" NOT NULL,
+  staging_ordinal BIGINT NOT NULL CHECK (staging_ordinal >= 0),
+  deleted BOOLEAN NOT NULL DEFAULT FALSE,
+  retired_at TIMESTAMPTZ,
+  CONSTRAINT ontology_source_roots_key UNIQUE (version_id, root_key),
+  CONSTRAINT ontology_source_roots_ordinal UNIQUE (version_id, staging_ordinal)
+);
+CREATE INDEX idx_ontology_source_roots_live
+  ON ontology_source_roots (project_id, root_key) WHERE retired_at IS NULL AND NOT deleted;
+CREATE INDEX idx_ontology_source_roots_retired
+  ON ontology_source_roots (project_id, retired_at) WHERE retired_at IS NOT NULL;
+
+-- A row's identity lives in its typed columns; `payload` is the assertion without kind and ref.
+CREATE TABLE ontology_source_rows (
+  root_id BIGINT NOT NULL REFERENCES ontology_source_roots (id) ON DELETE RESTRICT,
+  entity_kind TEXT NOT NULL CHECK (entity_kind IN ('object', 'link')),
+  object_type_id TEXT,
+  primary_id TEXT,
+  source_type_id TEXT,
+  source_primary_id TEXT,
+  link_id TEXT,
+  target_type_id TEXT,
+  target_primary_id TEXT,
+  payload JSONB,
+  CHECK (
+    (
+      entity_kind = 'object'
+      AND object_type_id IS NOT NULL AND primary_id IS NOT NULL
+      AND source_type_id IS NULL AND source_primary_id IS NULL AND link_id IS NULL
+      AND target_type_id IS NULL AND target_primary_id IS NULL
+    )
+    OR
+    (
+      entity_kind = 'link'
+      AND object_type_id IS NULL AND primary_id IS NULL
+      AND source_type_id IS NOT NULL AND source_primary_id IS NOT NULL AND link_id IS NOT NULL
+      AND target_type_id IS NOT NULL AND target_primary_id IS NOT NULL
+    )
+  )
+);
+CREATE INDEX idx_ontology_source_rows_root ON ontology_source_rows (root_id);
+CREATE INDEX idx_ontology_source_rows_link_source
+  ON ontology_source_rows (source_type_id, source_primary_id, link_id)
+  WHERE entity_kind = 'link';
+CREATE INDEX idx_ontology_source_rows_link_target
+  ON ontology_source_rows (target_type_id, target_primary_id)
+  WHERE entity_kind = 'link';
+
+-- A published root that was not active is retired, so liveness stays exactly what it was.
+INSERT INTO ontology_source_roots (
+  version_id, project_id, root_key, staging_ordinal, deleted, retired_at
+)
+SELECT versions.version_id, roots.project_id,
+  convert_from(decode(roots.root_sort_key, 'hex'), 'UTF8'), roots.staging_ordinal, roots.deleted,
+  CASE
+    WHEN roots.active THEN NULL
+    WHEN roots.retired_at IS NOT NULL THEN roots.retired_at
+    WHEN versions.status IN ('active', 'superseded') THEN versions.updated_at
+  END
+FROM legacy_ontology_source_roots AS roots
+JOIN ontology_sources AS versions USING (project_id, source_id, materialization_id);
+
+INSERT INTO ontology_source_rows (
+  root_id, entity_kind, object_type_id, primary_id,
+  source_type_id, source_primary_id, link_id, target_type_id, target_primary_id, payload
+)
+SELECT roots.id, rows.entity_kind, rows.object_type_id, rows.primary_id,
+  rows.source_type_id, rows.source_primary_id, rows.link_id, rows.target_type_id,
+  rows.target_primary_id, NULLIF(rows.assertion - 'kind' - 'ref', '{}'::jsonb)
+FROM legacy_ontology_source_rows AS rows
+JOIN ontology_sources AS versions USING (project_id, source_id, materialization_id)
+JOIN ontology_source_roots AS roots
+  ON roots.version_id = versions.version_id
+  AND roots.root_key = convert_from(decode(rows.root_sort_key, 'hex'), 'UTF8');
+
+DO $$
+BEGIN
+  IF (SELECT count(*) FROM legacy_ontology_source_roots)
+      <> (SELECT count(*) FROM ontology_source_roots)
+    OR (SELECT count(*) FROM legacy_ontology_source_rows)
+      <> (SELECT count(*) FROM ontology_source_rows) THEN
+    RAISE EXCEPTION 'Source roots or rows were lost while compacting source storage.';
+  END IF;
+END $$;
+
+DROP TABLE legacy_ontology_source_rows;
+DROP TABLE legacy_ontology_source_roots;
+ANALYZE ontology_sources, ontology_source_roots, ontology_source_rows;

package/src/migrations.ts

@@ -106,7 +106,17 @@ import ontologyCommitAttributionSql from "./migrations/047-ontology-commit-attri
   type: "text",
 }
 import nativeSessionsSql from "./migrations/049-native-sessions.sql" with { type: "text" }
-import type { SQL, SQLClient } from "./pg-client"
+import directoryGroupMembershipsSql from "./migrations/050-directory-group-memberships.sql" with {
+  type: "text",
+}
+import projectionRunSupersessionSql from "./migrations/051-projection-run-supersession.sql" with {
+  type: "text",
+}
+import compactSourceStorageSql from "./migrations/052-compact-source-storage.sql" with {
+  type: "text",
+}
+import type { ReservedSQL, SQL, SQLClient } from "./pg-client"
+import { runPgTransactionOn, undoOnFailure, withReservedPgConnection } from "./transactions"
 
 export interface PostgresMigrationContext {
   exec(sqlText: string): Promise<void>
@@ -186,7 +196,7 @@ export function quoteIdent(identifier: string): string {
 }
 
 function postgresMigrationSession(
-  sql: SQL,
+  sql: ReservedSQL,
   schemaName: string
 ): { context: PostgresMigrationContext; state: MigrationHistoryStore } {
   const schema = quoteIdent(schemaName)
@@ -253,19 +263,15 @@ function postgresMigrationSession(
       },
       async transaction(run) {
         // `sql` is the reserved connection holding the migration advisory lock. porsager's
-        // reserved connection has no `.begin`, so drive the transaction manually on it and
-        // route exec()/markStarted()/markApplied() through the same connection via `active`.
+        // `.begin` would open the transaction on another pool connection, so drive it on this one
+        // and route exec()/markStarted()/markApplied() through it via `active`.
         const previous = active
         active = sql
-        await sql.unsafe("BEGIN")
         try {
-          await sql.unsafe(`SET LOCAL search_path TO ${schema}`)
-          const result = await run()
-          await sql.unsafe("COMMIT")
-          return result
-        } catch (error) {
-          await sql.unsafe("ROLLBACK")
-          throw error
+          return await runPgTransactionOn(sql, async () => {
+            await sql.unsafe(`SET LOCAL search_path TO ${schema}`)
+            return run()
+          })
         } finally {
           active = previous
         }
@@ -312,23 +318,21 @@ async function withPostgresMigrationLock<T>(
     readonly schemaName: string
     readonly migrations: MigrationSet<PostgresMigrationContext>
   },
-  run: (sql: SQL) => Promise<T>
+  run: (sql: ReservedSQL) => Promise<T>
 ): Promise<T> {
-  const sql = await params.sql.reserve()
   const [first, second] = advisoryLockParts(
     `storage:migration:${params.schemaName}:${params.migrations.adapterId}`
   )
 
-  try {
+  // A session-level lock outlives any transaction, so it is released before the connection goes
+  // back to the pool — except when the connection was lost, which already released it.
+  return withReservedPgConnection(params.sql, async (sql) => {
+    const unlock = () => sql`SELECT pg_advisory_unlock(${first}, ${second})`
     await sql`SELECT pg_advisory_lock(${first}, ${second})`
-    try {
-      return await run(sql)
-    } finally {
-      await sql`SELECT pg_advisory_unlock(${first}, ${second})`
-    }
-  } finally {
-    sql.release()
-  }
+    const result = await undoOnFailure(() => run(sql), unlock)
+    await unlock()
+    return result
+  })
 }
 
 function advisoryLockParts(key: string): readonly [number, number] {
@@ -408,6 +412,9 @@ export const postgresStorageMigrations = defineMigrations<PostgresMigrationConte
     pgSql("047-ontology-commit-attribution", ontologyCommitAttributionSql),
     pgSql("048-file-upload-sessions", fileUploadSessionsSql),
     pgSql("049-native-sessions", nativeSessionsSql),
+    pgSql("050-directory-group-memberships", directoryGroupMembershipsSql),
+    pgSql("051-projection-run-supersession", projectionRunSupersessionSql),
+    pgSql("052-compact-source-storage", compactSourceStorageSql),
   ],
 })
 

package/src/ontology-storage/materialization-state.ts

@@ -38,15 +38,21 @@ import type {
 } from "@sixb/core/storage"
 import type { SQLClient } from "../pg-client"
 import {
-  databaseSafeInteger,
   jsonParameter,
   linkRefFromColumns,
   objectRefFromColumns,
   type PgOntologySourceAssertionRow,
   type PgStoredOverrideRow,
+  sourceAssertion,
   toIsoString,
 } from "./shared"
-import { activeSourceRows, replacementAssertionRows, replacementSourceRows } from "./source-roots"
+import {
+  activeSourceRows,
+  liveSourceRowsJoin,
+  replacementAssertionRows,
+  replacementSourceRows,
+  sourceAssertionColumns,
+} from "./source-roots"
 
 export const PG_MATERIALIZATION_WORK_TABLE = "ontology_materialization_work"
 export const PG_REPLACEMENT_WORK_TABLE = "ontology_replacement_work"
@@ -410,20 +416,14 @@ export class PgMaterializationStateReader {
               scope_sort_key TEXT, source_type_id TEXT, source_id TEXT, link_id TEXT
             )
         )
-        SELECT rows.*
+        SELECT ${sourceAssertionColumns(this.sql)}
         FROM ontology_source_rows AS rows
         JOIN requested
           ON requested.source_type_id = rows.source_type_id
          AND requested.source_id = rows.source_primary_id
          AND requested.link_id = rows.link_id
-        JOIN ontology_source_roots AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-         AND sources.root_sort_key = rows.root_sort_key
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'link'
-          AND sources.active
+        ${liveSourceRowsJoin(this.sql, this.projectId)}
+        WHERE rows.entity_kind = 'link'
       `,
       this.sql<LinkSlotOverrideRow[]>`
         WITH requested AS (
@@ -582,32 +582,20 @@ export class PgMaterializationStateReader {
           SELECT rows.source_type_id, rows.source_primary_id AS source_id,
             rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
           FROM ontology_source_rows AS rows
-          JOIN ontology_source_roots AS sources
-            ON sources.project_id = rows.project_id
-           AND sources.source_id = rows.source_id
-           AND sources.materialization_id = rows.materialization_id
-         AND sources.root_sort_key = rows.root_sort_key
+          ${liveSourceRowsJoin(this.sql, this.projectId)}
           JOIN requested
             ON requested.object_type_id = rows.source_type_id
            AND requested.primary_id = rows.source_primary_id
-          WHERE rows.project_id = ${this.projectId}
-            AND rows.entity_kind = 'link'
-            AND sources.active
+          WHERE rows.entity_kind = 'link'
           UNION
           SELECT rows.source_type_id, rows.source_primary_id AS source_id,
             rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
           FROM ontology_source_rows AS rows
-          JOIN ontology_source_roots AS sources
-            ON sources.project_id = rows.project_id
-           AND sources.source_id = rows.source_id
-           AND sources.materialization_id = rows.materialization_id
-         AND sources.root_sort_key = rows.root_sort_key
+          ${liveSourceRowsJoin(this.sql, this.projectId)}
           JOIN requested
             ON requested.object_type_id = rows.target_type_id
            AND requested.primary_id = rows.target_primary_id
-          WHERE rows.project_id = ${this.projectId}
-            AND rows.entity_kind = 'link'
-            AND sources.active
+          WHERE rows.entity_kind = 'link'
         ), selected AS (
           SELECT DISTINCT links.*,
             ${this.sql.unsafe(linkSortExpression("links"))} AS sort_key
@@ -912,32 +900,20 @@ export class PgMaterializationStateReader {
         SELECT rows.source_type_id, rows.source_primary_id AS source_id,
           rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
         FROM ontology_source_rows AS rows
-        JOIN ontology_source_roots AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-         AND sources.root_sort_key = rows.root_sort_key
+        ${liveSourceRowsJoin(this.sql, this.projectId)}
         JOIN incident_objects
           ON incident_objects.object_type_id = rows.source_type_id
          AND incident_objects.primary_id = rows.source_primary_id
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'link'
-          AND sources.active
+        WHERE rows.entity_kind = 'link'
         UNION
         SELECT rows.source_type_id, rows.source_primary_id AS source_id,
           rows.link_id, rows.target_type_id, rows.target_primary_id AS target_id
         FROM ontology_source_rows AS rows
-        JOIN ontology_source_roots AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-         AND sources.root_sort_key = rows.root_sort_key
+        ${liveSourceRowsJoin(this.sql, this.projectId)}
         JOIN incident_objects
           ON incident_objects.object_type_id = rows.target_type_id
          AND incident_objects.primary_id = rows.target_primary_id
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'link'
-          AND sources.active
+        WHERE rows.entity_kind = 'link'
       ), diff_links AS (
         SELECT * FROM replacement_links
         UNION SELECT * FROM incident_links
@@ -1104,9 +1080,7 @@ function storedSource(row: PgOntologySourceAssertionRow): StoredSourceAssertion
   return {
     source: { projectionId: row.source_id },
     materializationId: row.materialization_id,
-    root: structuredClone(row.root) as StoredSourceAssertion["root"],
-    assertion: structuredClone(row.assertion) as StoredSourceAssertion["assertion"],
-    stagingOrdinal: databaseSafeInteger(row.staging_ordinal, "Source staging ordinal"),
+    ...sourceAssertion(row),
   } as StoredSourceAssertion
 }
 

package/src/ontology-storage/shared.ts

@@ -1,6 +1,9 @@
 import { parseSixbFailure } from "@sixb/core/internal/errors"
-import type { ProjectionEntityRef } from "@sixb/core/internal/materialization"
 import { MaterializationConflictError } from "@sixb/core/internal/materialization"
+import {
+  sourceAssertionFromColumns,
+  sourceEntityFromKey,
+} from "@sixb/core/internal/ontology-storage-provider"
 import type {
   AssertSourceMaterializationExecutionInput,
   OntologyCommitRecord,
@@ -50,6 +53,7 @@ export interface PgOntologyCommitRow {
 }
 
 export interface PgOntologySourceRow {
+  readonly version_id: string
   readonly project_id: string
   readonly source_id: string
   readonly materialization_id: string
@@ -76,19 +80,21 @@ export interface PgOntologySourceRow {
   readonly updated_at: Date | string
 }
 
+/** An assertion with its root and version, as `sourceAssertionColumns` selects it. */
 export interface PgOntologySourceAssertionRow {
-  readonly project_id: string
   readonly source_id: string
   readonly materialization_id: string
-  readonly entity_kind: "object" | "link"
-  readonly entity_key: unknown
-  readonly entity_sort_key: string
-  readonly root_kind: "object" | "link"
-  readonly root_key: unknown
-  readonly root_sort_key: string
+  readonly root_key: string
   readonly staging_ordinal: number | string
-  readonly root: unknown
-  readonly assertion: unknown
+  readonly entity_kind: "object" | "link"
+  readonly object_type_id: string | null
+  readonly primary_id: string | null
+  readonly source_type_id: string | null
+  readonly source_primary_id: string | null
+  readonly link_id: string | null
+  readonly target_type_id: string | null
+  readonly target_primary_id: string | null
+  readonly payload: unknown
 }
 
 export interface PgStoredOverrideRow {
@@ -174,8 +180,8 @@ export function sourceRecord(row: PgOntologySourceRow): OntologySourceRecord {
 
 export function sourceAssertion(row: PgOntologySourceAssertionRow): StageSourceAssertion {
   return {
-    root: structuredClone(row.root) as ProjectionEntityRef,
-    assertion: structuredClone(row.assertion) as StageSourceAssertion["assertion"],
+    root: sourceEntityFromKey(row.root_key),
+    assertion: sourceAssertionFromColumns(row, row.payload),
     stagingOrdinal: databaseSafeInteger(row.staging_ordinal, "Source staging ordinal"),
   }
 }

package/src/ontology-storage/source-cleanup.ts

@@ -1,24 +1,74 @@
 import type {
   CleanupTerminalSourceMaterializationsInput,
   CleanupTerminalSourceMaterializationsResult,
+  PurgeAbandonedSourceMaterializationsInput,
 } from "@sixb/core/storage"
 import type { SQLClient } from "../pg-client"
 
+/**
+ * Superseded versions can still hold live roots (a delta keeps unchanged roots where they were),
+ * so they are cleaned root by root once retired. An abandoned candidate was never published:
+ * everything it holds goes, one whole version at a time, each delete on its own version prefix.
+ */
+export async function purgeAbandonedSourceVersions(
+  sql: SQLClient,
+  input: PurgeAbandonedSourceMaterializationsInput
+): Promise<CleanupTerminalSourceMaterializationsResult> {
+  let remaining = input.limit
+  let rowsDeleted = 0
+  let materializationsDeleted = 0
+  while (remaining > 0) {
+    const [candidate] = await sql<{ readonly version_id: string }[]>`
+      SELECT version_id FROM ontology_sources
+      WHERE project_id = ${input.projectId} AND status = 'abandoned'
+      ORDER BY terminal_at, source_id, materialization_id
+      LIMIT 1 FOR UPDATE SKIP LOCKED
+    `
+    if (!candidate) break
+    const rows = await sql`
+      DELETE FROM ontology_source_rows WHERE ctid IN (
+        SELECT rows.ctid FROM ontology_source_roots AS roots
+        JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+        WHERE roots.version_id = ${candidate.version_id} LIMIT ${remaining}
+      )
+    `
+    rowsDeleted += rows.count
+    remaining -= rows.count
+    if (remaining === 0) break
+    const roots = await sql`
+      DELETE FROM ontology_source_roots WHERE ctid IN (
+        SELECT ctid FROM ontology_source_roots
+        WHERE version_id = ${candidate.version_id} LIMIT ${remaining}
+      )
+    `
+    rowsDeleted += roots.count
+    remaining -= roots.count
+    if (remaining === 0) break
+    const manifest = await sql`
+      DELETE FROM ontology_sources
+      WHERE version_id = ${candidate.version_id} AND status = 'abandoned'
+    `
+    if (manifest.count === 0) break
+    materializationsDeleted += manifest.count
+    remaining -= manifest.count
+  }
+  return { rowsDeleted, materializationsDeleted }
+}
+
 export async function cleanupSourceVersions(
   sql: SQLClient,
   input: CleanupTerminalSourceMaterializationsInput
 ): Promise<CleanupTerminalSourceMaterializationsResult> {
   let remaining = input.limit
+  const retired = sql`roots.project_id = ${input.projectId}
+    AND roots.retired_at < ${input.terminalBefore} AND versions.status = 'superseded'`
   const removedRows = await sql`
     WITH selected AS (
       SELECT rows.ctid FROM ontology_source_roots AS roots
-      JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
-      JOIN ontology_source_rows AS rows
-        ON rows.project_id = roots.project_id AND rows.source_id = roots.source_id
-        AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key
-      WHERE roots.project_id = ${input.projectId} AND NOT roots.active AND roots.retired_at < ${input.terminalBefore}
-        AND sources.status IN ('superseded', 'abandoned')
-      ORDER BY roots.retired_at, roots.source_id, roots.materialization_id, roots.root_sort_key, rows.entity_sort_key
+      JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+      JOIN ontology_source_rows AS rows ON rows.root_id = roots.id
+      WHERE ${retired}
+      ORDER BY roots.retired_at, roots.id
       LIMIT ${remaining} FOR UPDATE OF rows SKIP LOCKED
     ) DELETE FROM ontology_source_rows AS rows USING selected WHERE rows.ctid = selected.ctid RETURNING 1
   `
@@ -28,13 +78,10 @@ export async function cleanupSourceVersions(
     const removed = await sql`
       WITH selected AS (
         SELECT roots.ctid FROM ontology_source_roots AS roots
-        JOIN ontology_sources AS sources USING (project_id, source_id, materialization_id)
-        WHERE roots.project_id = ${input.projectId} AND NOT roots.active AND roots.retired_at < ${input.terminalBefore}
-          AND sources.status IN ('superseded', 'abandoned')
-          AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
-            WHERE rows.project_id = roots.project_id AND rows.source_id = roots.source_id
-              AND rows.materialization_id = roots.materialization_id AND rows.root_sort_key = roots.root_sort_key)
-        ORDER BY roots.retired_at, roots.source_id, roots.materialization_id, roots.root_sort_key
+        JOIN ontology_sources AS versions ON versions.version_id = roots.version_id
+        WHERE ${retired}
+          AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows WHERE rows.root_id = roots.id)
+        ORDER BY roots.retired_at, roots.id
         LIMIT ${remaining} FOR UPDATE OF roots SKIP LOCKED
       ) DELETE FROM ontology_source_roots AS roots USING selected WHERE roots.ctid = selected.ctid RETURNING 1
     `
@@ -46,16 +93,13 @@ export async function cleanupSourceVersions(
       ? []
       : await sql`
     WITH selected AS (
-      SELECT sources.ctid FROM ontology_sources AS sources
-      WHERE project_id = ${input.projectId} AND status IN ('superseded', 'abandoned') AND terminal_at < ${input.terminalBefore}
+      SELECT versions.ctid FROM ontology_sources AS versions
+      WHERE project_id = ${input.projectId} AND status = 'superseded'
+        AND terminal_at < ${input.terminalBefore}
         AND NOT EXISTS (SELECT 1 FROM ontology_source_roots AS roots
-          WHERE roots.project_id = sources.project_id AND roots.source_id = sources.source_id
-            AND roots.materialization_id = sources.materialization_id)
-        AND NOT EXISTS (SELECT 1 FROM ontology_source_rows AS rows
-          WHERE rows.project_id = sources.project_id AND rows.source_id = sources.source_id
-            AND rows.materialization_id = sources.materialization_id)
+          WHERE roots.version_id = versions.version_id)
       ORDER BY terminal_at, source_id, materialization_id LIMIT ${remaining} FOR UPDATE SKIP LOCKED
-    ) DELETE FROM ontology_sources AS sources USING selected WHERE sources.ctid = selected.ctid RETURNING 1
+    ) DELETE FROM ontology_sources AS versions USING selected WHERE versions.ctid = selected.ctid RETURNING 1
   `
   return { rowsDeleted, materializationsDeleted: removedManifests.length }
 }