@sixb/pg 0.1.11 → 0.1.12

package/src/objects/query-compiler.ts

@@ -7,6 +7,12 @@ import {
   type ObjectQuerySortField,
   type QueryScalarKind,
 } from "@sixb/core"
+import {
+  hasVectorProfile,
+  isVectorProfileQuery,
+  normalizeVector,
+  vectorSearchCandidateLimit,
+} from "@sixb/core/internal/query"
 
 export interface PgObjectQueryPageRow {
   object_type_id: string
@@ -16,6 +22,7 @@ export interface PgObjectQueryPageRow {
 }
 
 export interface CompiledPgObjectQuery {
+  vectorProbe?: { sql: string; args: unknown[]; limit: number }
   sql: string
   args: unknown[]
   totalSql: string
@@ -74,7 +81,8 @@ type CompiledOrderField =
     }
   | {
       kind: "column"
-      column: "object_type_id" | "primary_id"
+      column: "object_type_id" | "primary_id" | "_vector_score"
+      binary?: boolean
       direction: "asc" | "desc"
     }
 
@@ -99,6 +107,12 @@ export function compilePgObjectQuery(
   query: ObjectQuery,
   options: { includeTotal?: boolean; source?: PgObjectQuerySource } = {}
 ): CompiledPgObjectQuery {
+  if (hasVectorProfile(query) && !isVectorProfileQuery(query)) {
+    throw new ObjectQueryExecutionError(
+      "unsupported_vector_composition",
+      "Vector search supports one profile with filters before ranking and limit/project after."
+    )
+  }
   const source = options.source ?? DEFAULT_OBJECT_QUERY_SOURCE
   const compiled = source.wrapQuery(
     compileObjectQueryInternal(projectId, query, {
@@ -110,6 +124,9 @@ export function compilePgObjectQuery(
     ...compiled,
     sql: numberPlaceholders(compiled.sql),
     totalSql: numberPlaceholders(compiled.totalSql),
+    vectorProbe: compiled.vectorProbe
+      ? { ...compiled.vectorProbe, sql: numberPlaceholders(compiled.vectorProbe.sql) }
+      : undefined,
     hasMoreProbe: compiled.hasMoreProbe
       ? {
           ...compiled.hasMoreProbe,
@@ -123,6 +140,7 @@ export function compilePgObjectQuery(
 export interface PgObjectQuerySource {
   readonly objectsTable: string
   readonly linksTable: string
+  readonly objectPropertyPermissionsTable?: string
   /** Wrap a terminal SELECT without its own WITH clause; the selected source owns the only WITH. */
   wrapStatement(
     sql: string,
@@ -263,9 +281,74 @@ function compileObjectQueryInternal(
     case "expand":
       return compileExpand(projectId, query.input, query.expansions, ctx)
     case "vector":
-      throw new Error(
-        `[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`
-      )
+      return compileVector(projectId, query, ctx)
+  }
+}
+
+function compileVector(
+  projectId: string,
+  query: Extract<ObjectQuery, { kind: "vector" }>,
+  ctx: CompileContext
+): CompiledPgObjectQuery {
+  if (
+    typeof query.vector === "string" ||
+    !isVectorProfileQuery(query) ||
+    !query.configuration ||
+    !Number.isSafeInteger(query.k) ||
+    query.k < 1 ||
+    query.k > 1000 ||
+    query.vector.length < 1 ||
+    query.vector.length > 16000
+  ) {
+    throw new ObjectQueryExecutionError(
+      "invalid_vector_query",
+      "A validated named vector profile is required."
+    )
+  }
+  const input = compileObjectQueryInternal(projectId, query.input, exactContext(ctx))
+  const permissions = ctx.source.objectPropertyPermissionsTable
+  const permissionJoin = permissions
+    ? `JOIN (
+      SELECT project_id, object_type_id, primary_id, array_agg(property_id) AS property_ids
+      FROM ${permissions}
+      GROUP BY project_id, object_type_id, primary_id
+    ) AS vector_permissions ON vector_permissions.project_id = vectors.project_id
+      AND vector_permissions.object_type_id = vectors.object_type_id
+      AND vector_permissions.primary_id = vectors.primary_id`
+    : ""
+  const authorized = permissions ? `AND vectors.source <@ vector_permissions.property_ids` : ""
+  const candidates = `FROM (${input.sql}) AS input
+    JOIN object_vectors AS vectors ON vectors.project_id = input.project_id
+      AND vectors.object_type_id = input.object_type_id AND vectors.primary_id = input.primary_id
+    ${permissionJoin}
+    WHERE vectors.profile = ? AND vectors.configuration = ?
+      AND cardinality(vectors.embedding) = ? ${authorized}`
+  const candidateArgs = [...input.args, query.profile!, query.configuration, query.vector.length]
+  // Bound distance work, not just returned rows. Exceeding the envelope fails before ranking.
+  const limit = vectorSearchCandidateLimit(query.vector.length)
+  const values = normalizeVector(query.vector, query.vector.length)
+  const order = compileOrder([
+    { kind: "column", column: "_vector_score", direction: "desc" },
+    ...identityOrderFields().map((field) => ({ ...field, binary: true })),
+  ])
+  const sql = `SELECT * FROM (SELECT input.*, 1 - (vectors.embedding::public.vector OPERATOR(public.<=>) ?::public.vector) AS _vector_score
+    ${candidates}) AS ranked ORDER BY ${order.sql} LIMIT ?`
+  const args = [JSON.stringify(values), ...candidateArgs, query.k]
+  return {
+    sql,
+    args,
+    // Top-k cardinality depends on eligibility, not distances or ranking.
+    totalSql: `SELECT COUNT(*)::bigint AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS eligible`,
+    totalArgs: [...candidateArgs, query.k],
+    order,
+    vectorProbe: {
+      sql: `SELECT COUNT(*)::bigint AS total FROM (SELECT 1 ${candidates} LIMIT ?) AS candidates`,
+      args: [...candidateArgs, limit + 1],
+      limit,
+    },
+    hasMore: () => false,
+    trimRows: identityRows,
+    nextPageToken: () => undefined,
   }
 }
 
@@ -377,6 +460,7 @@ function compileWhere(
       WHERE ${predicate.sql}
     `,
     totalArgs: [...input.args, ...predicate.args],
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: () => false,
     trimRows: identityRows,
@@ -424,7 +508,7 @@ function compileSort(
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${order.sql}
     `,
@@ -462,6 +546,7 @@ function compileLimit(
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: (rowCount, total) =>
       total === undefined ? ctx.probeLimit && rowCount > limit : limit < total,
@@ -499,6 +584,7 @@ function compilePage(
       FROM (${input.sql}) AS input
     `,
     totalArgs: input.args,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMore: (rowCount) => rowCount > pageSize,
     trimRows: (rows) => rows.slice(0, pageSize),
@@ -607,6 +693,7 @@ function compileExpand(
     args: [...expand.args, ...input.args, ...inputOrder.args],
     totalSql: input.totalSql,
     totalArgs: input.totalArgs,
+    vectorProbe: input.vectorProbe,
     order: input.order,
     hasMoreProbe: input.hasMoreProbe,
     hasMore: input.hasMore,
@@ -849,13 +936,14 @@ function compileProject(
         input.created_at,
         input.updated_at,
         input.version,
-        input.last_commit_id
+        input.last_commit_id${input.vectorProbe ? ", input._vector_score" : ""}
       FROM (${input.sql}) AS input
       ORDER BY ${inputOrder.sql}
     `,
     args: [...projection.args, ...input.args, ...inputOrder.args],
     totalSql: input.totalSql,
     totalArgs: input.totalArgs,
+    vectorProbe: input.vectorProbe,
     order: outputOrder,
     hasMoreProbe: input.hasMoreProbe,
     hasMore: input.hasMore,
@@ -909,9 +997,7 @@ function compileAggregateSource(
     case "page":
       return compileRowQueryAggregateSource(projectId, query, source)
     case "vector":
-      throw new Error(
-        `[SixbPg] PostgreSQL object storage does not support query node '${query.kind}'`
-      )
+      return compileRowQueryAggregateSource(projectId, query, source)
   }
 }
 
@@ -1416,7 +1502,9 @@ function compileOrder(
 
   for (const field of fields) {
     if (field.kind === "column") {
-      clauses.push(`${columnExpression(field.column, qualifier)} ${field.direction.toUpperCase()}`)
+      clauses.push(
+        `${columnExpression(field.column, qualifier)}${field.binary ? ' COLLATE "C"' : ""} ${field.direction.toUpperCase()}`
+      )
       continue
     }
 
@@ -1637,7 +1725,10 @@ function compiledPropertyValueExpression(
     : jsonValueExpression(propertyColumn)
 }
 
-function columnExpression(column: "object_type_id" | "primary_id", qualifier?: string): string {
+function columnExpression(
+  column: "object_type_id" | "primary_id" | "_vector_score",
+  qualifier?: string
+): string {
   return qualifier ? `${qualifier}.${column}` : column
 }
 

package/src/objects/read-scope.ts

@@ -18,6 +18,7 @@ export interface PgSelectedObjectReadSource extends PgObjectQuerySource {
  *
  * The complete compiled scope is serialized once. Every statement receives that one JSONB
  * document and the bound project id, keeping the parameter count constant as selections grow.
+ * Group property grants after resolving paths so redaction reads only each object's own grants.
  */
 export function compilePgSelectedObjectReadSource(
   projectId: string,
@@ -43,6 +44,9 @@ export function compilePgSelectedObjectReadSource(
     wrapQuery: (query: CompiledPgObjectQuery): CompiledPgObjectQuery => ({
       ...query,
       ...wrapStatement(query.sql, query.args),
+      vectorProbe: query.vectorProbe
+        ? { ...query.vectorProbe, ...wrapStatement(query.vectorProbe.sql, query.vectorProbe.args) }
+        : undefined,
       totalSql: `${compiled.sql}\n${query.totalSql}`,
       totalArgs: [...compiled.args, ...query.totalArgs],
       ...(query.hasMoreProbe
@@ -177,32 +181,29 @@ function compileSelectedReadScopeCte(scopeJson: string, projectId: string): Comp
         SELECT DISTINCT project_id, object_type_id, primary_id
         FROM _sixb_scope_reachable
       ),
+      _sixb_scope_object_grants AS (
+        SELECT reachable.project_id, reachable.object_type_id, reachable.primary_id,
+          array_agg(DISTINCT selected_property.value) FILTER (WHERE selected_property.value IS NOT NULL) AS property_ids
+        FROM _sixb_scope_reachable AS reachable
+        LEFT JOIN _sixb_scope_object_selections AS selection
+          ON selection.node_id = reachable.node_id
+         AND selection.object_type_id = reachable.object_type_id
+        LEFT JOIN LATERAL jsonb_array_elements_text(selection.property_ids) AS selected_property(value) ON true
+        GROUP BY reachable.project_id, reachable.object_type_id, reachable.primary_id
+      ),
       _sixb_scope_objects AS (
-        SELECT
-          stored.project_id,
-          stored.object_type_id,
-          stored.primary_id,
-          COALESCE(
-            (
-              SELECT jsonb_object_agg(property.key, property.value)
-              FROM jsonb_each(stored.properties) AS property(key, value)
-              JOIN _sixb_scope_object_permissions AS permission
-                ON permission.project_id = stored.project_id
-               AND permission.object_type_id = stored.object_type_id
-               AND permission.primary_id = stored.primary_id
-               AND permission.property_id = property.key
-            ),
-            '{}'::jsonb
-          ) AS properties,
-          stored.created_at,
-          stored.updated_at,
-          stored.version,
-          stored.last_commit_id
-        FROM objects AS stored
-        JOIN _sixb_scope_object_ids AS visible
-          ON visible.project_id = stored.project_id
-         AND visible.object_type_id = stored.object_type_id
-         AND visible.primary_id = stored.primary_id
+        SELECT stored.project_id, stored.object_type_id, stored.primary_id,
+          COALESCE((
+            SELECT jsonb_object_agg(property.key, property.value)
+            FROM jsonb_each(stored.properties) AS property(key, value)
+            WHERE property.key = ANY(grants.property_ids)
+          ), '{}'::jsonb) AS properties,
+          stored.created_at, stored.updated_at, stored.version, stored.last_commit_id
+        FROM _sixb_scope_object_grants AS grants
+        JOIN objects AS stored
+          ON stored.project_id = grants.project_id
+         AND stored.object_type_id = grants.object_type_id
+         AND stored.primary_id = grants.primary_id
       ),
       _sixb_scope_reached_links(
         project_id,

package/src/objects/reader.ts

@@ -1,4 +1,5 @@
-import type { ObjectQuery } from "@sixb/core"
+import { type ObjectQuery, ObjectQueryExecutionError } from "@sixb/core"
+import { hasVectorProfile } from "@sixb/core/internal/query"
 import type {
   CountObjectsInput,
   CountObjectsResult,
@@ -51,7 +52,35 @@ export class PgObjectReader {
     private readonly source: PgObjectQuerySource | PgSelectedObjectReadSource
   ) {}
 
+  private async assertVectorSearch(
+    params: QueryObjectsInput | CountObjectsInput | ExistsObjectsInput | FacetObjectsInput
+  ): Promise<void> {
+    if (!hasVectorProfile(params.query)) return
+    const compiled = compilePgObjectQuery(params.projectId, params.query, { source: this.source })
+    if (!compiled.vectorProbe) return
+    const extensions = await this.sql.unsafe<{ ready: boolean }[]>(
+      "SELECT EXISTS (SELECT 1 FROM pg_extension e JOIN pg_namespace n ON n.oid = e.extnamespace WHERE e.extname = 'vector' AND n.nspname = 'public') AS ready"
+    )
+    if (!extensions[0]?.ready)
+      throw new ObjectQueryExecutionError(
+        "vector_extension_missing",
+        "PostgreSQL vector search requires pgvector installed in schema public (CREATE EXTENSION vector WITH SCHEMA public)."
+      )
+    const probe = compiled.vectorProbe
+    const [row] = await this.sql.unsafe<{ total: string | number }[]>(
+      probe.sql,
+      probe.args as SqlParameter[]
+    )
+    if (Number(row?.total ?? 0) > probe.limit) {
+      throw new ObjectQueryExecutionError(
+        "vector_work_limit_exceeded",
+        `Exact vector search supports at most ${probe.limit} eligible vectors at this dimension. Narrow the query filters.`
+      )
+    }
+  }
+
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const compiled = compilePgObjectQuery(params.projectId, params.query, {
@@ -85,6 +114,7 @@ export class PgObjectReader {
   }
 
   async countObjects(params: CountObjectsInput): Promise<CountObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const compiled = compilePgObjectCountQuery(params.projectId, stripOuterRowShape(params.query), {
@@ -98,6 +128,7 @@ export class PgObjectReader {
   }
 
   async existsObjects(params: ExistsObjectsInput): Promise<ExistsObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const compiled = compilePgObjectExistsQuery(
@@ -110,6 +141,7 @@ export class PgObjectReader {
   }
 
   async facetObjects(params: FacetObjectsInput): Promise<FacetObjectsResult> {
+    await this.assertVectorSearch(params)
     const sql = this.sql
     const source = this.source
     const facets: ObjectFacetResult[] = []

package/src/objects/rows.ts

@@ -23,7 +23,10 @@ export function rowToObject(row: ObjectDatabaseRow): ObjectRow {
 // base columns map as usual; `_expand` (a `jsonb_build_object`) is revived into
 // the runtime link shape the core executor's fallback also produces.
 export function queryRowToObject(row: ObjectQueryDatabaseRow): ObjectRow {
-  const base = rowToObject(row)
+  const base = {
+    ...rowToObject(row),
+    ...(row._vector_score === undefined ? {} : { score: row._vector_score }),
+  }
   const links = reviveExpandedLinks(row._expand)
   return links ? { ...base, links } : base
 }
@@ -109,6 +112,7 @@ export interface ObjectDatabaseRow {
 }
 
 export interface ObjectQueryDatabaseRow extends ObjectDatabaseRow {
+  _vector_score?: number
   _cursor_properties?: unknown
   /** `jsonb_build_object(linkId, value, ...)` from an `expand` pushdown; absent otherwise. */
   _expand?: unknown

package/src/objects/storage.ts

@@ -1,3 +1,4 @@
+import { hasVectorProfile } from "@sixb/core/internal/query"
 import type {
   CompiledSelectedObjectReadScope,
   CountObjectsInput,
@@ -21,7 +22,7 @@ import type {
   QueryObjectsResult,
 } from "@sixb/core/storage"
 import type { SQLClient, SqlParameter } from "../pg-client"
-import type { PgStoreClient } from "../transactions"
+import { type PgStoreClient, runPgRepeatableReadTransaction } from "../transactions"
 import { DEFAULT_OBJECT_QUERY_SOURCE } from "./query-compiler"
 import { assertLinkQueryLimit, PgObjectReader } from "./reader"
 import {
@@ -43,6 +44,7 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     refs: true,
     filter: true,
     text: true,
+    vector: true,
     sort: true,
     limit: true,
     page: true,
@@ -95,7 +97,7 @@ const PG_OBJECT_QUERY_CAPABILITIES: ObjectQueryCapabilities = {
     "PostgreSQL object query pushdown supports start/refs/filter/text/sort/limit/page/traverse/set/project/expand over JSONB properties and object links.",
     "expand hydrates linked objects in-database (top-N per parent via LATERAL + jsonb_agg); core resolves each expansion's cardinality before pushdown, and a mixed/unresolved one stays on the fallback.",
     "Exact decimal predicates, ordering, and keyset pagination use PostgreSQL numeric casts.",
-    "Relevance sorting, vector search, and unresolved start.includeSubtypes remain planner fallback or rejection cases.",
+    "Relevance sorting and unresolved start.includeSubtypes remain planner fallback or rejection cases.",
   ],
 }
 
@@ -120,18 +122,34 @@ export class PgObjectStorage implements ObjectStorage {
   }
 
   async queryObjects(params: QueryObjectsInput): Promise<QueryObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).queryObjects(params)
+      )
     return this.reader.queryObjects(params)
   }
 
   async countObjects(params: CountObjectsInput): Promise<CountObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).countObjects(params)
+      )
     return this.reader.countObjects(params)
   }
 
   async existsObjects(params: ExistsObjectsInput): Promise<ExistsObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).existsObjects(params)
+      )
     return this.reader.existsObjects(params)
   }
 
   async facetObjects(params: FacetObjectsInput): Promise<FacetObjectsResult> {
+    if (hasVectorProfile(params.query))
+      return runPgRepeatableReadTransaction(this.sql, (tx) =>
+        new PgObjectReader(tx, DEFAULT_OBJECT_QUERY_SOURCE).facetObjects(params)
+      )
     return this.reader.facetObjects(params)
   }
 

package/src/ontology-storage/index.ts

@@ -6,12 +6,16 @@ import { PgOntologyMaterializationStorage } from "./materializations"
 import { PgOntologyOutboxStorage } from "./outbox"
 import type { PgRootOperation } from "./shared"
 import { PgOntologySourceStorage } from "./sources"
+import { PgVectorIndexingStorage } from "./vector-indexing"
+import { PgOntologyVectorStorage } from "./vectors"
 
 export class PgOntologyStorage implements OntologyStorage {
   readonly commits: PgOntologyCommitStorage
   readonly sources: PgOntologySourceStorage
   readonly materializations: PgOntologyMaterializationStorage
   readonly outbox: PgOntologyOutboxStorage
+  readonly vectorIndexing: PgVectorIndexingStorage
+  readonly vectors: PgOntologyVectorStorage
 
   constructor(input: {
     readonly sql: SQLClient
@@ -25,6 +29,17 @@ export class PgOntologyStorage implements OntologyStorage {
       input.transactionContext
     )
     this.outbox = new PgOntologyOutboxStorage(input.runRootOperation)
+    this.vectorIndexing = new PgVectorIndexingStorage(
+      input.sql,
+      input.runRootOperation,
+      (session, projectId) => this.materializations.assertVectorSession(session, projectId)
+    )
+    this.vectors = new PgOntologyVectorStorage(
+      input.sql,
+      input.runRootOperation,
+      (session, projectId, commitId) =>
+        this.materializations.assertVectorSession(session, projectId, commitId)
+    )
   }
 
   deactivateSessions(): void {

package/src/ontology-storage/materializations.ts

@@ -9,6 +9,7 @@ import {
   linkRefSortKey,
   linkScopeSortKey,
   MaterializationConflictError,
+  MaterializationValidationError,
   objectRefKey,
   objectRefSortKey,
   telemetryPointKey,
@@ -100,6 +101,18 @@ export class PgOntologyMaterializationStorage implements OntologyMaterialization
     this.writer = new PgMaterializationWriter(sql)
   }
 
+  assertVectorSession(session: MaterializationSession, projectId: string, commitId?: string): void {
+    const active = this.sessions.require(session)
+    if (
+      active.header.commit.projectId !== projectId ||
+      (commitId !== undefined && active.header.commit.id !== commitId)
+    ) {
+      throw new MaterializationValidationError(
+        "Vector mutation does not belong to this materialization session."
+      )
+    }
+  }
+
   async begin(input: MaterializationPlanHeader): Promise<MaterializationSession> {
     assertMaterializationHeader(input)
     const session = await this.sessions.create(input)

package/src/ontology-storage/vector-indexing.ts

@@ -0,0 +1,168 @@
+import { parseSixbFailure } from "@sixb/core/internal/errors"
+import {
+  type MaterializationSession,
+  type OntologyVectorIndexingStorage,
+  VECTOR_INDEXING_FAILURE_CODES,
+  type VectorIndexingRequest,
+  type VectorIndexingWork,
+} from "@sixb/core/storage"
+import type { SQLClient } from "../pg-client"
+import { jsonParameter as json, type PgRootOperation } from "./shared"
+
+interface WorkRow {
+  batch_id: string | null
+  request: VectorIndexingRequest
+  status: VectorIndexingWork["status"]
+  available_at: Date | string
+  values_json: number[] | null
+  error: string | null
+}
+
+export class PgVectorIndexingStorage implements OntologyVectorIndexingStorage {
+  constructor(
+    private readonly sql: SQLClient,
+    private readonly run: PgRootOperation,
+    private readonly assertSession: (session: MaterializationSession, projectId: string) => void
+  ) {}
+
+  async schedule(input: Parameters<OntologyVectorIndexingStorage["schedule"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    if (input.deleted.length)
+      await this.sql`
+      DELETE FROM object_vector_indexing AS work
+      USING jsonb_array_elements(${json(this.sql, input.deleted)}::jsonb) AS deleted(ref)
+      WHERE work.project_id = ${input.projectId}
+        AND work.object_type_id = deleted.ref->>'objectTypeId'
+        AND work.primary_id = deleted.ref->>'primaryId'
+    `
+    if (input.requests.length)
+      await this.sql`
+      INSERT INTO object_vector_indexing (
+        project_id, id, object_type_id, primary_id, profile, batch_id, request, status, available_at, dispatch_at
+      )
+      SELECT ${input.projectId}, entry->>'id', entry#>>'{ref,objectTypeId}',
+        entry#>>'{ref,primaryId}', entry->>'profile', entry->>'batchId', entry - 'batchId', 'pending',
+        ${input.availableAt}::timestamptz, ${input.availableAt}::timestamptz
+      FROM jsonb_array_elements(${json(this.sql, input.requests)}::jsonb) AS pending(entry)
+      ON CONFLICT (project_id, object_type_id, primary_id, profile) DO UPDATE SET
+        id = EXCLUDED.id, batch_id = EXCLUDED.batch_id, request = EXCLUDED.request, status = 'pending',
+        available_at = EXCLUDED.available_at, dispatch_at = EXCLUDED.dispatch_at,
+        values_json = NULL, error = NULL
+    `
+  }
+  async complete(input: Parameters<OntologyVectorIndexingStorage["complete"]>[0]) {
+    this.assertSession(input.session, input.projectId)
+    if (!input.entries.length) return
+    await this.sql`
+      DELETE FROM object_vector_indexing AS work
+      USING jsonb_array_elements(${json(this.sql, input.entries)}::jsonb) AS completed(entry)
+      WHERE work.project_id = ${input.projectId}
+        AND work.object_type_id = entry#>>'{ref,objectTypeId}'
+        AND work.primary_id = entry#>>'{ref,primaryId}'
+        AND work.profile = entry->>'profile'
+        AND work.request->>'configuration' = entry->>'configuration'
+        AND work.request->>'sourceFingerprint' = entry->>'sourceFingerprint'
+    `
+  }
+
+  async dispatched(input: Parameters<OntologyVectorIndexingStorage["dispatched"]>[0]) {
+    if (!input.ids.length) return
+    await this.run(async (sql) => {
+      await sql`UPDATE object_vector_indexing SET dispatch_at = ${input.nextDispatchAt} WHERE project_id = ${input.projectId} AND id = ANY(${sql.array([...input.ids])}::text[])`
+    })
+  }
+  async get(input: Parameters<OntologyVectorIndexingStorage["get"]>[0]) {
+    return this.run(async (sql) => {
+      const rows = await sql<
+        WorkRow[]
+      >`SELECT batch_id, request, status, available_at, values_json, error FROM object_vector_indexing WHERE project_id = ${input.projectId} AND id = ${input.id}`
+      return rows[0] ? decode(rows[0]) : null
+    })
+  }
+  async getBatch(input: Parameters<OntologyVectorIndexingStorage["getBatch"]>[0]) {
+    return this.run(async (sql) =>
+      (
+        await sql<WorkRow[]>`
+      SELECT batch_id, request, status, available_at, values_json, error
+      FROM object_vector_indexing WHERE project_id = ${input.projectId}
+      AND batch_id = ${input.batchId} ORDER BY id`
+      ).map(decode)
+    )
+  }
+
+  async getBatchMember(input: Parameters<OntologyVectorIndexingStorage["getBatchMember"]>[0]) {
+    return this.run(async (sql) => {
+      const rows = await sql<WorkRow[]>`
+        SELECT batch_id, request, status, available_at, values_json, error
+        FROM object_vector_indexing WHERE project_id = ${input.projectId}
+        AND object_type_id = ${input.ref.objectTypeId} AND primary_id = ${input.ref.primaryId}
+        AND profile = ${input.profile} AND batch_id = ${input.batchId}`
+      return rows[0] ? decode(rows[0]) : null
+    })
+  }
+
+  async updateBatch(input: Parameters<OntologyVectorIndexingStorage["updateBatch"]>[0]) {
+    if (!input.updates.length) return true
+    return this.run(async (sql) => {
+      const rows = await sql<{ id: string }[]>`
+        WITH changes AS MATERIALIZED (
+          SELECT item FROM jsonb_array_elements(${json(sql, input.updates)}::jsonb) AS entries(item)
+        ), locked AS MATERIALIZED (
+          SELECT work.id FROM object_vector_indexing AS work
+          JOIN changes ON work.id = item->>'id' AND work.status = item->>'expectedStatus'
+          WHERE work.project_id = ${input.projectId} ORDER BY work.id FOR UPDATE OF work
+        )
+        UPDATE object_vector_indexing AS work SET
+          status = changes.item->>'status', available_at = (changes.item->>'availableAt')::timestamptz,
+          values_json = COALESCE(changes.item->'values', work.values_json),
+          error = (changes.item->'error')::text
+        FROM changes, locked
+        WHERE work.project_id = ${input.projectId} AND work.id = locked.id
+          AND work.id = changes.item->>'id'
+          AND (${!input.requireAll} OR (SELECT count(*) FROM locked) = ${input.updates.length})
+        RETURNING work.id`
+      return !input.requireAll || rows.length === input.updates.length
+    })
+  }
+
+  async listDue(input: Parameters<OntologyVectorIndexingStorage["listDue"]>[0]) {
+    return this.run(async (sql) =>
+      (
+        await sql<
+          WorkRow[]
+        >`SELECT batch_id, request, status, available_at, NULL AS values_json, error FROM object_vector_indexing WHERE project_id = ${input.projectId} AND status <> 'failed' AND dispatch_at <= ${input.now} ORDER BY dispatch_at, id LIMIT ${input.limit}`
+      ).map(decode)
+    )
+  }
+  async update(input: Parameters<OntologyVectorIndexingStorage["update"]>[0]) {
+    return this.run(
+      async (sql) =>
+        (
+          await sql`
+      UPDATE object_vector_indexing SET status = ${input.status}, available_at = ${input.availableAt},
+      values_json = COALESCE(${input.values ? json(sql, input.values) : null}, values_json), error = ${input.error ? JSON.stringify(input.error) : null}
+      WHERE project_id = ${input.projectId} AND id = ${input.id} AND status = ${input.expectedStatus} RETURNING id
+    `
+        ).length === 1
+    )
+  }
+  async remove(input: Parameters<OntologyVectorIndexingStorage["remove"]>[0]) {
+    await this.run(async (sql) => {
+      await sql`DELETE FROM object_vector_indexing WHERE project_id = ${input.projectId} AND id = ${input.id}`
+    })
+  }
+}
+function decode(row: WorkRow): VectorIndexingWork {
+  return {
+    ...row.request,
+    ...(row.batch_id ? { batchId: row.batch_id } : {}),
+    status: row.status,
+    availableAt: new Date(row.available_at).toISOString(),
+    ...(row.values_json ? { values: row.values_json } : {}),
+    ...(row.error
+      ? {
+          error: parseSixbFailure(row.error, VECTOR_INDEXING_FAILURE_CODES),
+        }
+      : {}),
+  }
+}