@sixb/pg 0.1.20 → 0.1.22

package/src/migrations/078-agent-approvals.sql

@@ -0,0 +1,58 @@
+-- Calls of the Agent that wait for whoever asked for the turn. A call's run id is its key: a
+-- thread holds at most one pending, approved or denied approval per key, and a cancelled,
+-- superseded or expired one lets the same call ask again.
+CREATE TABLE agent_approvals (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL CHECK (length(trim(id)) > 0),
+  thread_id TEXT NOT NULL,
+  run_id TEXT NOT NULL CHECK (length(run_id) > 0),
+  caller_run_id TEXT NOT NULL CHECK (length(caller_run_id) > 0),
+  requested_by_type TEXT NOT NULL CHECK (requested_by_type IN ('user', 'serviceAccount', 'system')),
+  requested_by_id TEXT NOT NULL CHECK (length(requested_by_id) > 0),
+  mode TEXT NOT NULL CHECK (mode IN ('manual', 'accept-edits')),
+  call_key TEXT NOT NULL CHECK (length(call_key) > 0),
+  call JSONB NOT NULL,
+  status TEXT NOT NULL
+    CHECK (status IN ('pending', 'approved', 'denied', 'cancelled', 'superseded', 'expired')),
+  created_at TIMESTAMPTZ NOT NULL,
+  expires_at TIMESTAMPTZ NOT NULL,
+  decided_at TIMESTAMPTZ,
+  decided_by_type TEXT CHECK (decided_by_type IN ('user', 'serviceAccount', 'system')),
+  decided_by_id TEXT,
+  outcome JSONB,
+  reported_in_message_id TEXT,
+  PRIMARY KEY (project_id, id),
+  FOREIGN KEY (project_id, thread_id) REFERENCES agent_threads (project_id, id) ON DELETE CASCADE
+);
+
+CREATE UNIQUE INDEX idx_agent_approvals_live_call
+  ON agent_approvals (project_id, thread_id, call_key)
+  WHERE status IN ('pending', 'approved', 'denied');
+
+CREATE INDEX idx_agent_approvals_thread ON agent_approvals (project_id, thread_id, created_at);
+CREATE INDEX idx_agent_approvals_run ON agent_approvals (project_id, run_id, status);
+CREATE INDEX idx_agent_approvals_caller_run ON agent_approvals (project_id, caller_run_id, status);
+CREATE INDEX idx_agent_approvals_requester
+  ON agent_approvals (project_id, requested_by_type, requested_by_id, status);
+
+-- What each user lets the Agent change without asking: a default, then their own choice in a
+-- thread. Absent rows fall back, in that order.
+CREATE TABLE agent_user_settings (
+  project_id TEXT NOT NULL,
+  principal_type TEXT NOT NULL CHECK (principal_type IN ('user', 'serviceAccount', 'system')),
+  principal_id TEXT NOT NULL CHECK (length(principal_id) > 0),
+  approval_mode TEXT NOT NULL CHECK (approval_mode IN ('manual', 'accept-edits', 'auto')),
+  updated_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, principal_type, principal_id)
+);
+
+CREATE TABLE agent_thread_user_settings (
+  project_id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  principal_type TEXT NOT NULL CHECK (principal_type IN ('user', 'serviceAccount', 'system')),
+  principal_id TEXT NOT NULL CHECK (length(principal_id) > 0),
+  approval_mode TEXT NOT NULL CHECK (approval_mode IN ('manual', 'accept-edits', 'auto')),
+  updated_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, thread_id, principal_type, principal_id),
+  FOREIGN KEY (project_id, thread_id) REFERENCES agent_threads (project_id, id) ON DELETE CASCADE
+);

package/src/migrations/079-agent-approval-resume.sql

