@sixb/pg 0.1.20 → 0.1.22

package/src/objects/read-scope.ts

@@ -1,7 +1,11 @@
-import type { CompiledSelectedObjectReadScope } from "@sixb/core/storage"
+import type {
+  CompiledConditionalObjectReadScope,
+  CompiledSelectedObjectReadScope,
+} from "@sixb/core/storage"
 import {
   type CompiledPgObjectQuery,
   compilePgObjectStatement,
+  compilePredicate,
   type PgObjectQuerySource,
 } from "./query-compiler"
 
@@ -30,16 +34,78 @@ export function compilePgSelectedObjectReadSource(
     objects: scope.objects,
     steps: scope.steps,
   })
-  const compiled = compileSelectedReadScopeCte(scopeJson, projectId)
+  const source: PgSelectedObjectReadSource = {
+    ...scopedQuerySource(compileSelectedReadScopeCte(scopeJson, projectId)),
+    objectPropertyPermissionsTable: "_sixb_scope_object_permissions",
+    traversalProbe: { sql: "", args: [] },
+  }
+
+  const traversalProbe = compilePgObjectStatement(
+    `
+      SELECT COUNT(*)::bigint AS total
+      FROM (
+        SELECT 1 AS traversal_fact
+        FROM _sixb_scope_root_facts
+
+        UNION ALL
+
+        SELECT 1 AS traversal_fact
+        FROM _sixb_scope_reached_links
+
+        LIMIT ?
+      ) AS bounded_traversal_facts
+    `,
+    [BigInt(maxTraversalFacts) + 1n],
+    source
+  )
+
+  return Object.freeze({ ...source, traversalProbe })
+}
+
+/**
+ * Prepare a conditional scope as PostgreSQL relations that filter stored rows as they are read.
+ *
+ * Both relations are NOT MATERIALIZED, so PostgreSQL inlines them into each statement: its
+ * filters, index scans and LIMIT reach the stored tables, and the conditions become one more
+ * filter. An object of a conditioned type is visible while its condition matches; a link while
+ * each of its conditioned endpoints is a visible object.
+ */
+export function compilePgConditionalObjectReadSource(
+  projectId: string,
+  scope: CompiledConditionalObjectReadScope
+): PgObjectQuerySource {
+  const filters = new Map(
+    scope.conditions.map((condition) => [
+      condition.objectTypeId,
+      compilePredicate(condition.predicate),
+    ])
+  )
+
+  return Object.freeze({
+    ...scopedQuerySource(compileConditionalReadScopeCte(projectId, filters)),
+    // One type's visible objects are the stored ones its own condition matches.
+    objectsOfType: (objectTypeId: string) => {
+      const filter = filters.get(objectTypeId)
+      return filter ? { table: "objects", filter } : { table: "objects" }
+    },
+  })
+}
+
+interface CompiledReadScopeCte {
+  readonly sql: string
+  readonly args: readonly unknown[]
+}
+
+/** Prefix every statement of a query with the scope's relations, ahead of its own arguments. */
+function scopedQuerySource(compiled: CompiledReadScopeCte): PgObjectQuerySource {
   const wrapStatement = (sql: string, args: readonly unknown[] = []) => ({
     sql: `${compiled.sql}\n${sql}`,
     args: [...compiled.args, ...args],
   })
 
-  const source: PgSelectedObjectReadSource = {
+  return {
     objectsTable: "_sixb_scope_objects",
     linksTable: "_sixb_scope_links",
-    objectPropertyPermissionsTable: "_sixb_scope_object_permissions",
     wrapStatement,
     wrapQuery: (query: CompiledPgObjectQuery): CompiledPgObjectQuery => ({
       ...query,
@@ -58,34 +124,83 @@ export function compilePgSelectedObjectReadSource(
           }
         : {}),
     }),
-    traversalProbe: { sql: "", args: [] },
   }
+}
 
