@sixb/pg 0.1.20 → 0.1.22

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

@@ -16,6 +16,7 @@ import {
 import type { MaterializationPlanWorkItem } from "@sixb/core/storage"
 import type postgres from "postgres"
 import type { SQL, SQLClient } from "../pg-client"
+import { claimPgUniqueValues, heldValue } from "./unique-values"
 
 export interface PgStagedPlanTarget {
   /** The work table and the id its rows carry: a session's temp table, or a durable plan. */
@@ -24,11 +25,19 @@ export interface PgStagedPlanTarget {
   readonly projectId: string
   readonly commitId: string
   readonly committedAt: string
+  /** Whether unique value items were staged; probed in the work table when unknown. */
+  readonly uniqueWork?: PgUniqueWork
+}
+
+export interface PgUniqueWork {
+  readonly releases: boolean
+  readonly claims: boolean
 }
 
 export interface PgAppliedPlan {
   readonly objectWrites: number
   readonly linkWrites: number
+  readonly uniqueValueWrites: number
   readonly eventCount: number
 }
 
@@ -55,13 +64,32 @@ export class PgMaterializationWriter {
     await this.applyObjectOverrides(target)
     await this.applyLinkOverrides(target)
     await this.applyPoints(target)
+    const uniqueWork = target.uniqueWork ?? (await this.stagedUniqueWork(target))
+    if (uniqueWork.releases) await this.releaseUniqueValues(target)
     let linkWrites = await this.deleteLinks(target)
     let objectWrites = await this.deleteObjects(target)
     objectWrites += await this.upsertObjects(target)
     linkWrites += await this.upsertLinks(target)
+    const uniqueValueWrites = uniqueWork.claims ? await this.claimUniqueValues(target) : 0
     const eventCount = await this.writeOutbox(target)
     await this.writeTouches(target)
-    return { objectWrites, linkWrites, eventCount }
+    return { objectWrites, linkWrites, uniqueValueWrites, eventCount }
+  }
+
+  /** Two probes of the work table's lane index: a commit with no unique values runs nothing else. */
+  private async stagedUniqueWork(target: PgStagedPlanTarget): Promise<PgUniqueWork> {
+    const probe = (kind: "unique-value-release" | "unique-value-claim") => this.sql`
+      EXISTS (
+        SELECT 1 FROM ${this.sql(target.workTable)}
+        WHERE work_id = ${target.workId} AND lane = 'apply'
+          AND major_order = ${materializationApplyPhase(kind)}
+          AND minor_order = ${materializationPlanKindRank(kind)}
+      )
+    `
+    const [row] = await this.sql<{ readonly releases: boolean; readonly claims: boolean }[]>`
+      SELECT ${probe("unique-value-release")} AS releases, ${probe("unique-value-claim")} AS claims
+    `
+    return { releases: row?.releases ?? false, claims: row?.claims ?? false }
   }
 
   /** The staged values of one plan item kind, as `value`. */
@@ -330,6 +358,51 @@ export class PgMaterializationWriter {
     )
   }
 
+  /** The staged unique values of one item kind, as the columns their table keys them by. */
+  private stagedUniqueValues(
+    target: PgStagedPlanTarget,
+    kind: "unique-value-release" | "unique-value-claim"
+  ) {
+    return this.sql`
+      SELECT value->>'objectTypeId' AS object_type_id, value->>'propertyId' AS property_id,
+        value->>'valueKey' AS value_key, value->>'primaryId' AS primary_id,
+        value->>'keyKind' AS key_kind, (value->>'keyVersion')::integer AS key_version
+      FROM (${this.staged(target, kind)}) AS staged
+    `
+  }
+
+  /** A value whose row already names another object, or none, is simply no longer this one's. */
+  private async releaseUniqueValues(target: PgStagedPlanTarget): Promise<void> {
+    await this.sql`
+      WITH candidates AS MATERIALIZED (
+        ${this.stagedUniqueValues(target, "unique-value-release")}
+      ), released AS (
+        SELECT candidates.object_type_id, candidates.property_id, held.value_hash
+        FROM candidates
+        CROSS JOIN LATERAL (
+          ${heldValue(this.sql, target.projectId)}
+            AND stored.primary_id = candidates.primary_id
+          LIMIT 1
+        ) AS held
+      )
+      DELETE FROM object_unique_values AS stored USING released
+      WHERE stored.project_id = ${target.projectId}
+        AND stored.object_type_id = released.object_type_id
+        AND stored.property_id = released.property_id
+        AND stored.value_hash = released.value_hash
+    `
+  }
+
+  /** Runs once every release of the commit has applied, so values can move between objects. */
+  private async claimUniqueValues(target: PgStagedPlanTarget): Promise<number> {
+    return claimPgUniqueValues(
+      this.sql,
+      target.projectId,
+      this.stagedUniqueValues(target, "unique-value-claim"),
+      { requirePrepared: true }
+    )
+  }
+
   private async deleteLinks(target: PgStagedPlanTarget): Promise<number> {
     const candidates = this.staged(target, "link-delete")
     return this.write(
@@ -586,6 +659,8 @@ export class PgMaterializationWriter {
           END AS ref
       ) AS entity
       WHERE work.work_id = ${target.workId} AND work.lane = 'apply'
+        -- Unique values are no plan input: a stale claim fails when it applies.
+        AND entity.kind IS NOT NULL
     `
   }
 

package/src/ontology-storage/materializations.ts

@@ -63,6 +63,7 @@ import {
   toIsoString,
 } from "./shared"
 import { activateSourceRoots } from "./source-roots"
+import { pgUniqueHolders } from "./unique-values"
 
 interface TelemetrySummaryRow {
   readonly classified_points: number | string
@@ -203,6 +204,17 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
           yield { objects: [], links: [], linkScopes: [], points: stored }
         }
       }
+      const uniqueValues = request.uniqueValues ?? []
+      for (let offset = 0; offset < uniqueValues.length; offset += input.pageRows) {
+        const uniqueHolders = await pgUniqueHolders(
+          this.sql,
+          session.header.commit.projectId,
+          uniqueValues.slice(offset, offset + input.pageRows)
+        )
+        if (uniqueHolders.length > 0) {
+          yield { objects: [], links: [], linkScopes: [], points: [], uniqueHolders }
+        }
+      }
     }
   }
 
@@ -238,9 +250,11 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
       projectId: commit.projectId,
       commitId: commit.id,
       committedAt: commit.committedAt,
+      ...(session.plan ? {} : { uniqueWork: session.uniqueWork }),
     })
     session.changedObjects = applied.objectWrites
     session.changedLinks = applied.linkWrites
+    session.changedUniqueValues = applied.uniqueValueWrites
     session.appliedEventCount = applied.eventCount
     return { eventCount: applied.eventCount }
   }
@@ -256,6 +270,11 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     // With empty/stale statistics, a link lookup can scan every edge sharing its target.
     await refreshMaterializedStatistics(this.sql, "objects", session.changedObjects)
     await refreshMaterializedStatistics(this.sql, "links", session.changedLinks)
+    await refreshMaterializedStatistics(
+      this.sql,
+      "object_unique_values",
+      session.changedUniqueValues
+    )
     const record = await this.insertCommit(session.header, input)
     await this.sessions.release(session)
     return { commit: record }
@@ -743,7 +762,7 @@ function databaseCount(value: number | string | undefined): number {
  * count can still include a previous transaction's manually analyzed writes at this point. */
 async function refreshMaterializedStatistics(
   sql: SQLClient,
-  table: "objects" | "links",
+  table: "objects" | "links" | "object_unique_values",
   changed: number
 ): Promise<void> {
   if (changed < 1_000) return

package/src/ontology-storage/replacement-plans.ts

@@ -50,11 +50,13 @@ const IDENTITIES = "ontology_replacement_plan_identities"
 const SORT_KEY = "encode(convert_to(identity_key, 'UTF8'), 'hex')"
 
 /**
- * Rows a plan writes at once before its tables are analyzed again. Autovacuum lags behind a bulk
- * write, and with the statistics of near-empty tables the planner scans a plan's whole work for
- * each keyed lookup instead of seeking it.
+ * Rows a plan writes before its tables are analyzed again: identities when it opens or expands,
+ * work once a stream has staged it. Every plan fills and empties the same tables, so their
+ * statistics describe the plans that were there when they were last analyzed. Until they describe
+ * this one, the planner expects none of its rows and reads its whole work for each key it looks
+ * up. Below this many rows, those reads cost less than an ANALYZE.
  */
-const ANALYZE_ROWS = 10_000
+const ANALYZE_ROWS = 1_000
 
 /** The plan a session applies: its work rows carry the candidate's source version as `work_id`. */
 export interface PgReplacementPlan {
@@ -240,7 +242,7 @@ export class PgOntologyReplacementPlanStorage implements OntologyReplacementPlan
     input: StreamReplacementPlanStateInput
   ): AsyncIterable<ReplacementPlanStatePage> {
     assertPageRows(input.pageRows)
-    await runPgTransaction(this.sql, async (sql) => {
+    const versionId = await runPgTransaction(this.sql, async (sql) => {
       const { candidate } = await requirePlan(sql, input)
       if (input.entityKind === "object" && candidate.projection_kind !== "object") {
         throw new MaterializationConflictError(
@@ -258,6 +260,7 @@ export class PgOntologyReplacementPlanStorage implements OntologyReplacementPlan
         const expanded = await expandLinks(sql, candidate.version_id, input.projectId, "pending")
         if (expanded >= ANALYZE_ROWS && !isWithinPgTransaction(this.sql)) await analyzePlans(sql)
       }
+      return candidate.version_id
     })
     let after = ""
     let streamed = 0
@@ -296,8 +299,8 @@ export class PgOntologyReplacementPlanStorage implements OntologyReplacementPlan
       if (!page) {
         // Every page is staged by now: later lookups and the commit join this work. Never in the
         // commit transaction, where ANALYZE would hold a lock other commits queue behind.
-        if (streamed >= ANALYZE_ROWS && !isWithinPgTransaction(this.sql)) {
-          await analyzePlans(this.sql)
+        if (streamed > 0 && !isWithinPgTransaction(this.sql)) {
+          await analyzeStagedWork(this.sql, versionId)
         }
         return
       }
@@ -994,6 +997,21 @@ async function analyzePlans(sql: SQLClient): Promise<void> {
   await sql`ANALYZE ${sql(IDENTITIES)}, ${sql(PG_PLAN_WORK_TABLE)}`
 }
 
+/**
+ * Analyzes the plan tables once the plan holds `ANALYZE_ROWS` rows of work. Counted in work rows,
+ * not identities: an object stages its classification, its existence, its change and its event.
+ */
+async function analyzeStagedWork(sql: SQLClient, versionId: string): Promise<void> {
+  const [staged] = await sql<{ readonly rows: number | string }[]>`
+    SELECT COUNT(*) AS rows FROM (
+      SELECT 1 FROM ${sql(PG_PLAN_WORK_TABLE)} WHERE work_id = ${versionId} LIMIT ${ANALYZE_ROWS}
+    ) AS work
+  `
+
+  if (Number(staged?.rows ?? 0) < ANALYZE_ROWS) return
+  await analyzePlans(sql)
+}
+
 /**
  * Deletes the work of the identities of `kind` left to plan: an identity to plan holds none. The
  * keys come first, so the work is sought by key whatever the plan tables' statistics.

package/src/ontology-storage/sources.ts

@@ -19,6 +19,7 @@ import type {
   AbandonRunSourceMaterializationInput,
   AbandonSourceMaterializationCandidateInput,
   AbandonSourceMaterializationInput,
+  ActiveOntologySource,
   AdoptedSourceMaterialization,
   AdoptSourceMaterializationInput,
   AssertSourceMaterializationExecutionInput,
@@ -26,6 +27,7 @@ import type {
   CleanupTerminalSourceMaterializationsInput,
   CleanupTerminalSourceMaterializationsResult,
   GetActiveOntologySourceInput,
+  ListActiveOntologySourcesInput,
   MarkSourceMaterializationReadyInput,
   OntologySourceRecord,
   OntologySourceStorage,
@@ -237,6 +239,32 @@ export class PgOntologySourceStorage implements OntologySourceStorage {
     })
   }
 
+  async listActive(
+    input: ListActiveOntologySourcesInput
+  ): Promise<readonly ActiveOntologySource[]> {
+    return this.runRootOperation(async (sql) => {
+      assertNonblank(input.projectId, "Source project id")
+
+      // Served by the partial index on active sources.
+      const rows = await sql<ActiveSourceRow[]>`
+        SELECT source_id, dataset_id, dataset_version_id, dataset_version_created_at,
+          projection_revision
+        FROM ontology_sources
+        WHERE project_id = ${input.projectId} AND status = 'active'
+      `
+
+      return rows.map((row) => ({
+        source: { projectionId: row.source_id },
+        datasetVersion: {
+          datasetId: row.dataset_id,
+          versionId: row.dataset_version_id,
+          createdAt: toIsoString(row.dataset_version_created_at),
+        },
+        projectionRevision: row.projection_revision,
+      }))
+    })
+  }
+
   async adopt(
     input: AdoptSourceMaterializationInput
   ): Promise<AdoptedSourceMaterialization | null> {
@@ -620,3 +648,12 @@ export class PgOntologySourceStorage implements OntologySourceStorage {
 function numberOrNull(value: number | string | null): number | null {
   return value === null ? null : Number(value)
 }
+
+type ActiveSourceRow = Pick<
+  PgOntologySourceRow,
+  | "source_id"
+  | "dataset_id"
+  | "dataset_version_id"
+  | "dataset_version_created_at"
+  | "projection_revision"
+>

package/src/ontology-storage/unique-values.ts

@@ -0,0 +1,274 @@
+import {
+  uniquePropertyNotPrepared,
+  uniqueValueViolation,
+} from "@sixb/core/internal/ontology-storage-provider"
+import type {
+  ExactUniqueValueWrite,
+  OntologyUniqueValueStorage,
+  PreparedUniqueProperty,
+  UniqueValueEntry,
+  UniqueValueRef,
+} from "@sixb/core/storage"
+import type postgres from "postgres"
+import type { SQLClient } from "../pg-client"
+import { jsonParameter, type PgRootOperation } from "./shared"
+
+type Query = postgres.PendingQuery<postgres.Row[]>
+
+interface PgClaimCounts {
+  readonly staged: number | string
+  readonly written: number | string
+  readonly unprepared_type: string | null
+  readonly unprepared_property: string | null
+}
+
+/**
+ * Gives each candidate value to its object, set-based. `candidates` selects `object_type_id`,
+ * `property_id`, `value_key` and `primary_id`, and with `requirePrepared` also the claim's
+ * `key_kind` and `key_version`, which must match how the property was prepared.
+ *
+ * The insert goes first and conflicts do nothing, as the plan writer's statements do: only when
+ * it writes fewer rows than it was given does a second query look for the holder to name. A value
+ * another object holds, or that two candidates give to different objects, throws
+ * `UniqueValueViolationError`; a value already held by its own object is no conflict. A value a
+ * concurrent transaction claimed after this one's snapshot fails serialization instead, so the
+ * commit retries and then finds it held.
+ */
+export async function claimPgUniqueValues(
+  sql: SQLClient,
+  projectId: string,
+  candidates: Query,
+  options: { readonly requirePrepared: boolean }
+): Promise<number> {
+  const unprepared = options.requirePrepared
+    ? sql`
+        SELECT claimed.object_type_id, claimed.property_id
+        FROM (
+          SELECT DISTINCT object_type_id, property_id, key_kind, key_version FROM candidates
+        ) AS claimed
+        WHERE NOT EXISTS (
+          SELECT 1 FROM object_unique_properties AS prepared
+          WHERE prepared.project_id = ${projectId}
+            AND prepared.object_type_id = claimed.object_type_id
+            AND prepared.property_id = claimed.property_id
+            AND prepared.key_kind = claimed.key_kind
+            AND prepared.key_version = claimed.key_version
+        )
+        LIMIT 1
+      `
+    : sql`SELECT NULL::text AS object_type_id, NULL::text AS property_id WHERE false`
+
+  const [counts] = await sql<PgClaimCounts[]>`
+    WITH candidates AS MATERIALIZED (${candidates}),
+    unprepared AS (${unprepared}),
+    written AS (
+      INSERT INTO object_unique_values (
+        project_id, object_type_id, property_id, value_hash, value_key, primary_id
+      )
+      SELECT ${projectId}, object_type_id, property_id,
+        sha256(convert_to(value_key, 'UTF8')), value_key, primary_id
+      FROM candidates
+      WHERE NOT EXISTS (SELECT 1 FROM unprepared)
+      ON CONFLICT DO NOTHING
+      RETURNING 1
+    )
+    SELECT (SELECT COUNT(*) FROM candidates) AS staged, (SELECT COUNT(*) FROM written) AS written,
+      (SELECT object_type_id FROM unprepared) AS unprepared_type,
+      (SELECT property_id FROM unprepared) AS unprepared_property
+  `
+
+  if (counts?.unprepared_type && counts.unprepared_property) {
+    throw uniquePropertyNotPrepared({
+      objectTypeId: counts.unprepared_type,
+      propertyId: counts.unprepared_property,
+    })
+  }
+
+  const written = Number(counts?.written ?? 0)
+  if (written !== Number(counts?.staged ?? 0)) await assertNoOtherHolder(sql, projectId, candidates)
+  return written
+}
+
+/** Names a candidate whose value another object holds, now that every candidate was inserted. */
+async function assertNoOtherHolder(
+  sql: SQLClient,
+  projectId: string,
+  candidates: Query
+): Promise<void> {
+  const [conflict] = await sql<
+    {
+      readonly object_type_id: string
+      readonly property_id: string
+      readonly holder: string
+      readonly claimant: string
+    }[]
+  >`
+    WITH candidates AS MATERIALIZED (${candidates})
+    SELECT candidates.object_type_id, candidates.property_id,
+      held.primary_id AS holder, candidates.primary_id AS claimant
+    FROM candidates
+    CROSS JOIN LATERAL (${heldValue(sql, projectId)} LIMIT 1) AS held
+    WHERE held.primary_id <> candidates.primary_id
+    LIMIT 1
+  `
+  if (!conflict) return
+
+  throw uniqueValueViolation(
+    { objectTypeId: conflict.object_type_id, propertyId: conflict.property_id },
+    conflict.holder,
+    conflict.claimant
+  )
+}
+
+/**
+ * The stored row of `candidates`' value, by its whole primary key: a lateral lookup per candidate
+ * keeps the planner on the index whatever it guesses of the table.
+ */
+export function heldValue(sql: SQLClient, projectId: string) {
+  return sql`
+    SELECT stored.primary_id, stored.value_hash
+    FROM object_unique_values AS stored
+    WHERE stored.project_id = ${projectId}
+      AND stored.object_type_id = candidates.object_type_id
+      AND stored.property_id = candidates.property_id
+      AND stored.value_hash = sha256(convert_to(candidates.value_key, 'UTF8'))
+      AND stored.value_key = candidates.value_key
+  `
+}
+
+/** The objects holding these unique values; a value no object holds is left out. */
+export async function pgUniqueHolders(
+  sql: SQLClient,
+  projectId: string,
+  values: readonly UniqueValueRef[]
+): Promise<ExactUniqueValueWrite[]> {
+  if (values.length === 0) return []
+  const requested = values.map((value) => ({
+    object_type_id: value.objectTypeId,
+    property_id: value.propertyId,
+    value_key: value.valueKey,
+  }))
+  const rows = await sql<
+    {
+      readonly object_type_id: string
+      readonly property_id: string
+      readonly value_key: string
+      readonly primary_id: string
+    }[]
+  >`
+    WITH candidates AS MATERIALIZED (
+      SELECT * FROM jsonb_to_recordset(${jsonParameter(sql, requested)}::jsonb)
+        AS requested(object_type_id text, property_id text, value_key text)
+    )
+    SELECT candidates.object_type_id, candidates.property_id, candidates.value_key,
+      held.primary_id
+    FROM candidates
+    CROSS JOIN LATERAL (${heldValue(sql, projectId)} LIMIT 1) AS held
+  `
+  return rows.map((row) => ({
+    objectTypeId: row.object_type_id,
+    propertyId: row.property_id,
+    valueKey: row.value_key,
+    primaryId: row.primary_id,
+  }))
+}
+
+export class PgOntologyUniqueValueStorage implements OntologyUniqueValueStorage {
+  constructor(private readonly runRootOperation: PgRootOperation) {}
+
+  /**
+   * `LOCK TABLE` takes no snapshot, so as the transaction's first statement it waits before the
+   * serializable snapshot is taken, and a preparer that waited sees the values the previous one
+   * built instead of building them again. An advisory lock would be taken by a `SELECT`, after
+   * the snapshot. Only preparation writes this table, so claims, which read it, never wait.
+   */
+  async lockPreparation(_input: { readonly projectId: string }): Promise<void> {
+    await this.runRootOperation(async (sql) => {
+      await sql`LOCK TABLE object_unique_properties IN SHARE ROW EXCLUSIVE MODE`
+    })
+  }
+
+  async listPrepared(input: {
+    readonly projectId: string
+  }): Promise<readonly PreparedUniqueProperty[]> {
+    return this.runRootOperation(async (sql) => {
+      const rows = await sql<
+        {
+          readonly object_type_id: string
+          readonly property_id: string
+          readonly key_kind: PreparedUniqueProperty["keyKind"]
+          readonly key_version: number
+        }[]
+      >`
+        SELECT object_type_id, property_id, key_kind, key_version FROM object_unique_properties
+        WHERE project_id = ${input.projectId}
+        ORDER BY object_type_id, property_id
+      `
+      return rows.map((row) => ({
+        objectTypeId: row.object_type_id,
+        propertyId: row.property_id,
+        keyKind: row.key_kind,
+        keyVersion: row.key_version,
+      }))
+    })
+  }
+
+  async clear(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+  }): Promise<void> {
+    await this.runRootOperation(async (sql) => {
+      await sql`
+        DELETE FROM object_unique_values
+        WHERE project_id = ${input.projectId} AND object_type_id = ${input.objectTypeId}
+          AND property_id = ${input.propertyId}
+      `
+      await sql`
+        DELETE FROM object_unique_properties
+        WHERE project_id = ${input.projectId} AND object_type_id = ${input.objectTypeId}
+          AND property_id = ${input.propertyId}
+      `
+    })
+  }
+
+  async insert(input: {
+    readonly projectId: string
+    readonly objectTypeId: string
+    readonly propertyId: string
+    readonly entries: readonly UniqueValueEntry[]
+  }): Promise<void> {
+    await this.runRootOperation((sql) =>
+      claimPgUniqueValues(
+        sql,
+        input.projectId,
+        sql`
+          SELECT ${input.objectTypeId}::text AS object_type_id,
+            ${input.propertyId}::text AS property_id,
+            entry->>'valueKey' AS value_key, entry->>'primaryId' AS primary_id
+          FROM jsonb_array_elements(${jsonParameter(sql, input.entries)}::jsonb) AS entry
+        `,
+        // The values are being prepared: nothing to require yet.
+        { requirePrepared: false }
+      )
+    )
+  }
+
+  async markPrepared(
+    input: PreparedUniqueProperty & { readonly projectId: string; readonly preparedAt: string }
+  ): Promise<void> {
+    await this.runRootOperation(async (sql) => {
+      await sql`
+        INSERT INTO object_unique_properties (
+          project_id, object_type_id, property_id, key_kind, key_version, prepared_at
+        ) VALUES (
+          ${input.projectId}, ${input.objectTypeId}, ${input.propertyId}, ${input.keyKind},
+          ${input.keyVersion}, ${input.preparedAt}::timestamptz
+        )
+        ON CONFLICT (project_id, object_type_id, property_id)
+        DO UPDATE SET key_kind = EXCLUDED.key_kind, key_version = EXCLUDED.key_version,
+          prepared_at = EXCLUDED.prepared_at
+      `
+    })
+  }
+}

package/src/pg-action-run-storage.ts

@@ -136,6 +136,29 @@ export class PgActionRunStorage implements ActionRunStorage {
     return row ? rowToActionRunRecord(row) : null
   }
 
+  async getByExecutionIds(params: {
+    readonly projectId: string
+    readonly executionIds: readonly string[]
+  }): Promise<readonly ActionRunRecord[]> {
+    const executionIds = [...new Set(params.executionIds)]
+    if (executionIds.length === 0) {
+      return []
+    }
+
+    const rows = await this.sql<DatabaseRow[]>`
+      SELECT *
+      FROM action_runs
+      WHERE project_id = ${params.projectId}
+        AND execution_id = ANY(${this.sql.array(executionIds)}::text[])
+    `
+
+    const byExecution = new Map(rows.map((row) => [row.execution_id, row]))
+    return executionIds.flatMap((executionId) => {
+      const row = byExecution.get(executionId)
+      return row ? [rowToActionRunRecord(row)] : []
+    })
+  }
+
   async list(input: ListActionRunsInput): Promise<ListActionRunsResult> {
     if ((input.statuses && input.statuses.length === 0) || input.actionIds?.length === 0) {
       return {