@@ -0,0 +1,20 @@
+-- A paused Agent turn resumes once its requester decided on every call it held. What that needs:
+-- the mode "Always allow" raised the turn to, whether the turn may still resume on a call, and the
+-- claim a process takes before it runs an approved call left without its outcome.
+ALTER TABLE agent_approvals
+  ADD COLUMN raised_mode TEXT CHECK (raised_mode IN ('manual', 'accept-edits', 'auto')),
+  ADD COLUMN turn_stopped_at TIMESTAMPTZ,
+  ADD COLUMN execution_claimed_at TIMESTAMPTZ;
+
+-- The repair pass: calls past their time, approved calls without an outcome, and decided calls of
+-- turns that may still resume. Each index covers only the rows that are still work.
+CREATE INDEX idx_agent_approvals_due
+  ON agent_approvals (project_id, expires_at)
+  WHERE status = 'pending';
+CREATE INDEX idx_agent_approvals_unfinished
+  ON agent_approvals (project_id, created_at, id)
+  WHERE status = 'approved' AND outcome IS NULL;
+CREATE INDEX idx_agent_approvals_resumable
+  ON agent_approvals (project_id, created_at, id)
+  WHERE status IN ('approved', 'denied') AND reported_in_message_id IS NULL
+    AND turn_stopped_at IS NULL;

package/src/migrations/080-subagent-threads.sql

@@ -0,0 +1,145 @@
+-- A sub-agent works in a thread of its own: its task and its work are that thread's messages, and
+-- each of its runs has the thread and a trigger message, as a turn does. The thread's parent is the
+-- conversation, which every read of it goes through, and its spawning turn and key name it.
+ALTER TABLE agent_threads
+  ADD COLUMN kind TEXT NOT NULL DEFAULT 'conversation'
+    CHECK (kind IN ('conversation', 'subagent')),
+  ADD COLUMN parent_thread_id TEXT,
+  ADD COLUMN parent_run_id TEXT,
+  ADD COLUMN spawn_key TEXT,
+  ADD CONSTRAINT agent_threads_kind_fields CHECK (
+    (
+      kind = 'conversation'
+      AND parent_thread_id IS NULL
+      AND parent_run_id IS NULL
+      AND spawn_key IS NULL
+    )
+    OR
+    (
+      kind = 'subagent'
+      AND parent_thread_id IS NOT NULL
+      AND parent_run_id IS NOT NULL
+      AND spawn_key IS NOT NULL
+      AND sandbox_params IS NULL
+    )
+  ),
+  -- A conversation's sub-agent threads go with it.
+  ADD CONSTRAINT fk_agent_threads_parent
+    FOREIGN KEY (project_id, parent_thread_id)
+    REFERENCES agent_threads (project_id, id)
+    ON DELETE CASCADE,
+  ADD CONSTRAINT fk_agent_threads_parent_run
+    FOREIGN KEY (project_id, parent_run_id)
+    REFERENCES agent_runs (project_id, id)
+    ON DELETE RESTRICT,
+  ADD CONSTRAINT uq_agent_threads_spawn UNIQUE (project_id, parent_run_id, spawn_key);
+
+ALTER TABLE agent_runs DROP CONSTRAINT agent_runs_kind_fields;
+
+-- The children admitted before this have no thread. Each gets one named as a new child's is, with
+-- its task as the only message: what it answered stays in its parent's `wait_agent` output.
+CREATE TEMPORARY TABLE legacy_subagent_threads ON COMMIT DROP AS
+SELECT
+  child.project_id,
+  child.id AS run_id,
+  'agt_thr_child_' || regexp_replace(child.id, '^agt_run_child_', '') AS thread_id,
+  'agt_msg_child_' || regexp_replace(child.id, '^agt_run_child_', '') AS message_id
+FROM agent_runs AS child
+WHERE child.kind = 'subagent' AND child.thread_id IS NULL;
+
+INSERT INTO agent_threads (
+  project_id, id, kind, parent_thread_id, parent_run_id, spawn_key, owner_principal_type,
+  owner_principal_id, status, active_run_id, last_message_at, message_count, created_at,
+  updated_at
+)
+SELECT
+  child.project_id,
+  legacy.thread_id,
+  'subagent',
+  parent.thread_id,
+  child.parent_run_id,
+  child.spawn_key,
+  conversation.owner_principal_type,
+  conversation.owner_principal_id,
+  'active',
+  CASE WHEN child.status IN ('queued', 'running') THEN child.id END,
+  child.created_at,
+  1,
+  child.created_at,
+  COALESCE(child.completed_at, child.created_at)
+FROM legacy_subagent_threads AS legacy
+JOIN agent_runs AS child ON child.project_id = legacy.project_id AND child.id = legacy.run_id
+JOIN agent_runs AS parent
+  ON parent.project_id = child.project_id AND parent.id = child.parent_run_id
+JOIN agent_threads AS conversation
+  ON conversation.project_id = parent.project_id AND conversation.id = parent.thread_id;
+
+INSERT INTO agent_messages (
+  project_id, id, thread_id, run_id, role, seq, parts, content_version, created_at
+)
+SELECT
+  child.project_id,
+  legacy.message_id,
+  legacy.thread_id,
+  child.id,
+  'user',
+  1,
+  jsonb_build_array(jsonb_build_object('type', 'text', 'text', child.spec->>'task')),
+  2,
+  child.created_at
+FROM legacy_subagent_threads AS legacy
+JOIN agent_runs AS child ON child.project_id = legacy.project_id AND child.id = legacy.run_id;
+
+UPDATE agent_runs AS child
+SET thread_id = legacy.thread_id, trigger_message_id = legacy.message_id
+FROM legacy_subagent_threads AS legacy
+WHERE child.project_id = legacy.project_id AND child.id = legacy.run_id;
+
+DROP TABLE legacy_subagent_threads;
+
+ALTER TABLE agent_runs ADD CONSTRAINT agent_runs_kind_fields CHECK (
+  (
+    kind = 'conversation'
+    AND thread_id IS NOT NULL
+    AND trigger_message_id IS NOT NULL
+    AND parent_run_id IS NULL
+    AND spawn_key IS NULL
+    AND result IS NULL
+  )
+  OR
+  (
+    kind = 'subagent'
+    AND thread_id IS NOT NULL
+    AND trigger_message_id IS NOT NULL
+    AND parent_run_id IS NOT NULL
+    AND spawn_key IS NOT NULL
+    AND spec IS NOT NULL
+  )
+);
+
+-- Lists read conversations only, so a conversation's children never weigh on them.
+DROP INDEX idx_agent_threads_project_activity;
+DROP INDEX idx_agent_threads_project_status_activity;
+DROP INDEX idx_agent_threads_project_owner_activity;
+
+CREATE INDEX idx_agent_threads_project_activity
+  ON agent_threads (project_id, (COALESCE(last_message_at, created_at)) DESC, id DESC)
+  WHERE kind = 'conversation';
+CREATE INDEX idx_agent_threads_project_status_activity
+  ON agent_threads (project_id, status, (COALESCE(last_message_at, created_at)) DESC, id DESC)
+  WHERE kind = 'conversation';
+CREATE INDEX idx_agent_threads_project_owner_activity
+  ON agent_threads (
+    project_id,
+    owner_principal_type,
+    owner_principal_id,
+    (COALESCE(last_message_at, created_at)) DESC,
+    id DESC
+  )
+  WHERE kind = 'conversation';
+
+-- A conversation's children, in the order they were spawned. Only a child has a parent, so the
+-- index holds children only, and a read by `parent_thread_id` can use it.
+CREATE INDEX idx_agent_threads_children
+  ON agent_threads (project_id, parent_thread_id, created_at, id)
+  WHERE parent_thread_id IS NOT NULL;