-  const traversalProbe = compilePgObjectStatement(
-    `
-      SELECT COUNT(*)::bigint AS total
-      FROM (
-        SELECT 1 AS traversal_fact
-        FROM _sixb_scope_root_facts
+/** Conditions keyed by their concrete type, each compiled over that type's `properties`. */
+type ConditionFilters = ReadonlyMap<
+  string,
+  { readonly sql: string; readonly args: readonly unknown[] }
+>
 
-        UNION ALL
+function compileConditionalReadScopeCte(
+  projectId: string,
+  filters: ConditionFilters
+): CompiledReadScopeCte {
+  if (filters.size === 0) {
+    return {
+      sql: `
+        WITH
+        _sixb_scope_objects AS NOT MATERIALIZED (
+          SELECT * FROM objects WHERE project_id = ?
+        ),
+        _sixb_scope_links AS NOT MATERIALIZED (
+          SELECT * FROM links WHERE project_id = ?
+        )
+      `,
+      args: [projectId, projectId],
+    }
+  }
 
-        SELECT 1 AS traversal_fact
-        FROM _sixb_scope_reached_links
+  const conditionedTypeArgs = [...filters.keys()]
+  const conditionedTypes = conditionedTypeArgs.map(() => "?::text").join(", ")
 
-        LIMIT ?
-      ) AS bounded_traversal_facts
-    `,
-    [BigInt(maxTraversalFacts) + 1n],
-    source
-  )
+  const matches: string[] = []
+  const matchArgs: unknown[] = []
+  for (const [objectTypeId, filter] of filters) {
+    matches.push(`(object_type_id = ?::text AND ${filter.sql})`)
+    matchArgs.push(objectTypeId, ...filter.args)
+  }
 
-  return Object.freeze({ ...source, traversalProbe })
-}
+  const visibleEndpoint = (end: "source" | "target") => `
+    (
+      stored.${end}_type_id NOT IN (${conditionedTypes})
+      OR EXISTS (
+        SELECT 1
+        FROM _sixb_scope_objects AS endpoint
+        WHERE endpoint.project_id = stored.project_id
+          AND endpoint.object_type_id = stored.${end}_type_id
+          AND endpoint.primary_id = stored.${end}_id
+      )
+    )
+  `
 
