@youtyan/code-viewer 0.2.3 → 0.2.4

package/dist/code-viewer.js

@@ -3884,6 +3884,9 @@ import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
 function dockerDatabasesCacheKey(serviceName, kind, cwd) {
   return `${serviceName}\x00${kind}\x00${cwd}`;
 }
+function dockerSchemasCacheKey(serviceName, kind, cwd, database) {
+  return `${serviceName}\x00${kind}\x00${cwd}\x00${database}`;
+}
 function setDockerDatabasesCache(key, value, ttlMs, now = Date.now()) {
   const cachedValue = [...value];
   dockerDatabasesCache.set(key, {
@@ -3892,6 +3895,14 @@ function setDockerDatabasesCache(key, value, ttlMs, now = Date.now()) {
   });
   return [...cachedValue];
 }
+function setDockerSchemasCache(key, value, ttlMs, now = Date.now()) {
+  const cachedValue = [...value];
+  dockerSchemasCache.set(key, {
+    value: cachedValue,
+    expiresAt: now + ttlMs
+  });
+  return [...cachedValue];
+}
 function fallbackDockerDatabases(defaultDb) {
   return defaultDb ? [defaultDb] : [];
 }
@@ -4209,10 +4220,26 @@ function createDockerAdapter(config) {
   }
   const columnCache = new Map;
   const tableMetaCache = createTableMetaCache();
+  function currentPostgresSchema() {
+    return config.schema || "public";
+  }
+  function postgresSchemaLiteral() {
+    return escapeSqlString(currentPostgresSchema());
+  }
+  function tableIdentifier(table) {
+    if (config.kind === "postgresql") {
+      return `${sanitizeIdentifier(currentPostgresSchema(), config.kind)}.${sanitizeIdentifier(table, config.kind)}`;
+    }
+    return sanitizeIdentifier(table, config.kind);
+  }
+  function postgresRegclassLiteral(table) {
+    return escapeSqlString(`${sanitizeIdentifier(currentPostgresSchema(), "postgresql")}.${sanitizeIdentifier(table, "postgresql")}`);
+  }
   function buildColumnsSql(table) {
     const tableLiteral = table.replace(/'/g, "''");
     if (config.kind === "postgresql") {
-      return `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, CASE WHEN pk.column_name IS NULL THEN 'NO' ELSE 'YES' END FROM information_schema.columns c LEFT JOIN (SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.table_name = kcu.table_name WHERE tc.table_schema = 'public' AND tc.table_name = '${tableLiteral}' AND tc.constraint_type = 'PRIMARY KEY') pk ON pk.column_name = c.column_name WHERE c.table_schema = 'public' AND c.table_name = '${tableLiteral}' ORDER BY c.ordinal_position`;
+      const schemaLiteral = postgresSchemaLiteral();
+      return `SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, CASE WHEN pk.column_name IS NULL THEN 'NO' ELSE 'YES' END FROM information_schema.columns c LEFT JOIN (SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.table_name = kcu.table_name WHERE tc.table_schema = ${schemaLiteral} AND tc.table_name = '${tableLiteral}' AND tc.constraint_type = 'PRIMARY KEY') pk ON pk.column_name = c.column_name WHERE c.table_schema = ${schemaLiteral} AND c.table_name = '${tableLiteral}' ORDER BY c.ordinal_position`;
     }
     return `SELECT column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${tableLiteral}' ORDER BY ordinal_position`;
   }
@@ -4250,37 +4277,8 @@ function createDockerAdapter(config) {
     return countResult.rows.length > 0 ? Number(countResult.rows[0][0]) || 0 : 0;
   }
   function fetchColumnsUncached(table) {
-    let sql;
-    if (config.kind === "postgresql") {
-      sql = `SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${table.replace(/'/g, "''")}' ORDER BY ordinal_position`;
-    } else {
-      sql = `SELECT column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = '${table.replace(/'/g, "''")}' ORDER BY ordinal_position`;
-    }
-    const result = exec(sql);
-    if (config.kind === "postgresql") {
-      const pkSql = `SELECT a.attname FROM pg_index i JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indrelid = '${table.replace(/'/g, "''")}'::regclass AND i.indisprimary`;
-      let pkCols;
-      try {
-        const pkResult = exec(pkSql);
-        pkCols = new Set(pkResult.rows.map((r) => r[0]));
-      } catch {
-        pkCols = new Set;
-      }
-      return result.rows.map((row) => ({
-        name: row[0],
-        type: row[1],
-        nullable: row[2] === "YES",
-        primaryKey: pkCols.has(row[0]),
-        defaultValue: row[3] === "" ? null : row[3]
-      }));
-    }
-    return result.rows.map((row) => ({
-      name: row[0],
-      type: row[1],
-      nullable: row[2] === "YES",
-      primaryKey: row[4] === "PRI",
-      defaultValue: row[3] === "NULL" ? null : row[3]
-    }));
+    const result = exec(buildColumnsSql(table));
+    return columnsFromInfoRows(result.rows);
   }
   const adapter = {
     kind: config.kind,
@@ -4289,7 +4287,7 @@ function createDockerAdapter(config) {
     getTables() {
       let sql;
       if (config.kind === "postgresql") {
-        sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`;
+        sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = ${postgresSchemaLiteral()} ORDER BY table_name`;
       } else {
         sql = `SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = DATABASE() ORDER BY table_name`;
       }
@@ -4311,7 +4309,7 @@ function createDockerAdapter(config) {
     getIndexes() {
       let sql;
       if (config.kind === "postgresql") {
-        sql = `SELECT indexname, tablename FROM pg_indexes WHERE schemaname = 'public' AND indexname NOT LIKE 'pg_%' ORDER BY indexname`;
+        sql = `SELECT indexname, tablename FROM pg_indexes WHERE schemaname = ${postgresSchemaLiteral()} AND indexname NOT LIKE 'pg_%' ORDER BY indexname`;
       } else {
         sql = `SELECT DISTINCT index_name, table_name, non_unique FROM information_schema.statistics WHERE table_schema = DATABASE() ORDER BY index_name`;
       }
@@ -4334,18 +4332,25 @@ function createDockerAdapter(config) {
     getForeignKeys() {
       let sql;
       if (config.kind === "postgresql") {
-        sql = `SELECT tc.table_name, kcu.column_name, ccu.table_name, ccu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = 'public'`;
+        sql = `SELECT tc.table_schema, tc.table_name, kcu.column_name, ccu.table_schema, ccu.table_name, ccu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = ${postgresSchemaLiteral()}`;
       } else {
         sql = `SELECT table_name, column_name, referenced_table_name, referenced_column_name FROM information_schema.key_column_usage WHERE table_schema = DATABASE() AND referenced_table_name IS NOT NULL`;
       }
       try {
         const result = exec(sql);
-        return result.rows.map((row) => ({
+        return result.rows.map((row) => config.kind === "postgresql" ? {
+          fromSchema: row[0],
+          fromTable: row[1],
+          fromColumn: row[2],
+          toSchema: row[3],
+          toTable: row[4],
+          toColumn: row[5]
+        } : {
           fromTable: row[0],
           fromColumn: row[1],
           toTable: row[2],
           toColumn: row[3]
-        }));
+        });
       } catch {
         return [];
       }
@@ -4363,7 +4368,7 @@ function createDockerAdapter(config) {
       let sql;
       if (config.kind === "postgresql") {
         const inList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-        sql = `SELECT table_name, column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
+        sql = `SELECT table_name, column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema = ${postgresSchemaLiteral()} AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
       } else {
         const inList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
         sql = `SELECT table_name, column_name, column_type, is_nullable, column_default, column_key FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name IN (${inList}) ORDER BY table_name, ordinal_position`;
@@ -4381,7 +4386,7 @@ function createDockerAdapter(config) {
         if (config.kind === "postgresql") {
           try {
             const pkInList = uncached.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-            const pkResult = exec(`SELECT c.relname, a.attname FROM pg_index i JOIN pg_class c ON c.oid = i.indrelid JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indisprimary AND c.relname IN (${pkInList})`);
+            const pkResult = exec(`SELECT c.relname, a.attname FROM pg_index i JOIN pg_class c ON c.oid = i.indrelid JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) WHERE i.indisprimary AND n.nspname = ${postgresSchemaLiteral()} AND c.relname IN (${pkInList})`);
             for (const row of pkResult.rows) {
               const existing = pkMap.get(row[0]) || new Set;
               existing.add(row[1]);
@@ -4424,7 +4429,7 @@ function createDockerAdapter(config) {
       return result;
     },
     getTableRowCount(table) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const result = exec(`SELECT COUNT(*) FROM ${id}`);
       return result.rows.length > 0 ? Number(result.rows[0][0]) || 0 : 0;
     },
@@ -4433,7 +4438,7 @@ function createDockerAdapter(config) {
       if (tables.length === 0)
         return result;
       const parts = tables.map((t) => {
-        const id = sanitizeIdentifier(t, config.kind);
+        const id = tableIdentifier(t);
         return `SELECT '${t.replace(/'/g, "''")}' AS tbl, COUNT(*) AS cnt FROM ${id}`;
       });
       const sql = parts.join(" UNION ALL ");
@@ -4444,7 +4449,7 @@ function createDockerAdapter(config) {
         }
       } catch {
         for (const t of tables) {
-          const id = sanitizeIdentifier(t, config.kind);
+          const id = tableIdentifier(t);
           try {
             const r = exec(`SELECT COUNT(*) FROM ${id}`);
             result.set(t, r.rows.length > 0 ? Number(r.rows[0][0]) || 0 : 0);
@@ -4456,7 +4461,7 @@ function createDockerAdapter(config) {
       return result;
     },
     async getTablePageWithMeta(table, options) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const order = buildOrderClause(options.orderBy, config.kind);
       const countSql = `SELECT COUNT(*) AS cnt FROM ${id}`;
       const columnsPromise = tableMetaCache.getColumns(table, () => fetchColumnsAsyncUncached(table));
@@ -4471,7 +4476,7 @@ function createDockerAdapter(config) {
       return tablePageMetaFromResults(columns, dataResult, totalRows);
     },
     async getFilteredTablePageWithMeta(table, options) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const order = buildOrderClause(options.orderBy, config.kind);
       const where = buildDockerFilterWhere(options.grouped, config.kind);
       const whereClause = where ? ` WHERE ${where}` : "";
@@ -4488,7 +4493,7 @@ function createDockerAdapter(config) {
       return tablePageMetaFromResults(columns, dataResult, rowCountFromResult(countResult));
     },
     getTablePage(table, options) {
-      const id = sanitizeIdentifier(table, config.kind);
+      const id = tableIdentifier(table);
       const order = buildOrderClause(options.orderBy, config.kind);
       const cols = this.getColumns(table);
       const selectList = buildTableSelectList(cols, config.kind);
@@ -4522,10 +4527,8 @@ function createDockerAdapter(config) {
       if (BLOCKED_RE.test(upper)) {
         throw new Error("Query contains a disallowed statement keyword");
       }
-      const readOnlyPreamble = config.kind === "postgresql" ? "BEGIN TRANSACTION READ ONLY; " : "SET SESSION TRANSACTION READ ONLY; ";
-      const readOnlyPostamble = config.kind === "postgresql" ? "; COMMIT" : "; SET SESSION TRANSACTION READ WRITE";
       const stripped = trimmed.replace(/;\s*$/, "");
-      const limited = `${readOnlyPreamble}${stripped} LIMIT ${maxRows}${readOnlyPostamble}`;
+      const limited = config.kind === "postgresql" ? `BEGIN TRANSACTION READ ONLY; SET LOCAL search_path = ${sanitizeIdentifier(currentPostgresSchema(), config.kind)}; ${stripped} LIMIT ${maxRows}; COMMIT` : `SET SESSION TRANSACTION READ ONLY; ${stripped} LIMIT ${maxRows}; SET SESSION TRANSACTION READ WRITE`;
       const result = exec(limited);
       const columnNames = config.kind === "mysql" && result.columns.length > 0 ? result.columns : result.rows.length > 0 ? Array.from({ length: result.rows[0].length }, (_, i) => `col${i + 1}`) : [];
       return {
@@ -4541,14 +4544,14 @@ function createDockerAdapter(config) {
     getCreateStatement(table) {
       if (config.kind === "mysql") {
         try {
-          const result = exec(`SHOW CREATE TABLE ${sanitizeIdentifier(table, config.kind)}`);
+          const result = exec(`SHOW CREATE TABLE ${tableIdentifier(table)}`);
           return result.rows.length > 0 ? result.rows[0][1] || "" : "";
         } catch {
           return "";
         }
       }
       try {
-        const result = exec(`SELECT 'CREATE TABLE ' || '${table.replace(/'/g, "''")}' || ' (...)' AS ddl`);
+        const result = exec(`SELECT 'CREATE TABLE ' || ${escapeSqlString(tableIdentifier(table))} || ' (...)' AS ddl`);
         return result.rows.length > 0 ? result.rows[0][0] || "" : "";
       } catch {
         return "";
@@ -4559,7 +4562,7 @@ function createDockerAdapter(config) {
       if (config.kind === "mysql") {
         sql = `SELECT trigger_name, action_statement FROM information_schema.triggers WHERE event_object_schema = DATABASE() AND event_object_table = '${table.replace(/'/g, "''")}'`;
       } else {
-        sql = `SELECT tgname, pg_get_triggerdef(oid) FROM pg_trigger WHERE tgrelid = '${table.replace(/'/g, "''")}'::regclass AND NOT tgisinternal`;
+        sql = `SELECT tgname, pg_get_triggerdef(oid) FROM pg_trigger WHERE tgrelid = ${postgresRegclassLiteral(table)}::regclass AND NOT tgisinternal`;
       }
       try {
         const result = exec(sql);
@@ -4617,7 +4620,7 @@ function listDockerDatabases(serviceName, kind, env, cwd) {
     return [...cached.value];
   const containerName = resolveRunningComposeContainerName(serviceName, cwd);
   if (!containerName) {
-    return setDockerDatabasesCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+    return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
   const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || env.POSTGRES_USERNAME || env.MYSQL_USERNAME || env.USER || "root";
   const password = env.POSTGRES_PASSWORD || env.MYSQL_PASSWORD || env.MARIADB_PASSWORD || "";
@@ -4654,7 +4657,43 @@ function listDockerDatabases(serviceName, kind, env, cwd) {
     return setDockerDatabasesCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
   }
 }
-function openDockerAdapter(serviceName, kind, env, cwd, overrideDatabase) {
+function listDockerSchemas(serviceName, kind, env, cwd, overrideDatabase) {
+  if (kind !== "postgresql")
+    return [];
+  const user = env.POSTGRES_USER || env.POSTGRES_USERNAME || "postgres";
+  const password = env.POSTGRES_PASSWORD || "";
+  const database = overrideDatabase || env.POSTGRES_DB || "postgres";
+  const cacheKey = dockerSchemasCacheKey(serviceName, kind, cwd, database);
+  const now = Date.now();
+  const cached = dockerSchemasCache.get(cacheKey);
+  if (cached && cached.expiresAt > now)
+    return [...cached.value];
+  const containerName = resolveRunningComposeContainerName(serviceName, cwd);
+  if (!containerName) {
+    return setDockerSchemasCache(cacheKey, [], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+  }
+  const config = {
+    kind,
+    containerName,
+    user,
+    password,
+    database
+  };
+  try {
+    const sql = `SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('pg_catalog', 'information_schema') AND schema_name NOT LIKE 'pg_toast%' AND schema_name NOT LIKE 'pg_temp_%' AND schema_name NOT LIKE 'pg_toast_temp_%' AND has_schema_privilege(schema_name, 'USAGE') ORDER BY CASE WHEN schema_name = 'public' THEN 0 ELSE 1 END, schema_name`;
+    const result = execInContainer(config, sql);
+    if (result.code !== 0) {
+      return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+    }
+    const parsed = parseTsvOutput(result.stdout, false);
+    const schemas = parsed.rows.map((r) => r[0]).filter(Boolean);
+    const value = schemas.length > 0 ? schemas : ["public"];
+    return setDockerSchemasCache(cacheKey, value, DOCKER_DATABASES_POSITIVE_TTL_MS, now);
+  } catch {
+    return setDockerSchemasCache(cacheKey, ["public"], DOCKER_DATABASES_NEGATIVE_TTL_MS, now);
+  }
+}
+function openDockerAdapter(serviceName, kind, env, cwd, overrideDatabase, schema) {
   const containerName = resolveRunningComposeContainerNameOrThrow(serviceName, cwd);
   const user = env.POSTGRES_USER || env.MYSQL_USER || env.MARIADB_USER || (kind === "postgresql" ? "postgres" : "root");
   const password = env.POSTGRES_PASSWORD || env.MYSQL_PASSWORD || env.MYSQL_ROOT_PASSWORD || env.MARIADB_PASSWORD || env.MARIADB_ROOT_PASSWORD || "";
@@ -4664,14 +4703,16 @@ function openDockerAdapter(serviceName, kind, env, cwd, overrideDatabase) {
     containerName,
     user,
     password,
-    database
+    database,
+    ...kind === "postgresql" && schema ? { schema } : {}
   });
 }
-var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, spawnSyncImpl2, MYSQL_SPATIAL_TYPES;
+var COLUMNS_TTL_MS = 30000, ROWCOUNT_TTL_MS = 15000, DOCKER_DATABASES_POSITIVE_TTL_MS = 15000, DOCKER_DATABASES_NEGATIVE_TTL_MS = 3000, dockerDatabasesCache, dockerSchemasCache, spawnSyncImpl2, MYSQL_SPATIAL_TYPES;
 var init_docker = __esm(() => {
   init_sql_snapshot();
   init_docker_utils();
   dockerDatabasesCache = new Map;
+  dockerSchemasCache = new Map;
   spawnSyncImpl2 = spawnSync3;
   MYSQL_SPATIAL_TYPES = new Set([
     "geometry",
@@ -5957,6 +5998,12 @@ function createDockerAdapterCache(maxEntries = DEFAULT_MAX_DOCKER_ADAPTER_CACHE,
       const cached = cache.get(key);
       if (cached)
         closeEntry(key, cached);
+    },
+    closePrefix(prefix) {
+      for (const [key, entry] of Array.from(cache)) {
+        if (key.startsWith(prefix))
+          closeEntry(key, entry);
+      }
     }
   };
 }
@@ -7049,12 +7096,18 @@ function deleteQueryHistoryEntry(state, id) {
     entries: state.entries.filter((e) => e.id !== id)
   };
 }
-function clearQueryHistory(state, dbId) {
+function clearQueryHistory(state, dbId, schema) {
   if (!dbId)
     return emptyState();
   return {
     version: 1,
-    entries: state.entries.filter((e) => e.dbId !== dbId)
+    entries: state.entries.filter((e) => {
+      if (e.dbId !== dbId)
+        return true;
+      if (schema === undefined)
+        return false;
+      return (e.schema || "public") !== schema;
+    })
   };
 }
 var CODE_VIEWER_DIR2 = ".code-viewer", HISTORY_FILE_NAME = "query-history.json", MAX_ENTRIES2 = 200, MAX_PREVIEW_ROWS = 100, MAX_JSON_BYTES = 1e6;
@@ -7095,6 +7148,9 @@ async function getStoreDb(cwd) {
   storeDb.exec("PRAGMA journal_mode=WAL");
   storeDb.exec("PRAGMA foreign_keys=ON");
   storeDb.exec(SCHEMA_SQL);
+  try {
+    storeDb.exec("ALTER TABLE snapshots ADD COLUMN schema_name TEXT");
+  } catch {}
   return storeDb;
 }
 function makeId2(prefix) {
@@ -7103,10 +7159,10 @@ function makeId2(prefix) {
 function hashPayload(payloadJson) {
   return createHash4("sha256").update(payloadJson).digest("hex");
 }
-async function createSnapshot(cwd, dbId, kind, tables, note) {
+async function createSnapshot(cwd, dbId, kind, tables, note, schema) {
   const db = await getStoreDb(cwd);
   const id = makeId2("snap");
-  db.prepare("INSERT INTO snapshots (id, db_id, kind, note, created_at, status) VALUES (?, ?, ?, ?, ?, ?)").run(id, dbId, kind, note, new Date().toISOString(), "running");
+  db.prepare("INSERT INTO snapshots (id, db_id, schema_name, kind, note, created_at, status) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, dbId, schema ?? null, kind, note, new Date().toISOString(), "running");
   for (const t of tables) {
     db.prepare("INSERT INTO snapshot_tables (snapshot_id, table_name) VALUES (?, ?)").run(id, t);
   }
@@ -7135,19 +7191,22 @@ async function finalizeSnapshot(cwd, snapshotId, error) {
     db.prepare("UPDATE snapshots SET status = 'done' WHERE id = ?").run(snapshotId);
   }
 }
-async function listSnapshots(cwd, dbId) {
+async function listSnapshots(cwd, dbId, schema) {
   const db = await getStoreDb(cwd);
   let rows;
-  if (dbId) {
-    rows = db.prepare("SELECT id, db_id, kind, note, created_at, status, error_message FROM snapshots WHERE db_id = ? ORDER BY created_at DESC").all(dbId);
+  if (dbId && schema !== undefined) {
+    rows = db.prepare("SELECT id, db_id, schema_name, kind, note, created_at, status, error_message FROM snapshots WHERE db_id = ? AND COALESCE(schema_name, 'public') = ? ORDER BY created_at DESC").all(dbId, schema);
+  } else if (dbId) {
+    rows = db.prepare("SELECT id, db_id, schema_name, kind, note, created_at, status, error_message FROM snapshots WHERE db_id = ? ORDER BY created_at DESC").all(dbId);
   } else {
-    rows = db.prepare("SELECT id, db_id, kind, note, created_at, status, error_message FROM snapshots ORDER BY created_at DESC").all();
+    rows = db.prepare("SELECT id, db_id, schema_name, kind, note, created_at, status, error_message FROM snapshots ORDER BY created_at DESC").all();
   }
   return rows.map((r) => {
     const tableRows = db.prepare("SELECT table_name FROM snapshot_tables WHERE snapshot_id = ?").all(r.id);
     return {
       id: r.id,
       dbId: r.db_id,
+      ...r.schema_name ? { schema: r.schema_name } : {},
       kind: r.kind,
       note: r.note,
       createdAt: r.created_at,
@@ -7172,8 +7231,22 @@ async function deleteSnapshot(cwd, snapshotId) {
     }
   }
 }
+function getSnapshotScope(db, snapshotId) {
+  const row = db.prepare("SELECT db_id, COALESCE(schema_name, 'public') AS schema_name FROM snapshots WHERE id = ?").get(snapshotId);
+  if (!row)
+    throw new Error(`snapshot not found: ${snapshotId}`);
+  return { dbId: row.db_id, schema: row.schema_name };
+}
+function assertSameSnapshotScope(db, beforeId, afterId) {
+  const before = getSnapshotScope(db, beforeId);
+  const after = getSnapshotScope(db, afterId);
+  if (before.dbId !== after.dbId || before.schema !== after.schema) {
+    throw new Error(`cannot compare snapshots from different database/schema (${before.dbId}:${before.schema} vs ${after.dbId}:${after.schema})`);
+  }
+}
 async function computeDiffTables(cwd, beforeId, afterId) {
   const db = await getStoreDb(cwd);
+  assertSameSnapshotScope(db, beforeId, afterId);
   const beforeTables = db.prepare("SELECT table_name, table_hash, row_count FROM snapshot_tables WHERE snapshot_id = ?").all(beforeId);
   const afterTables = db.prepare("SELECT table_name, table_hash, row_count FROM snapshot_tables WHERE snapshot_id = ?").all(afterId);
   const beforeMap = new Map(beforeTables.map((t) => [t.table_name, t]));
@@ -7196,7 +7269,7 @@ async function computeDiffTables(cwd, beforeId, afterId) {
     if (!b) {
       results.push({
         tableName: table,
-        insertedCount: a.row_count,
+        insertedCount: a ? a.row_count : 0,
         updatedCount: 0,
         deletedCount: 0,
         unchangedCount: 0
@@ -7245,6 +7318,7 @@ async function computeDiffTables(cwd, beforeId, afterId) {
 }
 async function computeDiffRows(cwd, beforeId, afterId, table, offset = 0, limit = 200) {
   const db = await getStoreDb(cwd);
+  assertSameSnapshotScope(db, beforeId, afterId);
   const allDiffRows = [];
   const inserted = db.prepare(`SELECT a.row_key_json, a.payload_hash
        FROM snapshot_rows a
@@ -7314,6 +7388,7 @@ var CODE_VIEWER_DIR3 = ".code-viewer", SNAPSHOT_DB_NAME = "db-snapshots.sqlite",
 CREATE TABLE IF NOT EXISTS snapshots (
   id TEXT PRIMARY KEY,
   db_id TEXT NOT NULL,
+  schema_name TEXT,
   kind TEXT NOT NULL,
   note TEXT NOT NULL DEFAULT '',
   created_at TEXT NOT NULL,
@@ -7367,7 +7442,7 @@ async function runSnapshot(cwd, source, dbId, containers, note, onProgress, opti
     throw new Error("data source does not support snapshot (missing SnapshotIterable capability)");
   }
   const snapshotSource = source;
-  const snapshotId = await createSnapshot(cwd, dbId, snapshotSource.kind, containers, note);
+  const snapshotId = await createSnapshot(cwd, dbId, snapshotSource.kind, containers, note, options.schema);
   try {
     options.onSnapshotId?.(snapshotId);
     for (const container of containers) {
@@ -7600,14 +7675,40 @@ function ensureInit() {
 async function getAdapter(r, _cwd) {
   if (r.docker) {
     const docker = r.docker;
-    return dockerAdapterCache.getOrOpen(r.dbId, () => openDockerAdapter(docker.serviceName, docker.kind, docker.env, docker.composeDir, docker.database));
+    const cacheKey = r.schema ? `${r.dbId}\x00schema=${r.schema}` : r.dbId;
+    return dockerAdapterCache.getOrOpen(cacheKey, () => openDockerAdapter(docker.serviceName, docker.kind, docker.env, docker.composeDir, docker.database, r.schema));
   }
   return getConnection(r.resolved);
 }
 function sanitizeFilename(name) {
   return name.replace(/["\\\r\n\x00-\x1f]/g, "_");
 }
-function resolveDb(cwd, dbParam, omitDirNames) {
+function normalizeSchemaParam(value) {
+  if (value === undefined || value === null || value === "")
+    return;
+  if (value.length > MAX_SCHEMA_NAME_LEN) {
+    return textError("invalid schema parameter", 400);
+  }
+  if (/[\x00-\x1f\x7f]/.test(value)) {
+    return textError("invalid schema parameter", 400);
+  }
+  return value;
+}
+function resolvePostgresSchema(info, requestedSchema) {
+  if (info.kind !== "postgresql")
+    return;
+  const schemas = listDockerSchemas(info.serviceName, "postgresql", info.env, info.composeDir, info.database);
+  if (requestedSchema) {
+    if (!schemas.includes(requestedSchema)) {
+      return textError(`schema not found: ${requestedSchema}`, 404);
+    }
+    return requestedSchema;
+  }
+  if (schemas.includes("public"))
+    return "public";
+  return schemas[0] || "public";
+}
+function resolveDb(cwd, dbParam, omitDirNames, schemaParam) {
   if (!dbParam)
     return textError("missing db parameter", 400);
   if (dbParam.startsWith("docker:")) {
@@ -7624,7 +7725,18 @@ function resolveDb(cwd, dbParam, omitDirNames) {
       return textError("elasticsearch services must use the /_db/elasticsearch/* routes", 400);
     }
     const resolved2 = parsed.database ? { ...info, database: parsed.database } : info;
-    return { resolved: dbParam, dbId: dbParam, docker: resolved2 };
+    const requestedSchema = normalizeSchemaParam(schemaParam);
+    if (requestedSchema instanceof Response)
+      return requestedSchema;
+    const schema = resolvePostgresSchema(resolved2, requestedSchema);
+    if (schema instanceof Response)
+      return schema;
+    return {
+      resolved: dbParam,
+      dbId: dbParam,
+      docker: resolved2,
+      ...schema ? { schema } : {}
+    };
   }
   const resolved = validateDbPath(cwd, dbParam);
   if (!resolved)
@@ -7679,8 +7791,24 @@ function handleFiles(cwd, omitDirNames) {
   };
   return json(body);
 }
+function handleSchemas(cwd, url, omitDirNames) {
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
+  if (r instanceof Response)
+    return r;
+  if (!r.docker || r.docker.kind !== "postgresql") {
+    const body2 = { dbId: r.dbId, schemas: [] };
+    return json(body2);
+  }
+  const schemas = listDockerSchemas(r.docker.serviceName, "postgresql", r.docker.env, r.docker.composeDir, r.docker.database);
+  const body = {
+    dbId: r.dbId,
+    schemas: schemas.map((name) => ({ name })),
+    selectedSchema: r.schema
+  };
+  return json(body);
+}
 async function handleSchema(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const includeColumns = url.searchParams.get("includeColumns") === "1";
@@ -7705,6 +7833,7 @@ async function handleSchema(cwd, url, omitDirNames) {
     const foreignKeys = adapter.getForeignKeys();
     const body = {
       dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
       tables: tablesWithCount,
       indexes,
       foreignKeys
@@ -7782,7 +7911,7 @@ function groupFiltersByValue(filters) {
   return grouped;
 }
 async function handleTable(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -7817,6 +7946,7 @@ async function handleTable(cwd, url, omitDirNames) {
       }
       const body2 = {
         dbId: r.dbId,
+        ...r.schema ? { schema: r.schema } : {},
         table,
         columns: meta.columns,
         rows: serializeDbRows(meta.rows),
@@ -7839,6 +7969,7 @@ async function handleTable(cwd, url, omitDirNames) {
       }
       const body2 = {
         dbId: r.dbId,
+        ...r.schema ? { schema: r.schema } : {},
         table,
         columns: meta.columns,
         rows: serializeDbRows(meta.rows),
@@ -7870,6 +8001,7 @@ async function handleTable(cwd, url, omitDirNames) {
         const dataResult = adapter.executeReadonlyQuery(dataSql, filter.useParams ? [...filter.params, limit, offset] : undefined);
         const body2 = {
           dbId: r.dbId,
+          ...r.schema ? { schema: r.schema } : {},
           table,
           columns,
           rows: serializeDbRows(dataResult.rows),
@@ -7885,6 +8017,7 @@ async function handleTable(cwd, url, omitDirNames) {
     const totalRows = result.rowCount < limit ? offset + result.rowCount : adapter.getTableRowCount(table);
     const body = {
       dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
       table,
       columns,
       rows: serializeDbRows(result.rows),
@@ -7937,7 +8070,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
     return body;
   if (!body.db || !body.sql)
     return textError("missing db or sql", 400);
-  const r = resolveDb(cwd, body.db, omitDirNames);
+  const r = resolveDb(cwd, body.db, omitDirNames, body.schema);
   if (r instanceof Response)
     return r;
   const maxRows = Math.min(1e4, Math.max(1, body.maxRows || 1000));
@@ -7952,6 +8085,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
     const columnTypes = inferredColumns.length > 0 ? inferredColumns.map((col) => col.type) : result.columnTypes;
     const response = {
       dbId: body.db,
+      ...r.schema ? { schema: r.schema } : {},
       columns,
       columnTypes,
       rows: serializedRows,
@@ -7963,6 +8097,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
       const entry = {
         id: makeHistoryId(),
         dbId: body.db,
+        ...r.schema ? { schema: r.schema } : {},
         sql: body.sql,
         title: body.title,
         body: body.body,
@@ -7979,7 +8114,12 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
       const state = loadQueryHistory(cwd);
       const updated = addQueryHistoryEntry(state, entry);
       saveQueryHistory(cwd, updated);
-      sendSse?.("db-query", JSON.stringify({ action: "add", dbId: body.db, id: entry.id }));
+      sendSse?.("db-query", JSON.stringify({
+        action: "add",
+        dbId: body.db,
+        schema: r.schema,
+        id: entry.id
+      }));
     }
     return json(response);
   } catch (err) {
@@ -7990,6 +8130,7 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
     const elapsed = Date.now() - start;
     const response = {
       dbId: body.db,
+      ...r.schema ? { schema: r.schema } : {},
       columns: [],
       columnTypes: [],
       rows: [],
@@ -8003,11 +8144,20 @@ async function handleQuery(cwd, req, sendSse, omitDirNames) {
 }
 function handleHistory(cwd, url) {
   const dbId = url.searchParams.get("db") || undefined;
+  const schema = normalizeSchemaParam(url.searchParams.get("schema"));
+  if (schema instanceof Response)
+    return schema;
   const state = loadQueryHistory(cwd);
   if (dbId) {
     return json({
       version: 1,
-      entries: state.entries.filter((e) => e.dbId === dbId)
+      entries: state.entries.filter((e) => {
+        if (e.dbId !== dbId)
+          return false;
+        if (schema === undefined)
+          return true;
+        return (e.schema || "public") === schema;
+      })
     });
   }
   return json(state);
@@ -8022,7 +8172,12 @@ async function handleHistoryDelete(cwd, req, sendSse) {
   const deleted = state.entries.find((entry) => entry.id === body.id);
   const updated = deleteQueryHistoryEntry(state, body.id);
   saveQueryHistory(cwd, updated);
-  sendSse?.("db-query", JSON.stringify({ action: "delete", dbId: deleted?.dbId, id: body.id }));
+  sendSse?.("db-query", JSON.stringify({
+    action: "delete",
+    dbId: deleted?.dbId,
+    schema: deleted?.schema,
+    id: body.id
+  }));
   return json({ ok: true });
 }
 async function handleHistoryClear(cwd, req, sendSse) {
@@ -8035,9 +8190,12 @@ async function handleHistoryClear(cwd, req, sendSse) {
     body = {};
   }
   const state = loadQueryHistory(cwd);
-  const updated = clearQueryHistory(state, body.db);
+  const schema = normalizeSchemaParam(body.schema);
+  if (schema instanceof Response)
+    return schema;
+  const updated = clearQueryHistory(state, body.db, schema);
   saveQueryHistory(cwd, updated);
-  sendSse?.("db-query", JSON.stringify({ action: "clear", dbId: body.db }));
+  sendSse?.("db-query", JSON.stringify({ action: "clear", dbId: body.db, schema }));
   return json({ ok: true });
 }
 function formatCsvField(value) {
@@ -8055,7 +8213,7 @@ function formatCsvField(value) {
   return str;
 }
 async function handleExport(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -8156,7 +8314,7 @@ async function handleExport(cwd, url, omitDirNames) {
   }
 }
 async function handleColumns(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -8165,13 +8323,18 @@ async function handleColumns(cwd, url, omitDirNames) {
   try {
     const adapter = await getAdapter(r, cwd);
     const columns = adapter.getColumns(table);
-    return json({ dbId: r.dbId, table, columns });
+    return json({
+      dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
+      table,
+      columns
+    });
   } catch (err) {
     return handleError("database", "get columns", err);
   }
 }
 async function handleDdl(cwd, url, omitDirNames) {
-  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames);
+  const r = resolveDb(cwd, url.searchParams.get("db"), omitDirNames, url.searchParams.get("schema"));
   if (r instanceof Response)
     return r;
   const table = url.searchParams.get("table");
@@ -8181,7 +8344,13 @@ async function handleDdl(cwd, url, omitDirNames) {
     const adapter = await getAdapter(r, cwd);
     const sql = adapter.getCreateStatement(table);
     const triggers = adapter.getTriggers(table);
-    return json({ dbId: r.dbId, table, sql, triggers });
+    return json({
+      dbId: r.dbId,
+      ...r.schema ? { schema: r.schema } : {},
+      table,
+      sql,
+      triggers
+    });
   } catch (err) {
     return handleError("database", "get DDL", err);
   }
@@ -8192,7 +8361,7 @@ async function handleSearchStart(cwd, req, omitDirNames) {
     return body;
   if (!body.db || !body.term)
     return textError("missing db or term", 400);
-  const r = resolveDb(cwd, body.db, omitDirNames);
+  const r = resolveDb(cwd, body.db, omitDirNames, body.schema);
   if (r instanceof Response)
     return r;
   const jobId = makeId("search");
@@ -8200,6 +8369,7 @@ async function handleSearchStart(cwd, req, omitDirNames) {
   const job = {
     id: jobId,
     dbId: body.db,
+    ...r.schema ? { schema: r.schema } : {},
     scannedTables: 0,
     totalTables: 0,
     hits: [],
@@ -8237,7 +8407,10 @@ async function handleSearchStart(cwd, req, omitDirNames) {
         const pkCols = getPrimaryKeyColumns(adapter, table);
         const columns = adapter.getColumns(table);
         const hits = searchTable(adapter, table, columns, term, maxHitsPerTable, includeNonText, pkCols);
-        job.hits.push(...hits);
+        job.hits.push(...hits.map((hit) => ({
+          ...r.schema ? { schema: r.schema } : {},
+          ...hit
+        })));
         job.scannedTables++;
       }
       job.done = true;
@@ -8261,6 +8434,7 @@ function handleSearchStatus(url) {
   const result = {
     jobId: job.id,
     dbId: job.dbId,
+    schema: job.schema,
     scannedTables: job.scannedTables,
     totalTables: job.totalTables,
     currentTable: job.currentTable,
@@ -8292,7 +8466,10 @@ async function openRegisteredDockerSnapshotSource(info, requestedContainers) {
 }
 async function handleSnapshotList(cwd, url) {
   const dbId = url.searchParams.get("db") || undefined;
-  const snapshots = await listSnapshots(cwd, dbId);
+  const schema = normalizeSchemaParam(url.searchParams.get("schema"));
+  if (schema instanceof Response)
+    return schema;
+  const snapshots = await listSnapshots(cwd, dbId, schema);
   return json({ snapshots });
 }
 function sanitizeSnapshotTables(tables) {
@@ -8343,10 +8520,11 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
     }
   }
   if (!source) {
-    const r = resolveDb(cwd, body.db, omitDirNames);
+    const r = resolveDb(cwd, body.db, omitDirNames, body.schema);
     if (r instanceof Response)
       return r;
     source = await getAdapter(r, cwd);
+    body.schema = r.schema;
   }
   if (!containers || containers.length === 0) {
     const sqlAdapter = source;
@@ -8373,11 +8551,13 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
         sendSse?.("db-snapshot", JSON.stringify({
           action: "progress",
           dbId: snapshotDbId,
+          schema: body.schema,
           table,
           done
         }));
       }, {
         signal: abortController.signal,
+        schema: body.schema,
         onSnapshotId: (id) => {
           activeSnapshotId = id;
           snapshotJob.snapshotId = id;
@@ -8385,6 +8565,7 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
           sendSse?.("db-snapshot", JSON.stringify({
             action: "started",
             dbId: snapshotDbId,
+            schema: body.schema,
             id
           }));
         }
@@ -8392,6 +8573,7 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
       sendSse?.("db-snapshot", JSON.stringify({
         action: "created",
         dbId: snapshotDbId,
+        schema: body.schema,
         id: snapshotId
       }));
     } catch (err) {
@@ -8399,6 +8581,7 @@ async function handleSnapshotCreate(cwd, req, sendSse, omitDirNames) {
       sendSse?.("db-snapshot", JSON.stringify({
         action: "error",
         dbId: snapshotDbId,
+        schema: body.schema,
         error: err instanceof Error ? err.message : String(err)
       }));
     } finally {
@@ -8523,6 +8706,7 @@ async function handleClose(cwd, req, omitDirNames) {
     const info = findDockerServiceByDbId(cwd, body.db, undefined, omitDirNames);
     if (!info) {
       dockerAdapterCache.close(body.db);
+      dockerAdapterCache.closePrefix(`${body.db}\x00`);
       closeRedisAdapter(body.db);
       closeElasticsearchAdapter(body.db);
       return json({ ok: true });
@@ -8535,6 +8719,7 @@ async function handleClose(cwd, req, omitDirNames) {
     return r;
   if (r.docker) {
     dockerAdapterCache.close(r.dbId);
+    dockerAdapterCache.closePrefix(`${r.dbId}\x00`);
   } else {
     closeConnection(r.resolved);
   }
@@ -8567,6 +8752,10 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
       methods: ["GET"],
       handler: () => handleFiles(cwd, omitDirNames)
     },
+    "/_db/schemas": {
+      methods: ["GET"],
+      handler: () => handleSchemas(cwd, url, omitDirNames)
+    },
     "/_db/schema": {
       methods: ["GET"],
       handler: () => handleSchema(cwd, url, omitDirNames)
@@ -8664,7 +8853,7 @@ async function handleDatabaseRoute(req, url, cwd, omitDirNames, sideEffectAllowe
     }
   }, sideEffectAllowed, wrapResponse, (err) => handleError("database", "handle database request", err));
 }
-var initialized = false, dockerAdapterCache, EXPORT_MAX_ROWS = 1e5, MAX_TABS_BODY_BYTES = 1e6, MAX_SNAPSHOT_TABLES = 512, MAX_SNAPSHOT_TABLE_NAME_LEN = 1024, searchJobs, snapshotJobs, DOCKER_CLOSE_REGISTRY, SNAPSHOT_DOCKER_SOURCE_REGISTRY;
+var initialized = false, dockerAdapterCache, MAX_SCHEMA_NAME_LEN = 1024, EXPORT_MAX_ROWS = 1e5, MAX_TABS_BODY_BYTES = 1e6, MAX_SNAPSHOT_TABLES = 512, MAX_SNAPSHOT_TABLE_NAME_LEN = 1024, searchJobs, snapshotJobs, DOCKER_CLOSE_REGISTRY, SNAPSHOT_DOCKER_SOURCE_REGISTRY;
 var init_handle = __esm(() => {
   init_docker();
   init_docker_utils();
@@ -8684,8 +8873,14 @@ var init_handle = __esm(() => {
   searchJobs = new Map;
   snapshotJobs = new Map;
   DOCKER_CLOSE_REGISTRY = {
-    postgresql: (dbId) => dockerAdapterCache.close(dbId),
-    mysql: (dbId) => dockerAdapterCache.close(dbId),
+    postgresql: (dbId) => {
+      dockerAdapterCache.close(dbId);
+      dockerAdapterCache.closePrefix(`${dbId}\x00`);
+    },
+    mysql: (dbId) => {
+      dockerAdapterCache.close(dbId);
+      dockerAdapterCache.closePrefix(`${dbId}\x00`);
+    },
     redis: closeRedisAdapter,
     elasticsearch: closeElasticsearchAdapter
   };