@sixb/pg 0.1.9 → 0.1.10

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

@@ -46,6 +46,7 @@ import {
   type PgStoredOverrideRow,
   toIsoString,
 } from "./shared"
+import { activeSourceRows, replacementAssertionRows, replacementSourceRows } from "./source-roots"
 
 export const PG_MATERIALIZATION_WORK_TABLE = "ontology_materialization_work"
 export const PG_REPLACEMENT_WORK_TABLE = "ontology_replacement_work"
@@ -141,6 +142,7 @@ interface ReplacementSources {
 }
 
 interface ReplacementIdentityInput {
+  readonly incremental?: boolean
   readonly sessionId: string
   readonly sourceId: string
   readonly candidateMaterializationId: string
@@ -186,22 +188,11 @@ export class PgMaterializationStateReader {
         JOIN requested USING (object_type_id, primary_id)
         WHERE objects.project_id = ${this.projectId}
       `,
-      this.sql<PgOntologySourceAssertionRow[]>`
-        WITH requested AS (
-          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
-            AS requested_values(object_type_id TEXT, primary_id TEXT)
-        )
-        SELECT rows.*
-        FROM ontology_source_rows AS rows
-        JOIN requested USING (object_type_id, primary_id)
-        JOIN ontology_sources AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'object'
-          AND sources.status = 'active'
-      `,
+      activeSourceRows(
+        this.sql,
+        this.projectId,
+        refs.map((ref) => ({ kind: "object", ref }))
+      ),
       this.sql<ObjectOverrideRow[]>`
         WITH requested AS (
           SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter})
@@ -291,26 +282,11 @@ export class PgMaterializationStateReader {
         JOIN requested USING (source_type_id, source_id, link_id, target_type_id, target_id)
         WHERE links.project_id = ${this.projectId}
       `,
-      this.sql<PgOntologySourceAssertionRow[]>`
-        WITH requested AS (
-          SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter}) AS requested_values(
-            source_type_id TEXT, source_primary_id TEXT, link_id TEXT,
-            target_type_id TEXT, target_primary_id TEXT
-          )
-        )
-        SELECT rows.*
-        FROM ontology_source_rows AS rows
-        JOIN requested USING (
-          source_type_id, source_primary_id, link_id, target_type_id, target_primary_id
-        )
-        JOIN ontology_sources AS sources
-          ON sources.project_id = rows.project_id
-         AND sources.source_id = rows.source_id
-         AND sources.materialization_id = rows.materialization_id
-        WHERE rows.project_id = ${this.projectId}
-          AND rows.entity_kind = 'link'
-          AND sources.status = 'active'
-      `,
+      activeSourceRows(
+        this.sql,
+        this.projectId,
+        refs.map((ref) => ({ kind: "link", ref }))
+      ),
       this.sql<LinkOverrideRow[]>`
         WITH requested AS (
           SELECT DISTINCT * FROM jsonb_to_recordset(${requestedParameter}) AS requested_values(
@@ -440,13 +416,14 @@ export class PgMaterializationStateReader {
           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_sources AS sources
+        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.status = 'active'
+          AND sources.active
       `,
       this.sql<LinkSlotOverrideRow[]>`
         WITH requested AS (
@@ -605,30 +582,32 @@ 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_sources AS sources
+          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
           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.status = 'active'
+            AND sources.active
           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_sources AS sources
+          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
           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.status = 'active'
+            AND sources.active
         ), selected AS (
           SELECT DISTINCT links.*,
             ${this.sql.unsafe(linkSortExpression("links"))} AS sort_key
@@ -649,13 +628,19 @@ export class PgMaterializationStateReader {
     input: ReplacementIdentityInput
   ): AsyncIterable<ReplacementIdentity[]> {
     await this.prepareReplacementIdentities(input)
+    // Temporary tables are not auto-analyzed. Refresh after each identity population is
+    // prepared so the planner can choose the ordered index for its bounded pages.
+    await this.sql`ANALYZE ${this.sql(PG_REPLACEMENT_WORK_TABLE)}`
     let cursor: string | null = null
     while (true) {
+      // Keep the next-page bound indexable in generic prepared plans. A nullable OR
+      // makes PostgreSQL revisit the preceding pages before applying the cursor filter.
+      const after = cursor === null ? this.sql`` : this.sql`AND sort_key > ${cursor}`
       const rows: ReplacementWorkRow[] = await this.sql<ReplacementWorkRow[]>`
         SELECT entity_kind, identity_key, sort_key, diff_required
         FROM ${this.sql(PG_REPLACEMENT_WORK_TABLE)}
         WHERE session_id = ${input.sessionId} AND entity_kind = ${input.kind}
-          AND (${cursor}::text IS NULL OR sort_key > ${cursor})
+          ${after}
         ORDER BY sort_key
         LIMIT ${input.pageRows}
       `
@@ -693,14 +678,16 @@ export class PgMaterializationStateReader {
     sourceId: string,
     candidateMaterializationId: string,
     materializationIds: readonly string[],
-    identities: readonly Extract<ReplacementIdentity, { readonly kind: "link" }>[]
+    identities: readonly Extract<ReplacementIdentity, { readonly kind: "link" }>[],
+    incremental = false
   ): Promise<readonly SourceReplacementLinkState[]> {
     const refs = identities.map((identity) => identity.ref)
     const base = await this.linkStates(refs)
     const replacements = await this.replacementSources(
       sourceId,
       materializationIds,
-      refs.map((ref) => ({ kind: "link" as const, ref }))
+      refs.map((ref) => ({ kind: "link" as const, ref })),
+      incremental
     )
     const candidate = replacements.byMaterialization.get(candidateMaterializationId)
     return base.map((state, index) => {
@@ -807,29 +794,20 @@ export class PgMaterializationStateReader {
   private async replacementSources(
     sourceId: string,
     materializationIds: readonly string[],
-    refs: readonly ProjectionEntityRef[]
+    refs: readonly ProjectionEntityRef[],
+    incremental = false
   ): Promise<ReplacementSources> {
     if (materializationIds.length === 0 || refs.length === 0) {
       return { owned: new Set(), byMaterialization: new Map() }
     }
-    const keys = refs.map((ref) => ({
-      entity_kind: ref.kind,
-      entity_key: JSON.parse(projectionEntityKey(ref)) as unknown,
-    }))
-    const rows = await this.sql<PgOntologySourceAssertionRow[]>`
-      WITH requested AS (
-        SELECT *
-        FROM jsonb_to_recordset(${jsonParameter(this.sql, keys)})
-          AS requested_values(entity_kind TEXT, entity_key JSONB)
-      )
-      SELECT rows.* FROM ontology_source_rows AS rows
-      JOIN requested USING (entity_kind, entity_key)
-      WHERE rows.project_id = ${this.projectId}
-        AND rows.source_id = ${sourceId}
-        AND rows.materialization_id = ANY(
-          ${this.sql.array([...new Set(materializationIds)])}::text[]
-        )
-    `
+    const rows = await replacementAssertionRows(this.sql, {
+      projectId: this.projectId,
+      sourceId,
+      materializationId: materializationIds[0]!,
+      incremental,
+      includePrevious: materializationIds.length > 1,
+      refs,
+    })
     const owned = new Set<string>()
     const byMaterialization = new Map<string, Map<string, StoredSourceAssertion>>()
     for (const row of rows) {
@@ -852,20 +830,19 @@ export class PgMaterializationStateReader {
   }
 
   private async prepareReplacementObjects(input: ReplacementIdentityInput): Promise<void> {
-    const materializationIds = [
-      input.candidateMaterializationId,
-      ...(input.previousMaterializationId ? [input.previousMaterializationId] : []),
-    ]
+    const rows = replacementSourceRows(this.sql, {
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false,
+    })
     await this.sql`
       WITH selected AS (
         SELECT DISTINCT object_type_id, primary_id,
           ${this.sql.unsafe(objectKeyExpression("rows"))} AS identity_key,
           ${this.sql.unsafe(objectSortExpression("rows"))} AS sort_key
-        FROM ontology_source_rows AS rows
-        WHERE project_id = ${this.projectId}
-          AND source_id = ${input.sourceId}
-          AND entity_kind = 'object'
-          AND materialization_id = ANY(${this.sql.array(materializationIds)}::text[])
+        FROM (${rows}) AS rows
+        WHERE entity_kind = 'object'
       )
       INSERT INTO ${this.sql(PG_REPLACEMENT_WORK_TABLE)} (
         session_id, entity_kind, identity_key, sort_key, diff_required
@@ -879,10 +856,13 @@ export class PgMaterializationStateReader {
   }
 
   private async prepareReplacementLinks(input: ReplacementIdentityInput): Promise<void> {
-    const materializationIds = [
-      input.candidateMaterializationId,
-      ...(input.previousMaterializationId ? [input.previousMaterializationId] : []),
-    ]
+    await this.sql`ANALYZE ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}`
+    const rows = replacementSourceRows(this.sql, {
+      projectId: this.projectId,
+      sourceId: input.sourceId,
+      materializationId: input.candidateMaterializationId,
+      incremental: input.incremental ?? false,
+    })
     await this.sql`
       WITH incident_objects AS (
         SELECT DISTINCT payload->'ref'->>'objectTypeId' AS object_type_id,
@@ -892,11 +872,8 @@ export class PgMaterializationStateReader {
       ), replacement_links AS (
         SELECT source_type_id, source_primary_id AS source_id, link_id,
           target_type_id, target_primary_id AS target_id
-        FROM ontology_source_rows
-        WHERE project_id = ${this.projectId}
-          AND source_id = ${input.sourceId}
-          AND entity_kind = 'link'
-          AND materialization_id = ANY(${this.sql.array(materializationIds)}::text[])
+        FROM (${rows}) AS rows
+        WHERE entity_kind = 'link'
       ), incident_links AS (
         SELECT links.source_type_id, links.source_id, links.link_id,
           links.target_type_id, links.target_id
@@ -935,30 +912,32 @@ 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_sources AS sources
+        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
         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.status = 'active'
+          AND sources.active
         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_sources AS sources
+        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
         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.status = 'active'
+          AND sources.active
       ), diff_links AS (
         SELECT * FROM replacement_links
         UNION SELECT * FROM incident_links

package/src/ontology-storage/materializations.ts

@@ -68,6 +68,7 @@ import {
   type PgOntologySourceRow,
   toIsoString,
 } from "./shared"
+import { activateSourceRoots } from "./source-roots"
 
 interface ProjectionCountsRow {
   readonly object_classifications: number | string
@@ -235,6 +236,7 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
         sourceId: replacement.sourceId,
         candidateMaterializationId: replacement.candidateMaterializationId,
         previousMaterializationId: replacement.previousMaterializationId,
+        incremental: replacement.incremental,
         kind: "object",
         pageRows: input.pageRows,
       })) {
@@ -279,6 +281,7 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
       sourceId: replacement.sourceId,
       candidateMaterializationId: replacement.candidateMaterializationId,
       previousMaterializationId: replacement.previousMaterializationId,
+      incremental: replacement.incremental,
       kind: "link",
       pageRows: input.pageRows,
     })) {
@@ -293,7 +296,8 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
         replacement.sourceId,
         replacement.candidateMaterializationId,
         materializationIds,
-        linkIdentities
+        linkIdentities,
+        replacement.incremental
       )
       yield { objects: [], links }
     }
@@ -323,6 +327,10 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     assertPlanChunkCorrelations(input.chunk, commit)
     const progress = await this.sessions.prepareChunkSequence(session, input.chunk)
     await this.writer.apply(commit.projectId, commit.id, input.chunk)
+    session.changedObjects +=
+      input.chunk.effective.objectUpserts.length + input.chunk.effective.objectDeletes.length
+    session.changedLinks +=
+      input.chunk.effective.linkUpserts.length + input.chunk.effective.linkDeletes.length
     this.sessions.commitChunkSequence(session, progress)
   }
 
@@ -333,6 +341,10 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     for (const activation of input.finalization.sourceActivations) {
       await this.activateSource(session, activation)
     }
+    // The next sparse projection must see the distribution of a newly published bulk load.
+    // With empty/stale statistics, a link lookup can scan every edge sharing its target.
+    if (session.changedObjects >= 1_000) await this.sql`ANALYZE objects`
+    if (session.changedLinks >= 1_000) await this.sql`ANALYZE links`
     const record = await this.insertCommit(session.header, input)
     await this.sessions.release(session)
     return { commit: record }
@@ -393,6 +405,7 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
       sourceId: input.source.projectionId,
       candidateMaterializationId: input.candidateMaterializationId,
       previousMaterializationId: previous?.materialization_id ?? null,
+      incremental: candidate.base_materialization_id !== null,
       projectionKind: candidate.projection_kind,
       objectStreamStarted: false,
       objectStreamCompleted: false,
@@ -539,7 +552,7 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     assertMaterializationFinalizationCorrelation(session, input)
     const laneCounts = await this.sessions.laneCounts(session)
     assertMaterializationLaneCompletion(session, laneCounts)
-    await this.assertFinalCardinality(session)
+    if (laneCounts.cardinality > 0) await this.assertFinalCardinality(session)
     const eventCount = laneCounts.event
     const [outbox] = await this.sql<
       {
@@ -584,17 +597,27 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
   }
 
   private async assertFinalCardinality(session: PgMaterializationSessionState): Promise<void> {
-    const [violation] = await this.sql<{ readonly reason: "duplicate" | "mismatch" }[]>`
-      WITH work AS (
-        SELECT payload->>'scopeSortKey' AS scope_sort_key,
-          payload->>'linkSortKey' AS link_sort_key,
+    // A mixed work table can hide a few occupied scopes among millions of other records.
+    // Even ANALYZE can miss that population. Isolate it before planning the final join so
+    // the planner sees a relation of scopes, without JSON/session selectivity guesses.
+    // Session IDs are provider-generated UUIDs. Use unprepared statements for this private
+    // identifier so each session does not leave a new statement in the connection cache.
+    const table = `ontology_cardinality_${session.id.replaceAll("-", "")}`
+    await this.sql.unsafe(
+      `CREATE TEMP TABLE ${table} ON COMMIT DROP AS
+        SELECT sort_one AS scope_sort_key, sort_two AS link_sort_key,
           (payload->>'occupied')::boolean AS occupied,
           payload->'ref'->'source'->>'objectTypeId' AS source_type_id,
           payload->'ref'->'source'->>'primaryId' AS source_id,
           payload->'ref'->>'linkId' AS link_id
-        FROM ${this.sql(PG_MATERIALIZATION_WORK_TABLE)}
-        WHERE session_id = ${session.id} AND kind = 'cardinality'
-          AND payload->>'view' = 'effective'
+        FROM ${PG_MATERIALIZATION_WORK_TABLE}
+        WHERE session_id = $1 AND lane = 'cardinality' AND major_order = 0`,
+      [session.id]
+    )
+    await this.sql.unsafe(`ANALYZE ${table}`)
+    const [violation] = await this.sql.unsafe<{ readonly reason: "duplicate" | "mismatch" }[]>(
+      `WITH work AS (
+        SELECT * FROM ${table}
       ), duplicate AS (
         SELECT scope_sort_key FROM work WHERE occupied
         GROUP BY scope_sort_key HAVING COUNT(*) > 1
@@ -604,10 +627,10 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
         SELECT scope_sort_key, link_sort_key FROM work WHERE occupied
       ), actual AS (
         SELECT scopes.scope_sort_key,
-          ${this.sql.unsafe(linkSortExpression("links"))} AS link_sort_key
+          ${linkSortExpression("links")} AS link_sort_key
         FROM scopes
         JOIN links USING (source_type_id, source_id, link_id)
-        WHERE links.project_id = ${session.header.commit.projectId}
+        WHERE links.project_id = $1
       ), differences AS (
         (SELECT * FROM expected EXCEPT SELECT * FROM actual)
         UNION ALL
@@ -616,8 +639,10 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
       SELECT 'duplicate'::text AS reason FROM duplicate
       UNION ALL
       SELECT 'mismatch'::text AS reason FROM differences
-      LIMIT 1
-    `
+      LIMIT 1`,
+      [session.header.commit.projectId]
+    )
+    await this.sql.unsafe(`DROP TABLE ${table}`)
     if (violation?.reason === "duplicate") {
       invalidCorrelation("Materialization cardinality work violates cardinality-one.")
     }
@@ -766,6 +791,7 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
       true
     )
     this.assertSourceRow(activation.expected, previous)
+    await activateSourceRoots(this.sql, commit.projectId, candidate, activation)
     if (previous) {
       assertPinnedDatasetWatermark(
         {

package/src/ontology-storage/shared.ts

@@ -64,6 +64,8 @@ export interface PgOntologySourceRow {
   readonly ownership_hash: string
   readonly ontology_revision: string
   readonly root_count: number | string | null
+  readonly base_materialization_id: string | null
+  readonly base_commit_id: string | null
   readonly assertion_count: number | string | null
   readonly created_at: Date | string
   readonly ready_at: Date | string | null
@@ -146,6 +148,14 @@ export function sourceRecord(row: PgOntologySourceRow): OntologySourceRecord {
     projectionRevision: row.projection_revision,
     ownershipHash: row.ownership_hash,
     ontologyRevision: row.ontology_revision,
+    ...(row.base_materialization_id === null
+      ? {}
+      : {
+          base: {
+            materializationId: row.base_materialization_id,
+            lastCommitId: row.base_commit_id!,
+          },
+        }),
     rootCount:
       row.root_count === null ? null : databaseSafeInteger(row.root_count, "Source root count"),
     assertionCount:

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

@@ -0,0 +1,61 @@
+import type {
+  CleanupTerminalSourceMaterializationsInput,
+  CleanupTerminalSourceMaterializationsResult,
+} from "@sixb/core/storage"
+import type { SQLClient } from "../pg-client"
+
+export async function cleanupSourceVersions(
+  sql: SQLClient,
+  input: CleanupTerminalSourceMaterializationsInput
+): Promise<CleanupTerminalSourceMaterializationsResult> {
+  let remaining = input.limit
+  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
+      LIMIT ${remaining} FOR UPDATE OF rows SKIP LOCKED
+    ) DELETE FROM ontology_source_rows AS rows USING selected WHERE rows.ctid = selected.ctid RETURNING 1
+  `
+  let rowsDeleted = removedRows.length
+  remaining -= rowsDeleted
+  if (remaining > 0) {
+    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
+        LIMIT ${remaining} FOR UPDATE OF roots SKIP LOCKED
+      ) DELETE FROM ontology_source_roots AS roots USING selected WHERE roots.ctid = selected.ctid RETURNING 1
+    `
+    rowsDeleted += removed.length
+    remaining -= removed.length
+  }
+  const removedManifests =
+    remaining === 0
+      ? []
+      : 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}
+        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)
+      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
+  `
+  return { rowsDeleted, materializationsDeleted: removedManifests.length }
+}