package/src/migrations/081-subagent-questions.sql

@@ -0,0 +1,6 @@
+-- A child that pauses on its question waits for a later turn of its parent's conversation to
+-- answer it. Each turn reads which of the conversation's children wait so: few do, so a partial
+-- index keeps that read small however many children the conversation had.
+CREATE INDEX idx_agent_runs_paused_on_question
+  ON agent_runs (project_id, parent_run_id)
+  WHERE kind = 'subagent' AND finish_reason = 'awaiting_answer';

package/src/migrations.ts

@@ -433,6 +433,25 @@ export const postgresStorageMigrations = defineMigrations<PostgresMigrationConte
     pgSql("060-drained-source-versions", drainedSourceVersionsSql),
     pgSql("061-terminal-action-runs", terminalActionRunsSql),
     pgSql("062-drop-auth-audience", dropAuthAudienceSql),
+    pgSql("063-artifacts", artifactsSql),
+    pgSql("064-drop-output-diagnostics", dropOutputDiagnosticsSql),
+    pgSql("065-plan-work-payload-statistics", planWorkPayloadStatisticsSql),
+    pgSql("066-activity", activitySql),
+    pgSql("067-activity-timeline", activityTimelineSql),
+    pgSql("068-activity-interactions", activityInteractionsSql),
+    pgSql("069-artifact-kinds", artifactKindsSql),
+    pgSql("070-artifact-state", artifactStateSql),
+    pgSql("071-agent-thread-participants", agentThreadParticipantsSql),
+    pgSql("072-forked-context-checkpoints", forkedContextCheckpointsSql),
+    pgSql("073-unique-values", uniqueValuesSql),
+    pgSql("074-generated-media-usage", generatedMediaUsageSql),
+    pgSql("075-model-call-files", modelCallFilesSql),
+    pgSql("076-agent-memory", agentMemorySql),
+    pgSql("077-artifact-threads", artifactThreadsSql),
+    pgSql("078-agent-approvals", agentApprovalsSql),
+    pgSql("079-agent-approval-resume", agentApprovalResumeSql),
+    pgSql("080-subagent-threads", subagentThreadsSql),
+    pgSql("081-subagent-questions", subagentQuestionsSql),
   ],
 })
 