-interface CompiledReadScopeCte {
-  readonly sql: string
-  readonly args: readonly unknown[]
+  return {
+    sql: `
+      WITH
+      _sixb_scope_objects AS NOT MATERIALIZED (
+        SELECT *
+        FROM objects
+        WHERE project_id = ?
+          AND (object_type_id NOT IN (${conditionedTypes}) OR ${matches.join(" OR ")})
+      ),
+      _sixb_scope_links AS NOT MATERIALIZED (
+        SELECT stored.*
+        FROM links AS stored
+        WHERE stored.project_id = ?
+          AND ${visibleEndpoint("source")}
+          AND ${visibleEndpoint("target")}
+      )
+    `,
+    args: [
+      projectId,
+      ...conditionedTypeArgs,
+      ...matchArgs,
+      projectId,
+      ...conditionedTypeArgs,
+      ...conditionedTypeArgs,
+    ],
+  }
 }
 
 function compileSelectedReadScopeCte(scopeJson: string, projectId: string): CompiledReadScopeCte {

package/src/objects/reader.ts

@@ -30,6 +30,7 @@ import {
   compilePgObjectStatement,
   DEFAULT_OBJECT_QUERY_SOURCE,
   type PgObjectQuerySource,
+  pgObjectsOfType,
 } from "./query-compiler"
 import { findPgSortIndexBound } from "./query-indexes"
 import type { PgSelectedObjectReadSource } from "./read-scope"
@@ -258,13 +259,14 @@ export class PgObjectReader {
   }): Promise<ObjectRow | null> {
     const sql = this.sql
     const source = this.source
+    const objects = pgObjectsOfType(source, params.objectTypeId)
     const statement = compilePgObjectStatement(
       `
         SELECT *
-        FROM ${source.objectsTable}
-        WHERE project_id = ? AND object_type_id = ? AND primary_id = ?
+        FROM ${objects.table}
+        WHERE project_id = ? AND object_type_id = ? AND primary_id = ? ${objects.filter}
       `,
-      [params.projectId, params.objectTypeId, params.primaryId],
+      [params.projectId, params.objectTypeId, params.primaryId, ...objects.args],
       source
     )
     const [row] = await sql.unsafe<ObjectDatabaseRow[]>(
@@ -275,6 +277,44 @@ export class PgObjectReader {
     return row ? rowToObject(row) : null
   }
 
+  /** On a selected source, the holder must be in scope and selected for the property. */
+  async getByUniqueValue(
+    params: Parameters<ObjectReadStorage["getByUniqueValue"]>[0]
+  ): Promise<ObjectRow | null> {
+    const source = this.source
+    const selected = "objectPropertyPermissionsTable" in source
+    const permitted = selected
+      ? `AND EXISTS (
+           SELECT 1 FROM ${source.objectPropertyPermissionsTable} AS permitted
+           WHERE permitted.project_id = objects.project_id
+             AND permitted.object_type_id = objects.object_type_id
+             AND permitted.primary_id = objects.primary_id
+             AND permitted.property_id = held.property_id
+         )`
+      : ""
+    const statement = compilePgObjectStatement(
+      `
+        SELECT objects.*
+        FROM object_unique_values AS held
+        JOIN ${source.objectsTable} AS objects
+          ON objects.project_id = held.project_id
+         AND objects.object_type_id = held.object_type_id
+         AND objects.primary_id = held.primary_id
+        WHERE held.project_id = ? AND held.object_type_id = ? AND held.property_id = ?
+          AND held.value_hash = sha256(convert_to(?, 'UTF8')) AND held.value_key = ?
+          ${permitted}
+      `,
+      [params.projectId, params.objectTypeId, params.propertyId, params.valueKey, params.valueKey],
+      source
+    )
+    const [row] = await this.sql.unsafe<ObjectDatabaseRow[]>(
+      statement.sql,
+      statement.args as SqlParameter[]
+    )
+
+    return row ? rowToObject(row) : null
+  }
+
   async selectsObjectProperties(
     params: Parameters<ObjectReadStorage["selectsObjectProperties"]>[0]
   ): Promise<readonly boolean[]> {
@@ -592,11 +632,15 @@ export class PgObjectReader {
     const order = params.order ?? "desc"
     const orderColumn =
       orderBy === "primaryId" ? "primary_id" : orderBy === "createdAt" ? "created_at" : "updated_at"
+    const typed =
+      typeof params.objectTypeId === "string"
+        ? pgObjectsOfType(source, params.objectTypeId)
+        : { table: source.objectsTable, filter: "", args: [] }
     const filters = ["project_id = ?"]
     const args: unknown[] = [params.projectId]
     if (typeof params.objectTypeId === "string") {
-      filters.push("object_type_id = ?")
-      args.push(params.objectTypeId)
+      filters.push(`object_type_id = ? ${typed.filter}`)
+      args.push(params.objectTypeId, ...typed.args)
     } else if (params.objectTypeId !== undefined) {
       filters.push("object_type_id IN (SELECT jsonb_array_elements_text(?::text::jsonb))")
       args.push(JSON.stringify(params.objectTypeId))
@@ -626,7 +670,7 @@ export class PgObjectReader {
       args.push(params.createdBefore)
     }
 
-    const objectsTable = source.objectsTable
+    const objectsTable = typed.table
     const whereSql = filters.join(" AND ")
     const countStatement = compilePgObjectStatement(
       `SELECT COUNT(*)::int AS total FROM ${objectsTable} WHERE ${whereSql}`,

package/src/objects/scoped-reader.ts

@@ -0,0 +1,101 @@
+import type { ObjectQuery } from "@sixb/core"
+import type {
+  ObjectQueryCapabilities,
+  ObjectReadExecutionLimits,
+  ObjectReadStorage,
+} from "@sixb/core/storage"
+import {
+  assertObjectReaderProject,
+  assertObjectReadFacetCount,
+  assertObjectReadOutputWithinLimit,
+} from "@sixb/core/storage"
+import { assertLinkQueryLimit, type PgObjectReader } from "./reader"
+
+/** Run one terminal on a reader over the scope's source; a query terminal passes its query. */
+export type PgScopedRead = <T>(
+  run: (reader: PgObjectReader) => Promise<T>,
+  query?: ObjectQuery
+) => Promise<T>
+
+/** Answer every terminal through one scoped source; the scope decides how each read runs. */
+export function createPgScopedReader(
+  params: {
+    projectId: string
+    read: PgScopedRead
+    limits?: ObjectReadExecutionLimits
+  },
+  queryCapabilities: () => ObjectQueryCapabilities
+): ObjectReadStorage {
+  const { projectId, limits } = params
+  const assertProject = (actualProjectId: string): void =>
+    assertObjectReaderProject(projectId, actualProjectId)
+  const read = async <T>(
+    run: (reader: PgObjectReader) => Promise<T>,
+    query?: ObjectQuery
+  ): Promise<T> => {
+    const value = await params.read(run, query)
+    if (limits) assertObjectReadOutputWithinLimit(value, limits)
+    return value
+  }
+  const readMap = async <TKey, TValue>(
+    run: (reader: PgObjectReader) => Promise<Map<TKey, TValue>>
+  ): Promise<Map<TKey, TValue>> => {
+    const value = await params.read(run)
+    if (limits) assertObjectReadOutputWithinLimit([...value.entries()], limits)
+    return value
+  }
+
+  return Object.freeze({
+    queryCapabilities,
+    queryObjects: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.queryObjects(input), input.query)
+    },
+    countObjects: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.countObjects(input), input.query)
+    },
+    existsObjects: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.existsObjects(input), input.query)
+    },
+    facetObjects: async (input) => {
+      assertProject(input.projectId)
+      assertObjectReadFacetCount(input.facets.length)
+      return read((reader) => reader.facetObjects(input), input.query)
+    },
+    getByPrimaryId: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.getByPrimaryId(input))
+    },
+    getByUniqueValue: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.getByUniqueValue(input))
+    },
+    selectsObjectProperties: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.selectsObjectProperties(input))
+    },
+    listLinks: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.listLinks(input))
+    },
+    getByPrimaryIdBatch: async (input) => {
+      assertProject(input.projectId)
+      return readMap((reader) => reader.getByPrimaryIdBatch(input))
+    },
+    listLinksBatch: async (input) => {
+      assertProject(input.projectId)
+      return readMap((reader) => reader.listLinksBatch(input))
+    },
+    queryLinks: async (input) => {
+      assertProject(input.projectId)
+      assertLinkQueryLimit(input.limit)
+      return read((reader) => reader.queryLinks(input))
+    },
+    list: async (input) => {
+      assertProject(input.projectId)
+      return read((reader) => reader.list(input))
+    },
+  } satisfies ObjectReadStorage)
+}

