@crvouga/mockingbird-service-postgres 1.5.1 → 1.6.0

package/dist/wire/index.js

@@ -3463,7 +3463,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");
   }
@@ -7065,6 +7071,22 @@ 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;
+}
+function setDatabaseCatalogContext(state, context) {
+  contexts.set(state, context);
+}
+
 // src/functions/misc-fns.ts
 var PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
 function findSequenceForCall(ctx, name) {
@@ -7148,8 +7170,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));
@@ -7271,7 +7293,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(".")
       );
     })
   );
@@ -14521,14 +14543,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();
@@ -20530,6 +20557,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}`);
@@ -20540,7 +20588,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);
@@ -21274,7 +21322,8 @@ function pgSettings(ctx) {
     "pg_settings"
   );
 }
-function pgDatabase() {
+function pgDatabase(ctx) {
+  const names = databaseCatalogContext(ctx.state).names();
   return rel(
     [
       ["oid", "oid"],
@@ -21283,7 +21332,7 @@ function pgDatabase() {
       ["datistemplate", "bool"],
       ["datallowconn", "bool"]
     ],
-    [[5, "postgres", 6, false, true]],
+    names.map((name, index) => [5 + index, name, 6, false, true]),
     "pg_database"
   );
 }
@@ -21318,13 +21367,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"],
@@ -21336,13 +21386,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(
@@ -21358,6 +21409,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) => {
@@ -21368,7 +21420,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,
@@ -21413,10 +21465,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(
@@ -21431,10 +21484,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),
@@ -21462,11 +21516,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(
@@ -21484,12 +21539,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]);
       });
     }
   }
@@ -21509,12 +21565,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",
@@ -21571,7 +21628,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();
@@ -21752,6 +21809,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 },
@@ -21928,8 +21990,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];
@@ -21938,7 +22000,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;
       }
@@ -22074,10 +22136,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;
@@ -22429,7 +22492,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++) {
@@ -22749,12 +22818,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": {
@@ -23623,11 +23712,11 @@ if (typeof disposeKey === "symbol") {
 
 // src/wire/cluster.ts
 var Cluster = class {
-  constructor(db) {
-    this.db = db;
-    registerSessionFunctions(this);
+  constructor(db, defaultDatabaseName = "postgres") {
+    this.defaultDatabaseName = defaultDatabaseName;
+    this.installDatabase(defaultDatabaseName, db);
   }
-  db;
+  defaultDatabaseName;
   turnHolder = null;
   turnQueue = [];
   locks = /* @__PURE__ */ new Map();
@@ -23636,6 +23725,77 @@ var Cluster = class {
   sessions = /* @__PURE__ */ new Map();
   current = null;
   nextPid = 1e3;
+  databases = /* @__PURE__ */ new Map();
+  /** The initial database, retained for the server's backwards-compatible public handle. */
+  get db() {
+    return this.requireDatabase(this.defaultDatabaseName);
+  }
+  databaseNames() {
+    return [...this.databases.keys()].sort();
+  }
+  getDatabase(name) {
+    return this.databases.get(name);
+  }
+  requireDatabase(name) {
+    const db = this.databases.get(name);
+    if (!db) throw new PostgresError("undefined_object", `database "${name}" does not exist`, "3D000");
+    return db;
+  }
+  createDatabase(name, template) {
+    if (this.databases.has(name)) {
+      throw new PostgresError("duplicate_object", `database "${name}" already exists`, "42P04");
+    }
+    const db = template === void 0 ? new Database() : this.requireTemplate(template).snapshot().open();
+    this.installDatabase(name, db);
+  }
+  dropDatabase(name, requester) {
+    if (name === requester.databaseName || this.activeConnections(name) > 0) {
+      throw new PostgresError(
+        "object_not_in_prerequisite_state",
+        `database "${name}" is being accessed by other users`,
+        "55006"
+      );
+    }
+    if (!this.databases.delete(name)) {
+      throw new PostgresError("undefined_object", `database "${name}" does not exist`, "3D000");
+    }
+  }
+  renameDatabase(from, to, requester) {
+    if (this.databases.has(to)) {
+      throw new PostgresError("duplicate_object", `database "${to}" already exists`, "42P04");
+    }
+    const db = this.requireDatabase(from);
+    if (from === requester.databaseName || this.activeConnections(from) > 0) {
+      throw new PostgresError(
+        "object_not_in_prerequisite_state",
+        `database "${from}" is being accessed by other users`,
+        "55006"
+      );
+    }
+    this.databases.delete(from);
+    this.installDatabase(to, db);
+  }
+  requireTemplate(name) {
+    if (this.activeConnections(name) > 0) {
+      throw new PostgresError(
+        "object_not_in_prerequisite_state",
+        `source database "${name}" is being accessed by other users`,
+        "55006"
+      );
+    }
+    return this.requireDatabase(name);
+  }
+  activeConnections(name) {
+    let count = 0;
+    for (const session of this.sessions.values()) if (session.databaseName === name) count++;
+    return count;
+  }
+  installDatabase(name, db) {
+    const context = { name, names: () => this.databaseNames() };
+    setDatabaseCatalogContext(db.state, context);
+    this.databases.set(name, db);
+    registerSessionFunctions(this, db);
+  }
   newPid() {
     return this.nextPid++;
   }
@@ -23727,7 +23887,7 @@ var Cluster = class {
     }
     this.unlockAll(session);
     if (this.turnHolder === session) {
-      if (this.db.transactions.inTransaction) this.db.transactions.rollback();
+      if (session.database.transactions.inTransaction) session.database.transactions.rollback();
       this.releaseTurn(session);
     }
   }
@@ -23759,8 +23919,7 @@ var LockWait = class extends Error {
   key;
 };
 var lockKey = (args) => args.map((a) => String(a)).join(":");
-var registerSessionFunctions = (cluster) => {
-  const db = cluster.db;
+var registerSessionFunctions = (cluster, db) => {
   const me = () => {
     if (!cluster.current) throw new PostgresError("internal", "no session is executing", "XX000");
     return cluster.current;
@@ -23927,6 +24086,17 @@ var backend = {
     for (const oid of oids) w.i32(oid);
   }),
   notificationResponse: (pid, channel, payload) => message("A", (w) => w.i32(pid).cstring(channel).cstring(payload)),
+  copyInResponse: (columns) => message("G", (w) => {
+    w.u8(0).i16(columns);
+    for (let i = 0; i < columns; i++) w.i16(0);
+  }),
+  copyOutResponse: (columns) => message("H", (w) => {
+    w.u8(0).i16(columns);
+    for (let i = 0; i < columns; i++) w.i16(0);
+  }),
+  copyData: (data) => message("d", (w) => w.bytes(data)),
+  copyDone: () => message("c", () => {
+  }),
   /** The one-byte answers to SSLRequest / GSSENCRequest: no encryption here. */
   no: () => new Uint8Array([78])
 };
@@ -24168,6 +24338,23 @@ var LISTEN = /^listen\s+("?)([A-Za-z_][\w$]*)\1\s*$/i;
 var UNLISTEN = /^unlisten\s+(\*|"?[A-Za-z_][\w$]*"?)\s*$/i;
 var NOTIFY = /^notify\s+("?)([A-Za-z_][\w$]*)\1\s*(?:,\s*'((?:[^']|'')*)')?\s*$/i;
 var RETURNS_ROWS = /^(select|with|values|show|table|explain)\b/i;
+var CLUSTER_DDL = /^(create|drop|alter)\s+database\b/i;
+var IDENT = '(?:"((?:[^"]|"")+)"|([A-Za-z_][A-Za-z0-9_$]*))';
+var CREATE_DATABASE = new RegExp(
+  `^create\\s+database\\s+${IDENT}(?:\\s+with)?(?:\\s+template\\s*(?:=\\s*)?${IDENT})?\\s*$`,
+  "i"
+);
+var DROP_DATABASE = new RegExp(
+  `^drop\\s+database\\s+(if\\s+exists\\s+)?${IDENT}(?:\\s+with\\s*\\(\\s*force\\s*\\))?\\s*$`,
+  "i"
+);
+var RENAME_DATABASE = new RegExp(`^alter\\s+database\\s+${IDENT}\\s+rename\\s+to\\s+${IDENT}\\s*$`, "i");
+var identifier = (quoted, plain) => quoted === void 0 ? plain.toLowerCase() : quoted.replaceAll('""', '"');
+var ROW_LOCK = /\s+for\s+(?:no\s+key\s+update|key\s+share|update|share)(?:\s+of\s+(?:(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s*,\s*(?:(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?))*)?(?:\s+(nowait|skip\s+locked))?\s*$/i;
+var LIMIT = /\s+limit\s+(\d+)(?:\s+offset\s+(\d+))?\s*$/i;
+var FROM_TABLE = /\bfrom\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)/i;
+var UPDATE_TARGET = /^update\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][\w$]*))?\s+set\s+[\s\S]*?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$/i;
+var DELETE_TARGET = /^delete\s+from\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][\w$]*))?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$/i;
 var TYPLEN = {
   bool: 1,
   int2: 2,
@@ -24260,6 +24447,7 @@ var binaryValue = (type, text) => {
   }
 };
 var binaryEncodable = (type) => TEXT_TYPES2.has(type) || ["bool", "int2", "int4", "oid", "int8", "float4", "float8", "bytea", "uuid"].includes(type);
+var mutatesDatabase = (sql) => parse(sql).some((stmt) => !["select", "show", "explain", "transaction", "comment", "no_op"].includes(stmt.type));
 var decodeParam = (oid, format, bytes) => {
   if (bytes === null) return null;
   if (format === 0) return utf83.decode(bytes);
@@ -24308,6 +24496,8 @@ var Connection = class {
     this.socket = socket;
     this.cluster = cluster;
     this.options = options;
+    this.database = cluster.db;
+    this.databaseName = cluster.defaultDatabaseName;
     this.pid = cluster.newPid();
     this.secret = Math.floor(Math.random() * 2147483647);
     cluster.sessions.set(this.pid, this);
@@ -24323,6 +24513,8 @@ var Connection = class {
   waitingForTurn = null;
   waitingForLock = null;
   pendingNotifies = [];
+  database;
+  databaseName;
   frames = new FrameParser();
   inbox = [];
   pumping = false;
@@ -24339,6 +24531,10 @@ var Connection = class {
   prepared = /* @__PURE__ */ new Map();
   portals = /* @__PURE__ */ new Map();
   notifications = [];
+  copyIn = null;
+  copyDrain = false;
+  /** Successful writes in this session's READ COMMITTED transaction workspace. */
+  transaction = null;
   closed = false;
   receive(chunk) {
     let messages;
@@ -24416,6 +24612,20 @@ var Connection = class {
       this.fatal("08P01", "expected startup or password message");
       return;
     }
+    if (this.copyIn && message2.kind === "typed") {
+      await this.handleCopyIn(message2.type, message2.body);
+      return;
+    }
+    if (this.copyDrain && message2.kind === "typed") {
+      if (message2.type === "c" || message2.type === "f") {
+        this.copyDrain = false;
+        this.readyForQuery();
+      } else if (message2.type === "X") {
+        this.socket.end();
+        this.dispose();
+      }
+      return;
+    }
     if (this.skipUntilSync && message2.type !== "S" && message2.type !== "X") return;
     try {
       switch (message2.type) {
@@ -24466,10 +24676,13 @@ var Connection = class {
     }
     this.user = parameters.user ?? "postgres";
     const requested = parameters.database && parameters.database.length > 0 ? parameters.database : this.user;
-    if (this.options.database !== void 0 && requested !== this.options.database) {
+    const database = this.cluster.getDatabase(requested);
+    if (!database || this.options.database !== void 0 && requested !== this.options.database) {
       this.fatal("3D000", `database "${requested}" does not exist`);
       return;
     }
+    this.database = database;
+    this.databaseName = requested;
     if (this.options.password !== void 0) {
       this.scram = new ScramServer(this.options.password);
       this.write(backend.authenticationSASL(["SCRAM-SHA-256"]));
@@ -24533,7 +24746,7 @@ var Connection = class {
   }
   // --- execution ----------------------------------------------------------------------------
   get inTransaction() {
-    return this.cluster.turnHolder === this && this.cluster.db.transactions.inTransaction;
+    return this.transaction !== null;
   }
   status() {
     if (this.aborted) return "E";
@@ -24556,6 +24769,7 @@ var Connection = class {
       return outcome;
     } catch (error) {
       if (this.inTransaction) this.aborted = true;
+      if (error instanceof PostgresError && error.sqlState === "40P01") this.cluster.unlockAll(this, true);
       const status = error instanceof PostgresError ? error.sqlState : "XX000";
       this.options.onLog?.({ pid: this.pid, sql: text, durationMs: performance.now() - started, status });
       throw error;
@@ -24580,7 +24794,7 @@ var Connection = class {
       if (!this.inTransaction) this.flushNotifies();
       return command("NOTIFY");
     }
-    const db = this.cluster.db;
+    if (CLUSTER_DDL.test(text)) return this.executeClusterDdl(text);
     for (; ; ) {
       if (this.cancelled) throw pgError2("internal", "canceling statement due to user request", "57014");
       await this.cluster.acquireTurn(this);
@@ -24590,7 +24804,7 @@ var Connection = class {
         faults.delayStatementMs = void 0;
         await new Promise((resolve) => setTimeout(resolve, ms));
       }
-      if (faults.dropConnection && db.transactions.inTransaction) {
+      if (faults.dropConnection && this.inTransaction) {
         faults.dropConnection = void 0;
         this.destroy();
         throw new ConnectionDropped();
@@ -24602,7 +24816,7 @@ var Connection = class {
       } catch (error) {
         if (error instanceof LockWait) {
           const key = error.key;
-          if (!db.transactions.inTransaction) this.cluster.releaseTurn(this);
+          this.cluster.releaseTurn(this);
           await this.waitForLock(key);
           continue;
         }
@@ -24632,57 +24846,196 @@ var Connection = class {
   }
   /** The engine call itself: statement-atomic, and transaction control handled as the server sees it. */
   runStatement(text, params, control) {
-    const db = this.cluster.db;
-    const tx = db.transactions;
     const faults = this.options.faults;
     if (control && COMMIT.test(text)) {
       if (this.aborted) {
-        tx.rollback();
+        this.transaction = null;
         this.aborted = false;
         return command("ROLLBACK");
       }
       if (faults.failCommit !== void 0) {
         const code = faults.failCommit;
         faults.failCommit = void 0;
-        tx.rollback();
+        this.transaction = null;
         throw pgError2("internal", "could not serialize access due to concurrent update", code);
       }
     }
     if (control && this.aborted && /^(rollback|abort)\b/i.test(text) && !/\bto\b/i.test(text)) {
-      tx.rollback();
+      this.transaction = null;
       this.aborted = false;
       return command("ROLLBACK");
     }
-    const run = () => {
-      const result = this.cluster.as(this, () => db.prepare(text).textResult(...params));
-      return { empty: false, result, tag: commandTag(result) };
-    };
-    if (control) return run();
-    if (tx.inTransaction) {
-      const name = `__wire_${this.pid}`;
-      tx.savepoint(name);
-      try {
-        const outcome = run();
-        tx.releaseSavepoint(name);
-        return outcome;
-      } catch (error) {
-        tx.rollbackToSavepoint(name);
-        tx.releaseSavepoint(name);
-        throw error;
+    if (control) return this.transactionControl(text);
+    const workspace = this.transaction === null ? null : this.openWorkspace();
+    const db = workspace ?? this.database;
+    try {
+      const run = () => {
+        const result = this.cluster.as(this, () => this.runQuery(db, text, params));
+        return { empty: false, result, tag: commandTag(result) };
+      };
+      const outcome = db.transaction(run);
+      if (this.transaction && mutatesDatabase(text)) {
+        this.transaction.statements.push({ kind: "sql", sql: text, params: params.slice() });
       }
+      return outcome;
+    } finally {
+      workspace?.close();
     }
-    return db.transaction(run);
   }
-  /** Release the turn and transaction-scoped locks once no block is open; deliver NOTIFYs at commit. */
+  /** Release the statement turn; transaction-scoped locks live until COMMIT / ROLLBACK. */
   afterStatement() {
-    if (this.cluster.db.transactions.inTransaction) return;
-    this.cluster.unlockAll(this, true);
     this.cluster.releaseTurn(this);
-    this.flushNotifies();
+    if (!this.inTransaction) {
+      this.cluster.unlockAll(this, true);
+      this.flushNotifies();
+    }
+  }
+  transactionControl(text) {
+    const stmt = parse(text)[0];
+    if (stmt?.type !== "transaction") throw pgError2("syntax", "invalid transaction command", "42601");
+    switch (stmt.action) {
+      case "begin":
+        this.transaction ??= { statements: [], savepoints: [] };
+        return command("BEGIN");
+      case "commit": {
+        const transaction = this.transaction;
+        this.transaction = null;
+        if (transaction) {
+          this.database.transaction(() => {
+            for (const logged of transaction.statements) this.replay(this.database, logged);
+          });
+        }
+        return command("COMMIT");
+      }
+      case "rollback":
+        this.transaction = null;
+        return command("ROLLBACK");
+      case "savepoint": {
+        if (!this.transaction) throw pgError2("internal", "SAVEPOINT can only be used in transaction blocks", "25P01");
+        this.transaction.savepoints.push({
+          name: stmt.savepointName,
+          statementCount: this.transaction.statements.length
+        });
+        return command("SAVEPOINT");
+      }
+      case "release": {
+        const index = this.findSavepoint(stmt.savepointName);
+        this.transaction?.savepoints.splice(index);
+        return command("RELEASE");
+      }
+      case "rollback_to": {
+        const index = this.findSavepoint(stmt.savepointName);
+        const savepoint = this.transaction?.savepoints[index];
+        if (!this.transaction || !savepoint) throw pgError2("internal", "savepoint does not exist", "3B001");
+        this.transaction.statements.splice(savepoint.statementCount);
+        this.transaction.savepoints.splice(index + 1);
+        this.aborted = false;
+        return command("ROLLBACK");
+      }
+    }
+  }
+  findSavepoint(name) {
+    if (!this.transaction) throw pgError2("internal", "SAVEPOINT can only be used in transaction blocks", "25P01");
+    for (let i = this.transaction.savepoints.length - 1; i >= 0; i--) {
+      if (this.transaction.savepoints[i]?.name === name) return i;
+    }
+    throw pgError2("internal", `savepoint "${name}" does not exist`, "3B001");
+  }
+  /** Rebase this transaction's successful writes onto the latest committed state. */
+  openWorkspace() {
+    const workspace = this.database.branch();
+    setDatabaseCatalogContext(workspace.state, {
+      name: this.databaseName,
+      names: () => this.cluster.databaseNames()
+    });
+    for (const logged of this.transaction?.statements ?? []) {
+      workspace.transaction(() => this.replay(workspace, logged));
+    }
+    return workspace;
+  }
+  replay(db, logged) {
+    this.cluster.as(this, () => {
+      if (logged.kind === "sql") db.prepare(logged.sql).textResult(...logged.params);
+      else {
+        const env = { ctx: new EngineCtx(db.state), params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
+        executeCopyFromData(env, logged.stmt, logged.data);
+      }
+    });
+  }
+  runQuery(db, text, params) {
+    const lock = ROW_LOCK.exec(text);
+    if (!lock) {
+      const mutation = UPDATE_TARGET.exec(text) ?? DELETE_TARGET.exec(text);
+      if (mutation) {
+        const lockQuery = `SELECT * FROM ${mutation[1]}${mutation[2] ? ` WHERE ${mutation[2]}` : ""}`;
+        this.lockRows(db, lockQuery, params, "wait");
+      }
+      return db.prepare(text).textResult(...params);
+    }
+    let query = text.slice(0, lock.index).trimEnd();
+    const limitMatch = LIMIT.exec(query);
+    const limit = limitMatch ? Number(limitMatch[1]) : Number.POSITIVE_INFINITY;
+    const offset = limitMatch ? Number(limitMatch[2] ?? 0) : 0;
+    if (limitMatch) query = query.slice(0, limitMatch.index).trimEnd();
+    return this.lockRows(db, query, params, lock[1]?.toLowerCase().replace(/\s+/g, "_") ?? "wait", limit, offset);
+  }
+  lockRows(db, query, params, policy, limit = Number.POSITIVE_INFINITY, offset = 0) {
+    const result = db.prepare(query).textResult(...params);
+    const rows = [];
+    for (const row of result.rows.slice(offset)) {
+      const key = this.rowLockKey(db, query, result.columns, row);
+      if (this.cluster.tryLock(this, key, true)) {
+        rows.push(row);
+        if (rows.length >= limit) break;
+        continue;
+      }
+      if (policy === "skip_locked") continue;
+      if (policy === "nowait") {
+        throw pgError2("internal", "could not obtain lock on row in relation", "55P03");
+      }
+      throw new LockWait(key);
+    }
+    return { ...result, rows, rowCount: rows.length };
+  }
+  rowLockKey(db, query, columns, row) {
+    const rawName = FROM_TABLE.exec(query)?.[1] ?? "query";
+    const parts = rawName.split(".").map((part) => part.startsWith('"') ? part.slice(1, -1).replaceAll('""', '"') : part.toLowerCase());
+    const table = db.state.findTable(parts);
+    const primary = table?.constraints.find((constraint) => constraint.kind === "primary_key");
+    const indexes = primary?.columns.map((column) => columns.indexOf(column)) ?? [];
+    const identity = indexes.length > 0 && indexes.every((index) => index >= 0) ? indexes.map((i) => row[i]) : row;
+    return `row:${this.databaseName}:${parts.join(".")}:${JSON.stringify(identity)}`;
   }
   flushNotifies() {
     for (const { channel, payload } of this.pendingNotifies.splice(0)) this.cluster.notify(this, channel, payload);
   }
+  executeClusterDdl(text) {
+    if (this.inTransaction) {
+      throw pgError2("internal", "CREATE/DROP/ALTER DATABASE cannot run inside a transaction block", "25001");
+    }
+    const create = CREATE_DATABASE.exec(text);
+    if (create) {
+      const name = identifier(create[1], create[2]);
+      const template = create[3] === void 0 && create[4] === void 0 ? void 0 : identifier(create[3], create[4]);
+      this.cluster.createDatabase(name, template);
+      return command("CREATE DATABASE");
+    }
+    const drop = DROP_DATABASE.exec(text);
+    if (drop) {
+      const name = identifier(drop[2], drop[3]);
+      if (drop[1] && !this.cluster.getDatabase(name)) return command("DROP DATABASE");
+      this.cluster.dropDatabase(name, this);
+      return command("DROP DATABASE");
+    }
+    const rename = RENAME_DATABASE.exec(text);
+    if (rename) {
+      const from = identifier(rename[1], rename[2]);
+      const to = identifier(rename[3], rename[4]);
+      this.cluster.renameDatabase(from, to, this);
+      return command("ALTER DATABASE");
+    }
+    throw pgError2("syntax", "unsupported CREATE/DROP/ALTER DATABASE option", "0A000");
+  }
   listen(channel) {
     const set = this.cluster.listeners.get(channel) ?? /* @__PURE__ */ new Set();
     set.add(this);
@@ -24703,6 +25056,24 @@ var Connection = class {
       this.readyForQuery();
       return;
     }
+    if (statements.length === 1) {
+      const copy = this.copyStatement(statements[0]);
+      if (copy?.direction === "from") {
+        await this.beginCopyIn(copy);
+        return;
+      }
+      if (copy?.direction === "to") {
+        try {
+          const outcome = await this.execute(statements[0]);
+          this.sendCopyOut(outcome, this.copyColumnCount(copy));
+        } catch (error) {
+          this.write(backend.errorResponse(errorFields(error)));
+          if (this.inTransaction) this.aborted = true;
+        }
+        this.readyForQuery();
+        return;
+      }
+    }
     const implicit = statements.length > 1 && !this.inTransaction && !statements.some((s) => TX_CONTROL.test(s));
     let failed = false;
     try {
@@ -24723,6 +25094,138 @@ var Connection = class {
     if (failed && this.inTransaction) this.aborted = true;
     this.readyForQuery();
   }
+  copyStatement(sql) {
+    try {
+      const statements = parse(sql);
+      const stmt = statements.length === 1 ? statements[0] : void 0;
+      return stmt?.type === "copy" ? stmt : null;
+    } catch {
+      return null;
+    }
+  }
+  copyColumnCount(stmt) {
+    if (stmt.columns) return stmt.columns.length;
+    if (stmt.table) return this.database.state.findTable(stmt.table)?.columns.length ?? 0;
+    return 0;
+  }
+  async handleCopyIn(type, body) {
+    const copy = this.copyIn;
+    if (type === "d") {
+      try {
+        copy.buffer += copy.decoder.decode(body.rest(), { stream: true });
+        this.flushCopyRecords(copy, false);
+      } catch (error) {
+        this.abortCopyIn(copy, error, true);
+      }
+      return;
+    }
+    if (type === "f") {
+      const detail = body.cstring();
+      this.abortCopyIn(copy, pgError2("internal", `COPY from stdin failed: ${detail}`, "57014"), false);
+      return;
+    }
+    if (type === "c") {
+      this.finishCopyIn(copy);
+      return;
+    }
+    if (type === "H") return;
+    if (type === "X") {
+      this.socket.end();
+      this.dispose();
+      return;
+    }
+    this.fatal("08P01", `unexpected frontend message type ${JSON.stringify(type)} during COPY`);
+  }
+  async beginCopyIn(stmt) {
+    await this.cluster.acquireTurn(this);
+    const workspace = this.transaction ? this.openWorkspace() : null;
+    const database = workspace ?? this.database;
+    database.transactions.begin();
+    this.copyIn = {
+      stmt,
+      database,
+      workspace: workspace !== null,
+      buffer: "",
+      decoder: new TextDecoder(),
+      rowCount: 0,
+      headerPending: stmt.options.header === true || String(stmt.options.header ?? "").toLowerCase() === "true",
+      loggedData: ""
+    };
+    this.write(backend.copyInResponse(this.copyColumnCount(stmt)));
+  }
+  finishCopyIn(copy) {
+    const tx = copy.database.transactions;
+    try {
+      copy.buffer += copy.decoder.decode();
+      this.flushCopyRecords(copy, true);
+      tx.commit();
+      if (copy.workspace) {
+        this.transaction?.statements.push({ kind: "copy", stmt: copy.stmt, data: copy.loggedData });
+        copy.database.close();
+      }
+      this.copyIn = null;
+      this.write(backend.commandComplete(`COPY ${copy.rowCount}`));
+      this.cluster.releaseTurn(this);
+      this.readyForQuery();
+    } catch (error) {
+      this.abortCopyIn(copy, error, false);
+    }
+  }
+  flushCopyRecords(copy, final) {
+    const format = String(copy.stmt.options.format ?? "text").toLowerCase();
+    const quote = String(copy.stmt.options.quote ?? '"');
+    const boundaries = [];
+    let quoted = false;
+    for (let i = 0; i < copy.buffer.length; i++) {
+      const char = copy.buffer[i];
+      if (format === "csv" && char === quote) {
+        if (quoted && copy.buffer[i + 1] === quote) i++;
+        else quoted = !quoted;
+      } else if (char === "\n" && !quoted) {
+        boundaries.push(i + 1);
+      }
+    }
+    if (final && quoted) {
+      throw new PostgresError("invalid_text_representation", "unterminated CSV quoted field", "22P04");
+    }
+    const end = boundaries.at(-1) ?? 0;
+    const data = final ? copy.buffer : end > 0 ? copy.buffer.slice(0, end) : "";
+    if (data === "") return;
+    copy.buffer = final ? "" : copy.buffer.slice(end);
+    const stmt = copy.headerPending ? copy.stmt : { ...copy.stmt, options: { ...copy.stmt.options, header: false } };
+    const env = {
+      ctx: new EngineCtx(copy.database.state),
+      params: null,
+      ctes: /* @__PURE__ */ new Map(),
+      outer: null
+    };
+    const result = this.cluster.as(this, () => executeCopyFromData(env, stmt, data));
+    copy.rowCount += result.rowCount;
+    copy.loggedData += data;
+    copy.headerPending = false;
+  }
+  abortCopyIn(copy, error, drain) {
+    const tx = copy.database.transactions;
+    if (tx.inTransaction) tx.rollback();
+    if (copy.workspace) copy.database.close();
+    if (this.inTransaction) this.aborted = true;
+    this.cluster.releaseTurn(this);
+    this.copyIn = null;
+    this.copyDrain = drain;
+    this.write(backend.errorResponse(errorFields(error)));
+    if (!drain) this.readyForQuery();
+  }
+  sendCopyOut(outcome, columns) {
+    if (outcome.empty) throw pgError2("internal", "COPY TO produced no result", "XX000");
+    this.write(backend.copyOutResponse(columns));
+    for (const row of outcome.result.rows) {
+      const line = row[0] ?? "";
+      this.write(backend.copyData(utf83.encode(`${line}
+`)));
+    }
+    this.write(backend.copyDone());
+    this.write(backend.commandComplete(outcome.tag));
+  }
   sendOutcome(outcome, resultFormats, opts = { rowDescription: false }) {
     const from = opts.from ?? 0;
     const limit = opts.limit ?? 0;
@@ -24777,7 +25280,7 @@ var Connection = class {
     for (let i = 0; i < count; i++) paramOids.push(body.i32());
     const text = sql.trim();
     if (text !== "" && !LISTEN.test(text) && !UNLISTEN.test(text) && !NOTIFY.test(text) && !TX_CONTROL.test(text)) {
-      this.cluster.db.prepare(text);
+      if (!CLUSTER_DDL.test(text)) this.database.prepare(text);
     }
     if (name !== "" && this.prepared.has(name)) {
       throw pgError2("internal", `prepared statement "${name}" already exists`, "42P05");
@@ -24836,7 +25339,7 @@ var Connection = class {
    */
   async shapeOf(prepared) {
     if (!RETURNS_ROWS.test(prepared.sql)) return null;
-    const db = this.cluster.db;
+    const db = this.database;
     await this.cluster.acquireTurn(this);
     try {
       const params = prepared.paramOids.map(() => null);
@@ -24953,7 +25456,8 @@ var isSnapshot = (value) => typeof value === "object" && value !== null && "open
 var serve = (input = {}) => {
   const options = normalize(input);
   const database = isSnapshot(options.database) ? options.database.open() : options.database ?? new Database();
-  const cluster = new Cluster(database);
+  const initialName = options.databaseName ?? "postgres";
+  const cluster = new Cluster(database, initialName);
   const faults = {};
   const connections = /* @__PURE__ */ new Set();
   const host = options.host ?? "127.0.0.1";
@@ -24977,13 +25481,19 @@ var serve = (input = {}) => {
       server.removeListener("error", reject);
       const address = server.address();
       const port = typeof address === "object" && address !== null ? address.port : 0;
-      const name = options.databaseName ?? "postgres";
+      const name = initialName;
       const auth = options.password ? `${encodeURIComponent(user)}:${encodeURIComponent(options.password)}@` : `${encodeURIComponent(user)}@`;
       resolve({
         port,
         host,
         connectionString: `postgres://${auth}${host}:${port}/${encodeURIComponent(name)}`,
         database,
+        databaseNames() {
+          return cluster.databaseNames();
+        },
+        getDatabase(databaseName) {
+          return cluster.requireDatabase(databaseName);
+        },
         server,
         get connections() {
           return connections.size;
@@ -24991,8 +25501,8 @@ var serve = (input = {}) => {
         fault(next) {
           Object.assign(faults, next);
         },
-        snapshot() {
-          return database.snapshot();
+        snapshot(databaseName = initialName) {
+          return cluster.requireDatabase(databaseName).snapshot();
         },
         close() {
           for (const connection of connections) connection.destroy();