@@ -463,3 +482,36 @@ import drainedSourceVersionsSql from "./migrations/060-drained-source-versions.s
 }
 import terminalActionRunsSql from "./migrations/061-terminal-action-runs.sql" with { type: "text" }
 import dropAuthAudienceSql from "./migrations/062-drop-auth-audience.sql" with { type: "text" }
+import artifactsSql from "./migrations/063-artifacts.sql" with { type: "text" }
+import dropOutputDiagnosticsSql from "./migrations/064-drop-output-diagnostics.sql" with {
+  type: "text",
+}
+import planWorkPayloadStatisticsSql from "./migrations/065-plan-work-payload-statistics.sql" with {
+  type: "text",
+}
+import activitySql from "./migrations/066-activity.sql" with { type: "text" }
+import activityTimelineSql from "./migrations/067-activity-timeline.sql" with { type: "text" }
+import activityInteractionsSql from "./migrations/068-activity-interactions.sql" with {
+  type: "text",
+}
+import artifactKindsSql from "./migrations/069-artifact-kinds.sql" with { type: "text" }
+import artifactStateSql from "./migrations/070-artifact-state.sql" with { type: "text" }
+import agentThreadParticipantsSql from "./migrations/071-agent-thread-participants.sql" with {
+  type: "text",
+}
+import forkedContextCheckpointsSql from "./migrations/072-forked-context-checkpoints.sql" with {
+  type: "text",
+}
+import uniqueValuesSql from "./migrations/073-unique-values.sql" with { type: "text" }
+import generatedMediaUsageSql from "./migrations/074-generated-media-usage.sql" with {
+  type: "text",
+}
+import modelCallFilesSql from "./migrations/075-model-call-files.sql" with { type: "text" }
+import agentMemorySql from "./migrations/076-agent-memory.sql" with { type: "text" }
+import artifactThreadsSql from "./migrations/077-artifact-threads.sql" with { type: "text" }
+import agentApprovalsSql from "./migrations/078-agent-approvals.sql" with { type: "text" }
+import agentApprovalResumeSql from "./migrations/079-agent-approval-resume.sql" with {
+  type: "text",
+}
+import subagentThreadsSql from "./migrations/080-subagent-threads.sql" with { type: "text" }
+import subagentQuestionsSql from "./migrations/081-subagent-questions.sql" with { type: "text" }

package/src/objects/conditional-reader.ts

@@ -0,0 +1,44 @@
+import type { ObjectQuery } from "@sixb/core"
+import { hasVectorProfile } from "@sixb/core/internal/query"
+import type {
+  CompiledConditionalObjectReadScope,
+  ObjectQueryCapabilities,
+  ObjectReadStorage,
+} from "@sixb/core/storage"
+import { type PgStoreClient, runPgRepeatableReadTransaction } from "../transactions"
+import type { PgAggregateAdmission } from "./aggregate-admission"
+import { compilePgConditionalObjectReadSource } from "./read-scope"
+import { PgObjectReader } from "./reader"
+import { createPgScopedReader } from "./scoped-reader"
+
+/**
+ * Read objects and links through relations that apply the scope's conditions as they are read.
+ *
+ * Reads run as unscoped ones do, under the same aggregate admission: on the pool, and a vector
+ * query on one repeatable-read snapshot for its candidate probe and its rows.
+ */
+export function createPgConditionalReader(
+  sql: PgStoreClient,
+  params: {
+    projectId: string
+    scope: CompiledConditionalObjectReadScope
+  },
+  options: {
+    aggregateAdmission?: PgAggregateAdmission
+    queryCapabilities: () => ObjectQueryCapabilities
+  }
+): ObjectReadStorage {
+  const source = compilePgConditionalObjectReadSource(params.projectId, params.scope)
+  const reader = new PgObjectReader(sql, source, options.aggregateAdmission)
+
+  return createPgScopedReader(
+    {
+      projectId: params.projectId,
+      read: (run, query?: ObjectQuery) =>
+        query && hasVectorProfile(query)
+          ? runPgRepeatableReadTransaction(sql, (tx) => run(new PgObjectReader(tx, source)))
+          : run(reader),
+    },
+    options.queryCapabilities
+  )
+}

