@crvouga/mockingbird-service-postgres 1.5.1 → 1.6.0

package/AGENTS.md

@@ -13,12 +13,11 @@ Guidance for humans and coding agents editing this repository. For install and c
 3. Single-session **engine**: no MVCC across connections, no aborted-transaction (`25P02`) state in the sync API
 4. `NOT APPLICABLE` items: roles/auth enforcement, replication, VACUUM internals, storage params, full PL/pgSQL
 
-**Non-goals:** matching `pg`/`postgres.js` **client APIs**, full PL/pgSQL, or MVCC. The optional
-wire-protocol server (`src/wire/`, a Node/Bun-only entry over the one engine) is in scope: it
-speaks frontend/backend v3 and coordinates connections by serializing transaction blocks, adding
-advisory locks, `LISTEN`/`NOTIFY`, `CancelRequest` and per-connection `25P02`. It deliberately does
-**not** add row-level lock contention (`SELECT … FOR UPDATE SKIP LOCKED` distribution) or `COPY`
-streaming.
+**Non-goals:** matching `pg`/`postgres.js` **client APIs**, full PL/pgSQL, or MVCC in the synchronous
+API. The optional wire-protocol server (`src/wire/`, a Node/Bun-only entry over the one engine) is
+in scope: it coordinates per-session `READ COMMITTED` workspaces and adds row locks (`FOR UPDATE`,
+`NOWAIT`, `SKIP LOCKED`, deadlock detection), advisory locks, `LISTEN`/`NOTIFY`, `CancelRequest`
+and per-connection `25P02`. `COPY` streaming remains an explicitly documented boundary.
 
 ## SQL pipeline
 

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — @crvouga/mockingbird-service-postgres
 