package/src/objects/selected-reader.ts

@@ -4,19 +4,14 @@ import type {
   ObjectReadExecutionLimits,
   ObjectReadStorage,
 } from "@sixb/core/storage"
-import {
-  assertObjectReaderProject,
-  assertObjectReadFacetCount,
-  assertObjectReadOutputWithinLimit,
-  ObjectReadLimitExceededError,
-  snapshotObjectReadExecutionLimits,
-} from "@sixb/core/storage"
+import { ObjectReadLimitExceededError, snapshotObjectReadExecutionLimits } from "@sixb/core/storage"
 import type { SQLClient, SqlParameter } from "../pg-client"
 import { type PgStoreClient, runPgRepeatableReadTransaction } from "../transactions"
 import { compilePgSelectedObjectReadSource, type PgSelectedObjectReadSource } from "./read-scope"
+import { PgObjectReader } from "./reader"
+import { createPgScopedReader } from "./scoped-reader"
 
-import { assertLinkQueryLimit, PgObjectReader } from "./reader"
-
+/** Keep the traversal probe and every terminal statement on one repeatable-read snapshot. */
 export function createPgSelectedReader(
   sql: PgStoreClient,
   params: {
@@ -33,74 +28,19 @@ export function createPgSelectedReader(
     params.scope,
     limits.maxTraversalFacts
   )
-  const assertProject = (actualProjectId: string): void =>
-    assertObjectReaderProject(projectId, actualProjectId)
-  const read = <T>(run: (reader: PgObjectReader) => Promise<T>): Promise<T> =>
-    runPgRepeatableReadTransaction(sql, async (tx) => {
-      await assertTraversalBudget(tx, source, limits.maxTraversalFacts)
-      const value = await run(new PgObjectReader(tx, source))
-      assertObjectReadOutputWithinLimit(value, limits)
-      return value
-    })
-  const readMap = <TKey, TValue>(
-    run: (reader: PgObjectReader) => Promise<Map<TKey, TValue>>
-  ): Promise<Map<TKey, TValue>> =>
-    runPgRepeatableReadTransaction(sql, async (tx) => {
-      await assertTraversalBudget(tx, source, limits.maxTraversalFacts)
-      const value = await run(new PgObjectReader(tx, source))
-      assertObjectReadOutputWithinLimit([...value.entries()], limits)
-      return value
-    })
 
-  return Object.freeze({
-    queryCapabilities,
-    queryObjects: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.queryObjects(input))
-    },
-    countObjects: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.countObjects(input))
-    },
-    existsObjects: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.existsObjects(input))
-    },
-    facetObjects: async (input) => {
-      assertProject(input.projectId)
-      assertObjectReadFacetCount(input.facets.length)
-      return read((reader) => reader.facetObjects(input))
-    },
-    getByPrimaryId: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.getByPrimaryId(input))
-    },
-    selectsObjectProperties: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.selectsObjectProperties(input))
-    },
-    listLinks: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.listLinks(input))
-    },
-    getByPrimaryIdBatch: async (input) => {
-      assertProject(input.projectId)
-      return readMap((reader) => reader.getByPrimaryIdBatch(input))
-    },
-    listLinksBatch: async (input) => {
-      assertProject(input.projectId)
-      return readMap((reader) => reader.listLinksBatch(input))
-    },
-    queryLinks: async (input) => {
-      assertProject(input.projectId)
-      assertLinkQueryLimit(input.limit)
-      return read((reader) => reader.queryLinks(input))
-    },
-    list: async (input) => {
-      assertProject(input.projectId)
-      return read((reader) => reader.list(input))
-    },
-  } satisfies ObjectReadStorage)
+  return createPgScopedReader(
+    {
+      projectId,
+      read: (run) =>
+        runPgRepeatableReadTransaction(sql, async (tx) => {
+          await assertTraversalBudget(tx, source, limits.maxTraversalFacts)
+          return run(new PgObjectReader(tx, source))
+        }),
+      limits,
+    },
+    queryCapabilities
+  )
 }
 
 async function assertTraversalBudget(

package/src/objects/storage.ts

@@ -1,5 +1,6 @@
 import { hasVectorProfile } from "@sixb/core/internal/query"
 import type {
+  CompiledConditionalObjectReadScope,
   CompiledSelectedObjectReadScope,
   CountObjectsInput,
   CountObjectsResult,
@@ -28,6 +29,7 @@ import {
   runPgRepeatableReadTransaction,
 } from "../transactions"
 import { PgAggregateAdmission } from "./aggregate-admission"
+import { createPgConditionalReader } from "./conditional-reader"
 import { DEFAULT_OBJECT_QUERY_SOURCE } from "./query-compiler"
 import { assertLinkQueryLimit, PgObjectReader } from "./reader"
 import {
@@ -71,6 +73,7 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     in: true,
     exists: true,
     contains: true,
+    constant: true,
   },
   sortKinds: {
     property: true,
@@ -110,17 +113,17 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
 
 /** PostgreSQL object provider; interactive reads share one source-aware reader. */
 export class PgObjectStorage implements ObjectStorage {
+  private readonly aggregateAdmission?: PgAggregateAdmission
   private readonly reader: PgObjectReader
 
   constructor(
     private readonly sql: PgStoreClient,
     maxConcurrentAggregates = 1
   ) {
-    this.reader = new PgObjectReader(
-      sql,
-      DEFAULT_OBJECT_QUERY_SOURCE,
-      canStartPgTransaction(sql) ? new PgAggregateAdmission(maxConcurrentAggregates) : undefined
-    )
+    this.aggregateAdmission = canStartPgTransaction(sql)
+      ? new PgAggregateAdmission(maxConcurrentAggregates)
+      : undefined
+    this.reader = new PgObjectReader(sql, DEFAULT_OBJECT_QUERY_SOURCE, this.aggregateAdmission)
   }
 
   queryCapabilities(): ObjectQueryCapabilities {
@@ -135,6 +138,16 @@ export class PgObjectStorage implements ObjectStorage {
     return createPgSelectedReader(this.sql, params, () => this.queryCapabilities())
   }
 
+  createConditionalReadScope(params: {
+    projectId: string
+    scope: CompiledConditionalObjectReadScope
+  }): ObjectReadStorage {
+    return createPgConditionalReader(this.sql, params, {
+      aggregateAdmission: this.aggregateAdmission,
+      queryCapabilities: () => this.queryCapabilities(),
+    })
+  }
+
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
     if (hasVectorProfile(params.query))
       return runPgRepeatableReadTransaction(this.sql, (tx) =>
@@ -175,6 +188,12 @@ export class PgObjectStorage implements ObjectStorage {
     return this.reader.getByPrimaryId(params)
   }
 
+  async getByUniqueValue(
+    params: Parameters<ObjectReadStorage["getByUniqueValue"]>[0]
+  ): Promise<ObjectRow | null> {
+    return this.reader.getByUniqueValue(params)
+  }
+
   async selectsObjectProperties(
     params: Parameters<ObjectReadStorage["selectsObjectProperties"]>[0]
   ): Promise<readonly boolean[]> {

package/src/objects/text-count-index.ts

@@ -401,6 +401,7 @@ function stringPredicate(
       ? `(${items.join(predicate.op === "and" ? " AND " : " OR ")})`
       : undefined
   }
+  if (predicate.op === "constant") return predicate.value ? "true" : "false"
   if ((predicate.op !== "eq" && predicate.op !== "in") || predicate.scalarKind === "decimal")
     return undefined
   const column = columns.get(predicate.propertyId)

package/src/ontology-storage/index.ts

@@ -7,6 +7,7 @@ import { PgOntologyOutboxStorage } from "./outbox"
 import { PgOntologyReplacementPlanStorage } from "./replacement-plans"
 import type { PgRootOperation } from "./shared"
 import { PgOntologySourceStorage } from "./sources"
+import { PgOntologyUniqueValueStorage } from "./unique-values"
 import { PgVectorIndexingStorage } from "./vector-indexing"
 import { PgOntologyVectorStorage } from "./vectors"
 
@@ -18,6 +19,7 @@ export class PgOntologyStorage implements OntologyStorage {
   readonly outbox: PgOntologyOutboxStorage
   readonly vectorIndexing: PgVectorIndexingStorage
   readonly vectors: PgOntologyVectorStorage
+  readonly uniqueValues: PgOntologyUniqueValueStorage
 
   constructor(input: {
     readonly sql: SQLClient
@@ -32,6 +34,7 @@ export class PgOntologyStorage implements OntologyStorage {
     )
     this.replacementPlans = new PgOntologyReplacementPlanStorage(input.sql)
     this.outbox = new PgOntologyOutboxStorage(input.runRootOperation)
+    this.uniqueValues = new PgOntologyUniqueValueStorage(input.runRootOperation)
     this.vectorIndexing = new PgVectorIndexingStorage(
       input.sql,
       input.runRootOperation,

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

@@ -35,6 +35,9 @@ export class PgMaterializationSessionState extends ProviderMaterializationSessio
   stagedWorkCount = 0
   changedObjects = 0
   changedLinks = 0
+  changedUniqueValues = 0
+  /** What unique value items this session staged, known without reading its work back. */
+  readonly uniqueWork = { releases: false, claims: false }
   workAnalyzed = false
   /** Work staged on the session lives in a temp table; a plan-bound session reads its plan's. */
   readonly workTable: string
@@ -156,6 +159,11 @@ export class PgMaterializationSessions {
       throw error
     }
     session.stagedWorkCount += records.length
+    for (const { record } of records) {
+      if (record.kind !== "plan") continue
+      if (record.item.kind === "unique-value-release") session.uniqueWork.releases = true
+      if (record.item.kind === "unique-value-claim") session.uniqueWork.claims = true
+    }
   }
 
   /**