package/src/objects/prepare-queries.ts

@@ -59,7 +59,7 @@ function preparationFingerprint(plan: ObjectQueryPreparationPlan): string {
     .sort((a, b) => a.objectTypeId.localeCompare(b.objectTypeId))
 
   // Bump the version when physical generation changes, even if the ontology stays the same.
-  const definition = { version: 1, projectId: plan.projectId, objectTypes }
+  const definition = { version: 2, projectId: plan.projectId, objectTypes }
   return createHash("sha256").update(JSON.stringify(definition)).digest("hex")
 }
 

package/src/objects/query-compiler.ts

@@ -181,6 +181,12 @@ export interface PgObjectQuerySource {
   readonly objectsTable: string
   readonly linksTable: string
   readonly objectPropertyPermissionsTable?: string
+  /**
+   * Where to read one concrete type's objects, when the source can say it more precisely than
+   * `objectsTable`: a table and that type's own filter over its `properties`. A statement that
+   * reads a single type then holds the filter as a top-level condition, which an index can serve.
+   */
+  objectsOfType?(objectTypeId: string): PgTypedObjects
   /** Wrap a terminal SELECT without its own WITH clause; the selected source owns the only WITH. */
   wrapStatement(
     sql: string,
@@ -192,6 +198,26 @@ export interface PgObjectQuerySource {
   wrapQuery(query: CompiledPgObjectQuery): CompiledPgObjectQuery
 }
 
+export interface PgTypedObjects {
+  readonly table: string
+  readonly filter?: { readonly sql: string; readonly args: readonly unknown[] }
+}
+
+/** The table and `AND ...` filter a statement reads one type's objects with. */
+export function pgObjectsOfType(
+  source: PgObjectQuerySource,
+  objectTypeId: string
+): { table: string; filter: string; args: readonly unknown[] } {
+  const typed = source.objectsOfType?.(objectTypeId)
+  if (!typed) return { table: source.objectsTable, filter: "", args: [] }
+
+  return {
+    table: typed.table,
+    filter: typed.filter ? `AND (${typed.filter.sql})` : "",
+    args: typed.filter?.args ?? [],
+  }
+}
+
 /** Prefix an optional query source, then assign PostgreSQL positional placeholders. */
 export function compilePgObjectStatement(
   sql: string,
@@ -462,10 +488,11 @@ function compileStart(
   }
 
   const order = compileOrder(identityOrderFields())
+  const objects = pgObjectsOfType(ctx.source, query.objectTypeId)
   const sql = `
     SELECT *, properties AS _cursor_properties
-    FROM ${ctx.source.objectsTable}
-    WHERE project_id = ? AND object_type_id = ?
+    FROM ${objects.table}
+    WHERE project_id = ? AND object_type_id = ? ${objects.filter}
     ${ctx.startPredicate ? `AND (${ctx.startPredicate})` : ""}
     ${ctx.unordered ? "" : `ORDER BY ${order.sql}`}
     ${ctx.isolateSortOverflow ? "OFFSET 0" : ""}
@@ -473,9 +500,9 @@ function compileStart(
 
   return {
     sql,
-    args: [projectId, query.objectTypeId, ...(ctx.unordered ? [] : order.args)],
-    totalSql: `SELECT COUNT(*)::bigint AS total FROM ${ctx.source.objectsTable} WHERE project_id = ? AND object_type_id = ?`,
-    totalArgs: [projectId, query.objectTypeId],
+    args: [projectId, query.objectTypeId, ...objects.args, ...(ctx.unordered ? [] : order.args)],
+    totalSql: `SELECT COUNT(*)::bigint AS total FROM ${objects.table} WHERE project_id = ? AND object_type_id = ? ${objects.filter}`,
+    totalArgs: [projectId, query.objectTypeId, ...objects.args],
     order,
     hasMore: () => false,
     trimRows: identityRows,
@@ -1070,11 +1097,7 @@ function compileExpansionOrder(
     const direction = field.direction === "desc" ? "DESC" : "ASC"
     clauses.push(
       `CASE WHEN ${jsonTypeExpression(propertyColumn)} IS NULL OR ${jsonTypeExpression(propertyColumn)} = 'null' THEN 1 ELSE 0 END ASC`,
-      `${
-        field.scalarKind === "decimal"
-          ? `(${jsonTextExpression(propertyColumn)})::numeric`
-          : `NULLIF(${jsonValueExpression(propertyColumn)}, 'null'::jsonb)`
-      } ${direction}`
+      `${orderedValueExpression(field.scalarKind, propertyColumn)} ${direction}`
     )
     args.push(field.propertyId, field.propertyId, field.propertyId)
   }
@@ -1239,13 +1262,14 @@ function compileAggregateStart(
     throw new Error("[SixbPg] PostgreSQL object storage does not support start.includeSubtypes")
   }
 
+  const objects = pgObjectsOfType(source, query.objectTypeId)
   return {
     sql: `
       SELECT project_id, object_type_id, primary_id, properties
-      FROM ${source.objectsTable}
-      WHERE project_id = ? AND object_type_id = ?
+      FROM ${objects.table}
+      WHERE project_id = ? AND object_type_id = ? ${objects.filter}
     `,
-    args: [projectId, query.objectTypeId],
+    args: [projectId, query.objectTypeId, ...objects.args],
   }
 }
 
@@ -1452,7 +1476,8 @@ function compileProjectionExpression(properties: readonly string[]): CompiledPre
   }
 }
 
-function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
+/** Compile a predicate over the unqualified `properties` column of the relation it filters. */
+export function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
   switch (predicate.op) {
     case "and":
     case "or": {
@@ -1467,6 +1492,8 @@ function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
       const item = compilePredicate(predicate.item)
       return negatePredicate(item)
     }
+    case "constant":
+      return { sql: predicate.value ? "true" : "false", args: [] }
     case "eq":
       return predicate.scalarKind === "decimal"
         ? compileDecimalEqualityPredicate(predicate.propertyId, "eq", predicate.value)
@@ -1486,6 +1513,14 @@ function compilePredicate(predicate: ObjectQueryPredicate): CompiledPredicate {
           args: [predicate.propertyId, predicate.propertyId, predicate.value],
         }
       }
+      if (isTextScalarKind(predicate.scalarKind)) {
+        // The null rank makes the range a prefix of the property's sort index keys.
+        return {
+          sql: `(${nullRankExpression()} = 0 AND ${orderedValueExpression(predicate.scalarKind)} ${op} ?::text)`,
+          args: [predicate.propertyId, predicate.propertyId, predicate.propertyId, predicate.value],
+        }
+      }
+
       return {
         sql: `${jsonValueExpression()} ${op} ?::text::jsonb`,
         args: [predicate.propertyId, jsonbValue(predicate.value)],
@@ -1809,13 +1844,13 @@ function compileKeysetRanges(
     })
     if (value.nullish) return
     const expression = compiledPropertyValueExpression(field, propertyColumn)
-    const parameter = field.scalarKind === "decimal" ? "?::numeric" : "?::text::jsonb"
-    const args = [
-      field.propertyId,
-      field.scalarKind === "decimal" ? value.value : jsonbValue(value.value),
-    ]
-    addRange({ sql: `${expression} ${field.direction === "desc" ? "<" : ">"} ${parameter}`, args })
-    prefix.push({ sql: `${expression} = ${parameter}`, args })
+    const parameter = compiledPropertyParameter(field, value.value)
+    const args = [field.propertyId, parameter.value]
+    addRange({
+      sql: `${expression} ${field.direction === "desc" ? "<" : ">"} ${parameter.sql}`,
+      args,
+    })
+    prefix.push({ sql: `${expression} = ${parameter.sql}`, args })
   })
   return ranges
 }
@@ -1884,14 +1919,11 @@ function compileFieldEquality(
     }
   }
 
+  const parameter = compiledPropertyParameter(field, cursor.value)
+
   return {
-    sql: `(${jsonTypeExpression(propertyColumn)} IS NOT NULL AND ${jsonTypeExpression(propertyColumn)} != 'null' AND ${compiledPropertyValueExpression(field, propertyColumn)} = ${field.scalarKind === "decimal" ? "?::numeric" : "?::text::jsonb"})`,
-    args: [
-      field.propertyId,
-      field.propertyId,
-      field.propertyId,
-      field.scalarKind === "decimal" ? cursor.value : jsonbValue(cursor.value),
-    ],
+    sql: `(${jsonTypeExpression(propertyColumn)} IS NOT NULL AND ${jsonTypeExpression(propertyColumn)} != 'null' AND ${compiledPropertyValueExpression(field, propertyColumn)} = ${parameter.sql})`,
+    args: [field.propertyId, field.propertyId, field.propertyId, parameter.value],
   }
 }
 
@@ -1911,16 +1943,17 @@ function compileFieldAfter(
 
   const rankSql = `CASE WHEN ${jsonTypeExpression(propertyColumn)} IS NULL OR ${jsonTypeExpression(propertyColumn)} = 'null' THEN 1 ELSE 0 END`
   const valueOperator = field.direction === "desc" ? "<" : ">"
+  const parameter = compiledPropertyParameter(field, cursor.value)
 
   return {
-    sql: `(${rankSql} > 0 OR (${rankSql} = 0 AND ${compiledPropertyValueExpression(field, propertyColumn)} ${valueOperator} ${field.scalarKind === "decimal" ? "?::numeric" : "?::text::jsonb"}))`,
+    sql: `(${rankSql} > 0 OR (${rankSql} = 0 AND ${compiledPropertyValueExpression(field, propertyColumn)} ${valueOperator} ${parameter.sql}))`,
     args: [
       field.propertyId,
       field.propertyId,
       field.propertyId,
       field.propertyId,
       field.propertyId,
-      field.scalarKind === "decimal" ? cursor.value : jsonbValue(cursor.value),
+      parameter.value,
     ],
   }
 }
@@ -2010,9 +2043,39 @@ function compiledPropertyValueExpression(
   field: Extract<CompiledOrderField, { kind: "property" }>,
   propertyColumn = "properties"
 ): string {
-  return field.scalarKind === "decimal"
-    ? `(${jsonTextExpression(propertyColumn)})::numeric`
-    : `NULLIF(${jsonValueExpression(propertyColumn)}, 'null'::jsonb)`
+  return orderedValueExpression(field.scalarKind, propertyColumn)
+}
+
+/** The parameter a cursor value binds to, typed like `compiledPropertyValueExpression`. */
+function compiledPropertyParameter(
+  field: Extract<CompiledOrderField, { kind: "property" }>,
+  value: unknown
+): { sql: string; value: unknown } {
+  if (field.scalarKind === "decimal") return { sql: "?::numeric", value }
+  if (isTextScalarKind(field.scalarKind)) return { sql: "?::text", value }
+  return { sql: "?::text::jsonb", value: jsonbValue(value) }
+}
+
+/**
+ * The expression a property sorts and range-compares by. Strings compare by code point, as
+ * SQLite and the in-memory store do: JSONB and the database's own collation would order case and
+ * accents linguistically. Sort indexes repeat this expression, collation included.
+ */
+function orderedValueExpression(
+  scalarKind: QueryScalarKind | undefined,
+  propertyColumn = "properties"
+): string {
+  if (scalarKind === "decimal") return `(${jsonTextExpression(propertyColumn)})::numeric`
+  if (isTextScalarKind(scalarKind)) return `((${jsonTextExpression(propertyColumn)}) COLLATE "C")`
+  return `NULLIF(${jsonValueExpression(propertyColumn)}, 'null'::jsonb)`
+}
+
+export function isTextScalarKind(scalarKind: QueryScalarKind | undefined): boolean {
+  return scalarKind === "string" || scalarKind === "uuid"
+}
+
+function nullRankExpression(propertyColumn = "properties"): string {
+  return `CASE WHEN ${jsonTypeExpression(propertyColumn)} IS NULL OR ${jsonTypeExpression(propertyColumn)} = 'null' THEN 1 ELSE 0 END`
 }
 
 function columnExpression(

package/src/objects/query-indexes.ts

@@ -4,6 +4,7 @@ import type { ReservedSQL, SQL, SQLClient } from "../pg-client"
 import { isConnectionLost } from "../storage-errors"
 import { withReservedPgConnection } from "../transactions"
 import { lockPgPreparation } from "./preparation-lock"
+import { isTextScalarKind } from "./query-compiler"
 
 export interface PgObjectQueryIndexScope {
   readonly projectId: string
@@ -110,6 +111,22 @@ async function createQueryIndex(
     await connection.unsafe(
       `CREATE INDEX CONCURRENTLY IF NOT EXISTS ${identifier(`${name}_overflow`)} ON ${identifier(schema)}.objects (primary_id) WHERE ${scope} AND NOT (${sortIndexBound(definition.index)})`
     )
+
+    // The same definition under another name is an earlier generation of this index, built
+    // with an expression queries no longer use. Writes would keep maintaining it.
+    const superseded = await connection<{ name: string }[]>`
+      SELECT c.relname AS name FROM pg_index i
+      JOIN pg_class c ON c.oid = i.indexrelid
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = ${schema} AND c.relname LIKE 'sixb_query_%' AND c.relname <> ${name}
+        AND obj_description(c.oid, 'pg_class') = ${JSON.stringify(definition.index)}`
+    for (const previous of superseded) {
+      for (const index of [previous.name, `${previous.name}_overflow`]) {
+        await connection.unsafe(
+          `DROP INDEX CONCURRENTLY IF EXISTS ${identifier(schema)}.${identifier(index)}`
+        )
+      }
+    }
   }
   return name
 }
@@ -150,14 +167,7 @@ function statisticsExpressions(index: PgObjectQueryIndex): string[] {
   if (index.kind === "value") expressions.push(`(properties -> ${literal(index.propertyId)})`)
   if (index.kind === "text")
     expressions.push(`lower(coalesce(properties ->> ${literal(index.propertyId)}, ''))`)
-  if (index.kind === "sort")
-    for (const field of index.fields) {
-      expressions.push(
-        field.scalarKind === "decimal"
-          ? `((properties ->> ${literal(field.propertyId)})::numeric)`
-          : `(NULLIF(properties -> ${literal(field.propertyId)}, 'null'::jsonb))`
-      )
-    }
+  if (index.kind === "sort") for (const field of index.fields) expressions.push(sortValue(field))
   return expressions
 }
 
@@ -220,7 +230,7 @@ function compileIndex(index: PgObjectQueryIndex): string {
       const property = `properties -> ${literal(field.propertyId)}`
       fields.push(
         `(CASE WHEN jsonb_typeof(${property}) IS NULL OR jsonb_typeof(${property}) = 'null' THEN 1 ELSE 0 END)`,
-        `${field.scalarKind === "decimal" ? `((properties ->> ${literal(field.propertyId)})::numeric)` : `(NULLIF(${property}, 'null'::jsonb))`} ${field.direction === "desc" ? "DESC" : "ASC"}`
+        `${sortValue(field)} ${field.direction === "desc" ? "DESC" : "ASC"}`
       )
     }
     fields.push("primary_id")
@@ -228,6 +238,14 @@ function compileIndex(index: PgObjectQueryIndex): string {
   return `(${fields.join(", ")}) WHERE ${predicate.join(" AND ")}`
 }
 
+/** The query compiler's ordered value expression; an index serves a sort only when they match. */
+function sortValue(field: Extract<PgObjectQueryIndex, { kind: "sort" }>["fields"][number]): string {
+  const text = `(properties ->> ${literal(field.propertyId)})`
+  if (field.scalarKind === "decimal") return `(${text}::numeric)`
+  if (isTextScalarKind(field.scalarKind)) return `(${text} COLLATE "C")`
+  return `(NULLIF(properties -> ${literal(field.propertyId)}, 'null'::jsonb))`
+}
+
 function literal(value: string): string {
   if (value.includes("\0"))
     throw new Error("[SixbPg] Query index names and values cannot contain NUL")
@@ -337,7 +355,8 @@ export async function findPgSortIndexBound(
           fields[i]?.kind === "property" &&
           fields[i].propertyId === field.propertyId &&
           (field.direction ?? "asc") === (fields[i].direction ?? "asc") &&
-          (field.scalarKind === "decimal") === (fields[i].scalarKind === "decimal")
+          (field.scalarKind === "decimal") === (fields[i].scalarKind === "decimal") &&
+          isTextScalarKind(field.scalarKind) === isTextScalarKind(fields[i].scalarKind)
       )
     )
       continue