+## 1.6.0 (2026-10-01)
+
+### Features
+
+- add MVCC row locks ([9e199e0](https://github.com/crvouga/mockingbird/commit/9e199e083c3d16a9a2acfd7a2e9ab00ad733ef4f))
+- stream COPY protocol ([9e7a867](https://github.com/crvouga/mockingbird/commit/9e7a8673206fd6dad1b170e1b3a31e183e5abb2f))
+- add database catalogs ([c9b2c06](https://github.com/crvouga/mockingbird/commit/c9b2c060af4919135926c805412886177b4026a0))
+- parse identity sequence names ([e7a5a03](https://github.com/crvouga/mockingbird/commit/e7a5a03f33e6d5a0dc28a34d30659bb128db7c73))
+- accept tooling session GUCs ([0464416](https://github.com/crvouga/mockingbird/commit/04644162f7bbd5071e580cfb398b3da82a2a4952))
+
 ## 1.5.1 (2026-10-01)
 
 ### Fixes and improvements

package/COMPATIBILITY.md

@@ -16,7 +16,11 @@ Differential tests compare a **tuple** per statement: rows (normalized to canoni
 
 A catalog ID appearing in a test file is **not** proof by itself. Trivial probes are tracked in [`compat/smoke-baseline.json`](compat/smoke-baseline.json) and ratcheted downward (currently **0 smoke stubs** across 945 catalog scenarios). Generated operator/cast matrices live under [`tests/contract/matrices/`](tests/contract/matrices/). Observed mem≠oracle diffs must bind to a `compat/divergences.json` entry or be a **FAILURE** — unexplained diffs are not allowed.
 
-Intentional differences are finite and machine-readable in `compat/divergences.json` (PGMM snapshots, seeded `random()`/`now()`, sync single-session API, no aborted-transaction state, EXPLAIN stubs, trigger-order/`UPDATE OF` edges, float8 rounding/overflow edges, …). Human-readable: [DIVERGENCES.md](DIVERGENCES.md).
+Intentional differences are finite and machine-readable in `compat/divergences.json` (PGMM snapshots, seeded `random()`/`now()`, sync single-session API, no aborted-transaction state, EXPLAIN stubs, trigger-order/`UPDATE OF` edges, float8 rounding/overflow edges, …). The wire server supports isolated database catalogs, startup selection, database lifecycle DDL, and copy-on-write template cloning. Human-readable: [DIVERGENCES.md](DIVERGENCES.md).
+
+The wire server supports protocol-v3 text and CSV `COPY FROM STDIN` / `COPY TO STDOUT`, including
+incremental `CopyData`, client aborts, and statement-atomic rollback. Binary COPY remains outside
+the compatibility surface.
 
 ## Status vocabulary
 
@@ -33,7 +37,7 @@ Anything a PostgreSQL application can invoke through SQL against the PGlite **18
 
 1. **Snapshot format** — custom binary codec (`PGMM`), not `pg_dump` / on-disk clusters (logical state still round-trips).
 2. **Deterministic `random()` / `now()`** — seeded PRNG and fixed clock by default (injectable).
-3. **Single session** — no MVCC across connections, no isolation levels beyond one session, no `25P02` aborted-transaction state (documented divergence).
+3. **Single-session sync API** — no concurrent sessions or `25P02` aborted-transaction state. The optional wire server separately provides per-session `READ COMMITTED` workspaces and row locks.
 4. **NOT APPLICABLE** rows in `compat/coverage.json` (roles, replication, VACUUM internals, LISTEN/NOTIFY, cursors, full PL/pgSQL, extensions other than `pgcrypto`'s `digest()` and `pg_trgm`'s `similarity` / `<%` / `gin_trgm_ops`).
 
 The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalog`; postgres-mem implements **302 functions** and **41 operators**, and every remaining item is an explicit entry in [`compat/unsupported-register.json`](compat/unsupported-register.json) with a reason (trigger/internal plumbing, admin/monitoring, unsupported type families, …). The gate fails closed on silence.
@@ -56,7 +60,7 @@ The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalo
 | GROUPING SETS / ROLLUP / CUBE, DISTINCT ON, LATERAL, set ops | VERIFIED | |
 | Recursive + data-modifying CTEs | VERIFIED | |
 | Constraints: PK / UNIQUE / NOT NULL / CHECK / FK actions | VERIFIED | DEFERRABLE parsed, checked at statement end |
-| Sequences / serial / identity | VERIFIED | |
+| Sequences / serial / identity | VERIFIED | Includes pg_dump identity sequence names and options |
 | Schemas + search_path + pg_catalog / information_schema | VERIFIED | Catalog columns are the commonly-queried subset |
 | Enums, domains, generated columns | VERIFIED | |
 | Triggers (row-level, LANGUAGE sql-expressible) | PARTIALLY VERIFIED | Creation-order firing, `UPDATE OF` ignored, no INSTEAD OF (documented) |
@@ -65,14 +69,15 @@ The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalo
 | `CREATE EXTENSION pgcrypto` / `digest()` | PARTIALLY VERIFIED | `digest(bytea, text)` and `digest(text, text)` for md5, sha1, sha224, sha256, sha384, sha512. `crypt`, `hmac`, `gen_salt`, and PGP functions are not installed. OpenSSL-only names (sha3, blake2, ripemd160, sm3) are not available. Extensions other than `pgcrypto` and `pg_trgm` still fail loud (`0A000`) |
 | `CREATE EXTENSION pg_trgm` | PARTIALLY VERIFIED | `similarity(text, text)`, `<%` at the default word-similarity threshold 0.6, and a single-column `gin_trgm_ops` index on `text` or `varchar`. `gist_trgm_ops`, multicolumn `gin_trgm_ops`, and non-default thresholds are not installed. |
 | COPY FROM/TO (text, csv) | VERIFIED | Via `copyFrom` API hook / rows out |
-| PREPARE / EXECUTE / DEALLOCATE, SET / SHOW / RESET | VERIFIED | GUC subset |
+| PREPARE / EXECUTE / DEALLOCATE, SET / SHOW / RESET | VERIFIED | GUC subset, including PostgreSQL dump and migration-client preambles |
 | Transactions / savepoints | VERIFIED | No `25P02` aborted state (documented divergence) |
 | Collation / ordering | PARTIALLY VERIFIED | `C` semantics pinned; locale/ICU out of scope |
 | Regex (`~`, `~*`, POSIX functions) | PARTIALLY VERIFIED | JS regex flavor mapped to POSIX ERE; documented edges |
 | EXPLAIN | PARTIALLY VERIFIED | Stub plan shapes |
 | MERGE / CALL / cursors / LISTEN / full PL/pgSQL | UNSUPPORTED | Fail loud `0A000`, registered |
 | Roles / GRANT / VACUUM / ANALYZE / LOCK | NOT APPLICABLE | Parsed no-ops where harmless |
-| Wire protocol / multi-session MVCC / on-disk format | NOT APPLICABLE | |
+| Wire protocol / multi-session concurrency | PARTIALLY VERIFIED | `READ COMMITTED` workspaces; `FOR UPDATE`, `NOWAIT`, `SKIP LOCKED`, and deadlock detection |
+| On-disk PostgreSQL format | NOT APPLICABLE | PGMM snapshots are the persistence format |
 
 ## How to verify
 

package/README.md

@@ -173,6 +173,13 @@ const fromUri = await serve("postgres://postgres:secret@127.0.0.1:0/app")
 await fromUri.close()
 ```
 
+The wire server owns a PostgreSQL-style database catalog. Start on `postgres`, then use ordinary
+`CREATE DATABASE`, `DROP DATABASE`, and `ALTER DATABASE … RENAME TO` statements; startup packets
+select an isolated engine and unknown names fail with `3D000`. `CREATE DATABASE child TEMPLATE
+seed` forks `seed` through the same copy-on-write snapshot path as `Snapshot.open()`. The live names
+are available through `pg_database` and `server.databaseNames()`, while
+`server.getDatabase(name)` and `server.snapshot(name)` provide programmatic test controls.
+
 Or from the command line (installs a `mockingbird-postgres` bin):
 
 ```bash
@@ -190,11 +197,12 @@ The wire server does not speak that HTTP API.
 failCommit })` arms the next statement or connection for a drop, a delay, or a `40001` commit
 failure.
 
-One engine is shared by every connection. The engine runs one statement at a time, so a connection
-inside an explicit `BEGIN` block holds it until `COMMIT`/`ROLLBACK` and other connections queue
-behind it — which keeps read-committed visibility (an uncommitted row is never seen by another
-connection) by serializing transaction blocks rather than by MVCC. Across connections the server
-adds what a single engine does not: per-session advisory locks (`pg_advisory_lock` /
+One committed engine is shared by every connection. Explicit transactions execute in per-session
+copy-on-write workspaces that rebase each statement on the latest committed state, providing
+`READ COMMITTED` visibility without holding an engine-wide transaction turn. Successful writes
+are applied atomically at commit; rollback discards the workspace. Across connections the server
+adds row locks for `SELECT … FOR UPDATE` (including blocking, `NOWAIT`, `SKIP LOCKED`, and
+deadlock SQLSTATE `40P01`) and per-session advisory locks (`pg_advisory_lock` /
 `pg_try_advisory_lock` / `_xact_` / `_unlock`) with in-order waiters and deadlock detection
 (`40P01`), `LISTEN`/`NOTIFY` delivered to idle listeners, `CancelRequest` (a blocked statement ends
 `57014` and the session stays usable), and per-connection aborted-transaction state (a failed
@@ -202,13 +210,15 @@ statement in a block is `25P02` until `ROLLBACK`, with `ReadyForQuery` reporting
 SCRAM-SHA-256 and trust auth, the extended query protocol (`Parse`/`Bind`/`Describe`/`Execute`/
 `Sync`) with text and binary parameters and results, real type OIDs in `RowDescription`, and
 `23505`/`23502` errors carrying the constraint, table and column the engine names, all work over
-the wire.
+the wire. `COPY … FROM STDIN` and `COPY … TO STDOUT` use protocol-v3 `CopyInResponse`,
+`CopyOutResponse`, `CopyData`, `CopyDone`, and `CopyFail` messages. Text and CSV streams are parsed
+incrementally across arbitrary frame and quoted-record boundaries; failed imports are atomic and
+leave the connection in PostgreSQL's transaction state.
 
-**Not modelled by the server:** row-level lock contention, so `SELECT … FOR UPDATE SKIP LOCKED`
-parses and returns rows but does not distribute disjoint rows across concurrent workers (there are
-no row locks); `COPY` streaming (`CopyInResponse`/`CopyData`) — use `copyFrom` on a shared
-`Database`; and the binary parameter formats beyond the common scalar types (a client that sends
-another binary type gets `0A000`, and can switch that parameter to text).
+**Not modelled by the server:** transaction ID and snapshot-inspection functions, predicate and
+table locks, isolation levels beyond `READ COMMITTED`, and the binary parameter formats beyond the
+common scalar types (a client that sends another binary type gets `0A000`, and can switch that
+parameter to text). Binary `COPY` is not supported.
 
 ### Method semantics
 
@@ -308,8 +318,8 @@ Goal: **SQL dialect** behavioural parity vs PostgreSQL **18.3** for the sync API
 [DROP-IN-CONTRACT.md](https://github.com/crvouga/mockingbird/blob/main/packages/service/postgres/docs/DROP-IN-CONTRACT.md).
 
 The in-process API has no async client, no connection pooling and no `pg_dump` codec; the optional
-[wire-protocol server](#wire-protocol-server-separate-processes) adds a TCP listener and coordinates
-several connections over the one engine, but by serializing transaction blocks, not by MVCC.
+[wire-protocol server](#wire-protocol-server-separate-processes) adds a TCP listener, per-session
+`READ COMMITTED` transaction workspaces, and row-level worker locks.
 Intentional differences: custom `PGMM` snapshots; seeded `random()` / fixed `now()` by default
 (`{ random: "os" }` / `{ now: "system" }` match PostgreSQL entropy and wall clock).
 

package/dist/admin.js

@@ -717,12 +717,12 @@ function bootAdmin(config) {
       throw new Error(`admin shell is missing #${id}`);
     return node;
   };
-  const errorMessage = (data, fallback) => {
+  const errorMessage = (data, fallback2) => {
     if (!isRecord(data))
-      return fallback;
+      return fallback2;
     const error = data.error;
     if (!isRecord(error) || typeof error.message !== "string" || error.message === "") {
-      return fallback;
+      return fallback2;
     }
     return error.message;
   };
@@ -981,8 +981,8 @@ function bootAdmin(config) {
     const data = await api("GET", "/namespaces");
     const select = el("namespace", HTMLSelectElement);
     const listed2 = requireList(isRecord(data) ? data.namespaces : void 0, "Namespaces");
-    const fallback = isRecord(data) && typeof data.default === "string" && data.default !== "" ? data.default : "default";
-    const names = (listed2.length > 0 ? listed2.map((name) => String(name)) : [fallback]).slice();
+    const fallback2 = isRecord(data) && typeof data.default === "string" && data.default !== "" ? data.default : "default";
+    const names = (listed2.length > 0 ? listed2.map((name) => String(name)) : [fallback2]).slice();
     if (!names.includes(state.namespace))
       names.unshift(state.namespace);
     select.innerHTML = names.map((name) => `<option value="${esc(name)}">${esc(name)}</option>`).join("");
@@ -2629,9 +2629,9 @@ var kindFromType = (type) => {
     return "unknown";
   return "string";
 };
-var countParam = (value, fallback, max) => {
+var countParam = (value, fallback2, max) => {
   if (value === null)
-    return fallback;
+    return fallback2;
   if (!/^\d+$/.test(value))
     return void 0;
   return Math.min(max, Number(value));
@@ -6344,7 +6344,13 @@ var DatabaseState = class _DatabaseState {
     this.settings.set("lc_numeric", "C");
     this.settings.set("lc_time", "C");
     this.settings.set("default_transaction_isolation", "read committed");
+    this.settings.set("lock_timeout", "0");
+    this.settings.set("idle_in_transaction_session_timeout", "0");
+    this.settings.set("transaction_timeout", "0");
     this.settings.set("statement_timeout", "0");
+    this.settings.set("check_function_bodies", "on");
+    this.settings.set("xmloption", "content");
+    this.settings.set("row_security", "on");
     this.settings.set("array_nulls", "on");
     this.settings.set("backslash_quote", "safe_encoding");
   }
@@ -9946,6 +9952,19 @@ function exactDegTan(x) {
   return Math.tan(x * Math.PI / 180);
 }
 
+// src/sql/deparse.ts
+function quoteIdent(name) {
+  if (/^[a-z_][a-z0-9_$]*$/.test(name)) return name;
+  return `"${name.replaceAll('"', '""')}"`;
+}
+
+// src/runtime/database-context.ts
+var contexts = /* @__PURE__ */ new WeakMap();
+var fallback = { name: "postgres", names: () => ["postgres"] };
+function databaseCatalogContext(state) {
+  return contexts.get(state) ?? fallback;
+}
+
 // src/functions/misc-fns.ts
 var PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
 function findSequenceForCall(ctx, name) {
@@ -10029,8 +10048,8 @@ function sequenceNextval(ctx, seq) {
 function getMiscFunctions() {
   const m = /* @__PURE__ */ new Map();
   m.set("version", () => tv("text", PG_VERSION_TEXT));
-  m.set("current_database", () => tv("name", "postgres"));
-  m.set("current_catalog", () => tv("name", "postgres"));
+  m.set("current_database", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
+  m.set("current_catalog", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
   m.set("current_schema", (ctx) => {
     const path = ctx.state.effectiveSearchPath();
     const first = path.find((s) => ctx.state.schemas.has(s));
@@ -10152,7 +10171,7 @@ function getMiscFunctions() {
       if (!col.identity) return tv("text", null);
       return tv(
         "text",
-        col.identity.sequence.split(".").map((p) => p).join(".")
+        col.identity.sequence.split(".").map(quoteIdent).join(".")
       );
     })
   );
@@ -17402,14 +17421,19 @@ var Parser = class {
   parseIdentityOptions() {
     const options = {};
     if (this.eatPunct("(")) {
-      Object.assign(options, this.parseSequenceOptions());
+      Object.assign(options, this.parseSequenceOptions(true));
       this.expectPunct(")");
     }
     return options;
   }
-  parseSequenceOptions() {
+  parseSequenceOptions(identity = false) {
     const options = {};
     for (; ; ) {
+      if (identity && this.eatKw("sequence")) {
+        this.expectKw("name");
+        options.sequenceName = this.qualifiedName();
+        continue;
+      }
       if (this.eatKw("increment")) {
         this.eatKw("by");
         options.increment = this.parseSignedBigInt();
@@ -23411,6 +23435,27 @@ function parseCsvLine(line, delim, quote) {
   }
   return fields;
 }
+function splitCsvRecords(data, quote) {
+  const records = [];
+  let start = 0;
+  let quoted = false;
+  for (let i = 0; i < data.length; i++) {
+    const char = data[i];
+    if (char === quote) {
+      if (quoted && data[i + 1] === quote) i++;
+      else quoted = !quoted;
+      continue;
+    }
+    if (char === "\n" && !quoted) {
+      const end = i > start && data[i - 1] === "\r" ? i - 1 : i;
+      records.push(data.slice(start, end));
+      start = i + 1;
+    }
+  }
+  if (quoted) throw pgError("invalid_text_representation", "unterminated CSV quoted field", "22P04");
+  if (start < data.length) records.push(data.slice(start));
+  return records;
+}
 function executeCopyFromData(env, stmt, data) {
   const format = String(stmt.options.format ?? "text").toLowerCase();
   if (format !== "text" && format !== "csv") throw unsupported(`COPY format ${format}`);
@@ -23421,7 +23466,7 @@ function executeCopyFromData(env, stmt, data) {
   const nullStr = String(stmt.options.null ?? (format === "csv" ? "" : "\\N"));
   const quote = String(stmt.options.quote ?? '"');
   const header = stmt.options.header === true || String(stmt.options.header ?? "").toLowerCase() === "true";
-  let lines = data.split(/\r?\n/);
+  let lines = format === "csv" ? splitCsvRecords(data, quote) : data.split(/\r?\n/);
   const endMarker = lines.indexOf("\\.");
   if (endMarker !== -1) lines = lines.slice(0, endMarker);
   if (lines.length > 0 && lines[lines.length - 1] === "") lines = lines.slice(0, -1);
@@ -24155,7 +24200,8 @@ function pgSettings(ctx) {
     "pg_settings"
   );
 }
-function pgDatabase() {
+function pgDatabase(ctx) {
+  const names = databaseCatalogContext(ctx.state).names();
   return rel(
     [
       ["oid", "oid"],
@@ -24164,7 +24210,7 @@ function pgDatabase() {
       ["datistemplate", "bool"],
       ["datallowconn", "bool"]
     ],
-    [[5, "postgres", 6, false, true]],
+    names.map((name, index) => [5 + index, name, 6, false, true]),
     "pg_database"
   );
 }
@@ -24199,13 +24245,14 @@ function pgTrigger(ctx) {
     "pg_trigger"
   );
 }
-var CATALOG_NAME = "postgres";
+var catalogName = (state) => databaseCatalogContext(state).name;
 function infoSchemata(state) {
+  const catalog = catalogName(state);
   const rows = [
-    [CATALOG_NAME, "pg_catalog", OWNER],
-    [CATALOG_NAME, "information_schema", OWNER]
+    [catalog, "pg_catalog", OWNER],
+    [catalog, "information_schema", OWNER]
   ];
-  for (const s of state.schemas.values()) rows.push([CATALOG_NAME, s.name, OWNER]);
+  for (const s of state.schemas.values()) rows.push([catalog, s.name, OWNER]);
   return rel(
     [
       ["catalog_name", "name"],
@@ -24217,13 +24264,14 @@ function infoSchemata(state) {
   );
 }
 function infoTables(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const t of schema.tables.values()) {
-      rows.push([CATALOG_NAME, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
+      rows.push([catalog, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
     }
     for (const v of schema.views.values()) {
-      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, "VIEW", "NO"]);
+      if (!v.materialized) rows.push([catalog, v.schema, v.name, "VIEW", "NO"]);
     }
   }
   return rel(
@@ -24239,6 +24287,7 @@ function infoTables(ctx) {
   );
 }
 function infoColumns(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     t.columns.forEach((c, i) => {
@@ -24249,7 +24298,7 @@ function infoColumns(ctx) {
       const dataType = isArrayType(id) ? "ARRAY" : isEnumType(id) ? "USER-DEFINED" : typeDisplayName(id);
       const udt = isArrayType(id) ? `_${arrayUdt(id)}` : isEnumType(id) ? id.slice(5).split(".").pop() : id;
       rows.push([
-        CATALOG_NAME,
+        catalog,
         t.schema,
         t.name,
         c.name,
@@ -24294,10 +24343,11 @@ function arrayUdt(t) {
   return isEnumType(elem) ? elem.slice(5).split(".").pop() : elem;
 }
 function infoViews(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const v of schema.views.values()) {
-      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, null]);
+      if (!v.materialized) rows.push([catalog, v.schema, v.name, null]);
     }
   }
   return rel(
@@ -24312,10 +24362,11 @@ function infoViews(ctx) {
   );
 }
 function infoSequences(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const s of allSequences(ctx.state)) {
     rows.push([
-      CATALOG_NAME,
+      catalog,
       s.schema,
       s.name,
       typeDisplayName(s.dataType),
@@ -24343,11 +24394,12 @@ function infoSequences(ctx) {
   );
 }
 function infoTableConstraints(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     for (const c of t.constraints) {
       const type = c.kind === "primary_key" ? "PRIMARY KEY" : c.kind === "unique" ? "UNIQUE" : c.kind === "check" ? "CHECK" : "FOREIGN KEY";
-      rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, type]);
+      rows.push([catalog, t.schema, c.name, catalog, t.schema, t.name, type]);
     }
   }
   return rel(
@@ -24365,12 +24417,13 @@ function infoTableConstraints(ctx) {
   );
 }
 function infoKeyColumnUsage(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const t of allTables(ctx.state)) {
     for (const c of t.constraints) {
       if (c.kind !== "primary_key" && c.kind !== "unique" && c.kind !== "foreign_key") continue;
       c.columns.forEach((col, i) => {
-        rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, col, i + 1]);
+        rows.push([catalog, t.schema, c.name, catalog, t.schema, t.name, col, i + 1]);
       });
     }
   }
@@ -24390,12 +24443,13 @@ function infoKeyColumnUsage(ctx) {
   );
 }
 function infoRoutines(ctx) {
+  const catalog = catalogName(ctx.state);
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const fns of schema.functions.values()) {
       for (const f of fns) {
         rows.push([
-          CATALOG_NAME,
+          catalog,
           f.schema,
           f.name,
           "FUNCTION",
@@ -24452,7 +24506,7 @@ function buildCatalogRelation(ctx, schema, name) {
       case "pg_settings":
         return pgSettings(ctx);
       case "pg_database":
-        return pgDatabase();
+        return pgDatabase(ctx);
       case "pg_roles":
       case "pg_user":
         return pgRoles();
@@ -24633,6 +24687,11 @@ var MAX_IDENT = 63;
 function truncIdent(s) {
   return s.length > MAX_IDENT ? s.slice(0, MAX_IDENT) : s;
 }
+function identitySequenceTarget(env, tableSchema, defaultName, options) {
+  const parts = options.sequenceName;
+  if (!parts || parts.length === 0) return { schema: tableSchema, name: defaultName };
+  return targetSchema(env, parts);
+}
 var SEQ_LIMITS = {
   int2: { min: -32768n, max: 32767n },
   int4: { min: -2147483648n, max: 2147483647n },
@@ -24809,8 +24868,8 @@ function buildColumn(env, schema, tableName, def, out, taken) {
         break;
       }
       case "generated_identity": {
-        const seqName = truncIdent(`${tableName}_${def.name}_seq`);
-        const seq = buildSequence(env, schema, seqName, c.options, false);
+        const target = identitySequenceTarget(env, schema, truncIdent(`${tableName}_${def.name}_seq`), c.options);
+        const seq = buildSequence(env, target.schema, target.name, c.options, false);
         if (!c.options.as) {
           seq.dataType = col.type.id === "int2" || col.type.id === "int4" || col.type.id === "int8" ? col.type.id : "int8";
           const limits = SEQ_LIMITS[seq.dataType];
@@ -24819,7 +24878,7 @@ function buildColumn(env, schema, tableName, def, out, taken) {
         }
         seq.ownedBy = { table: tableName, column: def.name };
         out.sequences.push(seq);
-        col.identity = { always: c.always, sequence: `${schema.name}.${seqName}` };
+        col.identity = { always: c.always, sequence: `${target.schema.name}.${target.name}` };
         col.notNull = true;
         break;
       }
@@ -24955,10 +25014,11 @@ function executeCreateTable(env, stmt) {
     throw pgError("invalid_table_definition", `multiple primary keys for table "${name}" are not allowed`, "42P16");
   }
   for (const seq of built.sequences) {
-    if (schema.hasRelation(seq.name)) {
+    const seqSchema = state.getSchema(seq.schema);
+    if (seqSchema.hasRelation(seq.name)) {
       throw pgError("duplicate_table", `relation "${seq.name}" already exists`, "42P07");
     }
-    schema.sequences.set(seq.name, seq);
+    seqSchema.sequences.set(seq.name, seq);
   }
   const table = new TableData(schema.name, name, built.columns, state.nextOid(), stmt.temp);
   table.constraints = built.constraints;
@@ -25310,7 +25370,13 @@ function executeAlterTable(env, stmt) {
         const built = { columns: [], constraints: [], sequences: [] };
         const taken = constraintNames(table);
         const col = buildColumn(env, schema, table.name, action.column, built, taken);
-        for (const seq of built.sequences) schema.sequences.set(seq.name, seq);
+        for (const seq of built.sequences) {
+          const seqSchema = state.getSchema(seq.schema);
+          if (seqSchema.hasRelation(seq.name)) {
+            throw pgError("duplicate_table", `relation "${seq.name}" already exists`, "42P07");
+          }
+          seqSchema.sequences.set(seq.name, seq);
+        }
         table.columns.push(col);
         table.constraints.push(...built.constraints);
         for (let i = 0; i < rows.length; i++) {
@@ -25630,12 +25696,32 @@ function executeAlterTable(env, stmt) {
             "42P16"
           );
         }
-        const seqName = truncIdent(`${table.name}_${action.column}_seq`);
-        const seq = buildSequence(env, schema, seqName, action.options, false);
+        if (!col.notNull) {
+          throw pgError(
+            "object_not_in_prerequisite_state",
+            `column "${action.column}" of relation "${table.name}" must be declared NOT NULL before identity can be added`,
+            "55000"
+          );
+        }
+        const target = identitySequenceTarget(
+          env,
+          schema,
+          truncIdent(`${table.name}_${action.column}_seq`),
+          action.options
+        );
+        if (target.schema.hasRelation(target.name)) {
+          throw pgError("duplicate_table", `relation "${target.name}" already exists`, "42P07");
+        }
+        const seq = buildSequence(env, target.schema, target.name, action.options, false);
+        if (!action.options.as) {
+          seq.dataType = col.type.id === "int2" || col.type.id === "int4" || col.type.id === "int8" ? col.type.id : "int8";
+          const limits = SEQ_LIMITS[seq.dataType];
+          if (action.options.maxValue === void 0) seq.maxValue = seq.increment > 0n ? limits.max : -1n;
+          if (action.options.minValue === void 0) seq.minValue = seq.increment > 0n ? 1n : limits.min;
+        }
         seq.ownedBy = { table: table.name, column: action.column };
-        schema.sequences.set(seqName, seq);
-        col.identity = { always: true, sequence: `${schema.name}.${seqName}` };
-        col.notNull = true;
+        target.schema.sequences.set(target.name, seq);
+        col.identity = { always: action.always, sequence: `${target.schema.name}.${target.name}` };
         break;
       }
       case "drop_identity": {
@@ -26504,7 +26590,7 @@ if (typeof disposeKey === "symbol") {
 
 // src/admin.ts
 var QUERY_CAP = 500;
-var quoteIdent = (name) => `"${name.replaceAll('"', '""')}"`;
+var quoteIdent2 = (name) => `"${name.replaceAll('"', '""')}"`;
 var bounded = (value) => {
   if (!Number.isSafeInteger(value) || value < 0) throw new Error("limit and offset must be non-negative integers");
   return value;
@@ -26577,7 +26663,7 @@ var adapt = (db) => ({
   tables: () => listed(db),
   page(schema, table, limit, offset) {
     const found = requireTable(db, schema, table);
-    const from = `${quoteIdent(schema)}.${quoteIdent(table)}`;
+    const from = `${quoteIdent2(schema)}.${quoteIdent2(table)}`;
     const take = bounded(limit);
     const skip = bounded(offset);
     const totalRow = db.query(`SELECT count(*) AS count FROM ${from}`);