alinea 2.0.0-preview.7 → 2.0.0-preview.8

package/dist/chunks/{chunk-X47OVDF3.js → chunk-2U43BB6P.js}

@@ -1,45 +1,80 @@
 import {
-  BatchQuery,
-  Builder,
-  Column,
-  Functions,
-  JsonColumn,
+  connect
+} from "./chunk-A42DP5T7.js";
+import {
+  connect as connect2
+} from "./chunk-NLZLRQ5U.js";
+import {
+  connect as connect3
+} from "./chunk-IL7FJQAY.js";
+import {
+  Dialect,
+  Emitter,
+  NamedParam,
+  ReusedStatement,
+  StatementCache,
+  ValueParam,
+  execTransaction,
+  sqliteDialect,
+  sqliteDiff
+} from "./chunk-M7KDJEGH.js";
+import {
+  AsyncDatabase,
+  Batch,
+  SyncDatabase,
+  txGenerator
+} from "./chunk-N47Y62CI.js";
+import {
   and,
   asc,
-  boolean,
-  column,
-  columnConfig,
   eq,
-  formatColumn,
   gt,
-  integer,
   isNotNull,
   isNull,
   like,
   not,
-  oid,
   or,
+  when
+} from "./chunk-XCZXR3C2.js";
+import {
+  Column,
+  boolean,
+  column,
+  formatColumn,
+  integer,
+  oid,
   primaryKeyColumns,
   table,
-  text,
-  when
-} from "./chunk-G6E35DMJ.js";
+  tableFields,
+  text
+} from "./chunk-TFMUSWGG.js";
+import {
+  Field,
+  selection
+} from "./chunk-2PIFHEYR.js";
+import {
+  Functions
+} from "./chunk-K62JP6HR.js";
+import {
+  input
+} from "./chunk-ATF42T2B.js";
 import {
-  Sql,
-  getCreate,
   getData,
-  getDrop,
+  getField,
   getQuery,
-  getResolver,
   getSelection,
   getSql,
   getTable,
-  hasQuery,
-  hasSelection,
-  input,
-  internalResolver,
+  hasField,
+  hasSql,
+  internalCreate,
+  internalData,
+  internalDrop,
+  internalQuery,
+  internalSelection,
+  internalTarget,
   sql
-} from "./chunk-NWQXN4SB.js";
+} from "./chunk-ETBQTP2S.js";
 import {
   __export
 } from "./chunk-CQ52GEHY.js";
@@ -47,17 +82,17 @@ import {
 // node_modules/rado/dist/driver.js
 var driver_exports = {};
 __export(driver_exports, {
-  "@electric-sql/pglite": () => connect8,
-  "@libsql/client": () => connect4,
-  "@neondatabase/serverless": () => connect7,
-  "@vercel/postgres": () => connect7,
-  "better-sqlite3": () => connect,
-  "bun:sqlite": () => connect2,
-  d1: () => connect3,
-  mysql2: () => connect5,
-  "node:sqlite": () => connect6,
-  pg: () => connect7,
-  "sql.js": () => connect9
+  "@electric-sql/pglite": () => connect9,
+  "@libsql/client": () => connect6,
+  "@neondatabase/serverless": () => connect8,
+  "@vercel/postgres": () => connect8,
+  "better-sqlite3": () => connect4,
+  "bun:sqlite": () => connect,
+  d1: () => connect5,
+  mysql2: () => connect7,
+  "node:sqlite": () => connect2,
+  pg: () => connect8,
+  "sql.js": () => connect3
 });
 
 // node_modules/rado/dist/universal/functions.js
@@ -76,785 +111,213 @@ function concat(...slices) {
   });
 }
 
-// node_modules/rado/dist/universal/transactions.js
-function txGenerator(create) {
-  function run(tx) {
-    const iter = create(tx);
-    const next = (inner) => {
-      if (inner instanceof Promise)
-        return inner.then(iter.next.bind(iter)).catch(iter.throw.bind(iter)).then(handle);
-      try {
-        return handle(iter.next(inner));
-      } catch (err) {
-        return handle(iter.throw(err));
-      }
-    };
-    const handle = ({ done, value }) => {
-      if (done) return value;
-      return next(typeof value === "function" ? tx.transaction(value) : value);
-    };
-    return next();
+// node_modules/rado/dist/core/View.js
+var ViewBase = class {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
   }
-  return Object.assign(run, {
-    *[Symbol.iterator]() {
-      return yield run;
-    }
+};
+function viewIdentifier({ name, schemaName }) {
+  return schemaName ? sql.join([sql.identifier(schemaName), sql.identifier(name)], sql`.`) : sql.identifier(name);
+}
+function createView(data, as) {
+  const createKeyword = data.materialized ? sql`create materialized view` : sql`create view`;
+  const { columns, columnNames } = data;
+  const columnList = columnNames ? sql.join(
+    columnNames.map((name) => sql.identifier(name)),
+    sql`, `
+  ) : columns ? sql.join(
+    Object.entries(columns).map(([name, column2]) => {
+      const columnData = getData(column2);
+      return sql.identifier(columnData.name ?? name);
+    }),
+    sql`, `
+  ) : void 0;
+  return sql.join([
+    createKeyword,
+    viewIdentifier(data),
+    columnList ? sql`(${columnList})` : void 0,
+    sql`as`,
+    as
+  ]).inlineValues();
+}
+function viewColumnNames(input2) {
+  const expr = getSql(input2);
+  if (expr) {
+    if (hasField(input2)) return [getField(input2).fieldName];
+    if (expr.alias) return [expr.alias];
+    throw new Error("Missing field name");
+  }
+  return Object.entries(input2).flatMap(([name, value]) => {
+    const expr2 = getSql(value);
+    if (expr2 && !hasField(value)) return [expr2.alias ?? name];
+    return viewColumnNames(value);
   });
 }
-
-// node_modules/rado/dist/core/expr/Aggregate.js
-function count(input2) {
-  return Functions.count(input2 ?? sql`*`).mapWith(Number);
+function viewFields(alias, source) {
+  return Object.fromEntries(
+    Object.entries(source).map(([key, value]) => {
+      if (value && typeof value === "object" && !hasSql(value))
+        return [key, viewFields(alias, value)];
+      const fieldName = hasField(value) ? getField(value).fieldName : key;
+      return [key, new Field(alias, fieldName, getSql(value))];
+    })
+  );
 }
-
-// node_modules/rado/dist/core/Resolver.js
-var Resolver = class {
-  #driver;
-  #dialect;
-  constructor(driver, dialect) {
-    this.#driver = driver;
-    this.#dialect = dialect;
-  }
-  toSQL(query) {
-    const emitter = this.#dialect.emit(query);
-    return { sql: emitter.sql, params: emitter.bind() };
-  }
-  prepare(query, name) {
-    const isSelection = hasSelection(query);
-    const mapRow = isSelection ? getSelection(query).mapRow : void 0;
-    const emitter = this.#dialect.emit(query);
-    const stmt = this.#driver.prepare(emitter.sql, {
-      isSelection,
-      name
-    });
-    return new PreparedStatement(emitter, stmt, mapRow, this.#driver);
-  }
-  batch(queries) {
-    return new Batch(
-      this.#driver,
-      queries.map((query) => {
-        const isSelection = hasSelection(query);
-        const mapRow = isSelection ? getSelection(query).mapRow : void 0;
-        const emitter = this.#dialect.emit(query);
-        return { sql: emitter.sql, params: emitter.bind(), isSelection, mapRow };
-      })
-    );
-  }
-};
-var Batch = class {
-  #driver;
-  #queries;
-  constructor(driver, queries) {
-    this.#driver = driver;
-    this.#queries = queries;
-  }
-  #transform = (results) => {
-    const ctx = {
-      values: void 0,
-      index: 0,
-      specs: this.#driver
+function dropView(data) {
+  const dropKeyword = data.materialized ? sql`drop materialized view` : sql`drop view`;
+  return sql.join([dropKeyword, sql`if exists`, viewIdentifier(data)]);
+}
+var QueryView = class extends ViewBase {
+  as(query) {
+    const data = getData(this);
+    const input2 = getSelection(query).input;
+    const target = {
+      [internalTarget]: viewIdentifier(data),
+      ...viewFields(data.name, input2)
+    };
+    const createData = {
+      ...data,
+      columnNames: viewColumnNames(input2)
     };
-    for (let i = 0; i < this.#queries.length; i++) {
-      const { mapRow } = this.#queries[i];
-      if (!mapRow) continue;
-      const rows = results[i];
-      for (let j = 0; j < results[i].length; j++) {
-        ctx.values = rows[j];
-        ctx.index = 0;
-        rows[j] = mapRow(ctx);
+    return {
+      ...target,
+      [internalSelection]: selection(target),
+      [internalQuery]: getQuery(query),
+      get [internalCreate]() {
+        const result = createView(createData, getQuery(query));
+        return [result];
+      },
+      get [internalDrop]() {
+        return [dropView(data)];
       }
-    }
-    return results;
-  };
-  execute() {
-    const results = this.#driver.batch(this.#queries);
-    if (results instanceof Promise) return results.then(this.#transform);
-    return this.#transform(results);
-  }
-};
-var PreparedStatement = class {
-  #emitter;
-  #stmt;
-  #mapRow;
-  #specs;
-  constructor(emitter, stmt, mapRow, specs) {
-    this.#emitter = emitter;
-    this.#stmt = stmt;
-    this.#mapRow = mapRow;
-    this.#specs = specs;
-  }
-  #transform = (rows) => {
-    if (!this.#mapRow) return rows;
-    const ctx = {
-      values: void 0,
-      index: 0,
-      specs: this.#specs
     };
-    for (let i = 0; i < rows.length; i++) {
-      ctx.values = rows[i];
-      ctx.index = 0;
-      rows[i] = this.#mapRow(ctx);
-    }
-    return rows;
-  };
-  all(inputs) {
-    const rows = this.#stmt.values(this.#emitter.bind(inputs));
-    if (rows instanceof Promise) return rows.then(this.#transform);
-    return this.#transform(rows);
-  }
-  get(inputs) {
-    const rows = this.all(inputs);
-    if (rows instanceof Promise) return rows.then((rows2) => rows2[0]);
-    return rows[0];
-  }
-  run(inputs) {
-    return this.#stmt.run(this.#emitter.bind(inputs));
-  }
-  async execute(inputs) {
-    return this.all(inputs);
-  }
-  free() {
-    this.#stmt.free();
   }
 };
-
-// node_modules/rado/dist/core/Database.js
-var Database = class extends Builder {
-  driver;
-  dialect;
-  diff;
-  [internalResolver];
-  constructor(driver, dialect, diff) {
-    const resolver = new Resolver(driver, dialect);
-    super({ resolver });
-    this[internalResolver] = resolver;
-    this.driver = driver;
-    this.dialect = dialect;
-    this.diff = diff;
-  }
-  close() {
-    return this.driver.close();
-  }
-  [Symbol.dispose]() {
-    this.close();
-  }
-  async [Symbol.asyncDispose]() {
-    return this.close();
-  }
-  create(...createables) {
-    return new BatchQuery(getResolver(this), createables.flatMap(getCreate));
-  }
-  drop(...droppables) {
-    return new BatchQuery(getResolver(this), droppables.flatMap(getDrop));
-  }
-  run(input2) {
-    const sql2 = this.dialect.inline(input2);
-    return this.driver.exec(sql2);
-  }
-  get(input2) {
-    const emitter = this.dialect.emit(input2);
-    return this.driver.prepare(emitter.sql).get(emitter.bind());
-  }
-  all(input2) {
-    const emitter = this.dialect.emit(input2);
-    return this.driver.prepare(emitter.sql).all(emitter.bind());
-  }
-  migrate(...tables) {
-    if (this.dialect.runtime === "mysql" && tables.length > 1) {
-      const run = async () => {
-        for (const table2 of tables) await this.migrate(table2);
-      };
-      return run();
-    }
-    const computeDiff = this.diff;
-    return this.transaction(
-      txGenerator(function* (tx) {
-        for (const table2 of tables) {
-          const diff = yield* computeDiff(table2);
-          if (diff.length > 0) yield* tx.batch(diff.map(sql.unsafe));
-        }
-      })
-    );
+var DefinedView = class extends ViewBase {
+  existing() {
+    const data = getData(this);
+    const { name, columns } = data;
+    const fields = tableFields(name, columns);
+    return {
+      [internalTarget]: viewIdentifier(data),
+      ...fields,
+      [internalSelection]: selection(fields)
+    };
   }
-  batch(queries) {
-    return new BatchQuery(getResolver(this), queries);
-  }
-  execute(input2) {
-    const inner = getSql(input2);
-    const emitter = this.dialect.emit(inner.inlineValues());
-    if (emitter.hasParams) throw new Error("Query has parameters");
-    return this.driver.exec(emitter.sql);
-  }
-  refreshMaterializedView(view) {
-    return this.execute(sql`refresh materialized view ${view}`);
-  }
-  transaction(run, options = {}) {
-    return this.driver.transaction(
-      (inner) => {
-        const tx = new Transaction(inner, this.dialect, this.diff);
-        return run(tx);
-      },
-      { async: run.constructor.name === "AsyncFunction", ...options }
+  as(query) {
+    const data = getData(this);
+    const fields = tableFields(
+      data.name,
+      data.columns
     );
-  }
-  $count(source, condition) {
-    return this.select(count()).from(source).where(condition).$first();
-  }
-};
-var Rollback = class extends Error {
-  constructor(data) {
-    super("Rollback");
-    this.data = data;
-  }
-  data;
-};
-var Transaction = class extends Database {
-  rollback(data) {
-    throw new Rollback(data);
-  }
-};
-var SyncDatabase = class extends Database {
-};
-var AsyncDatabase = class extends Database {
-};
-
-// node_modules/rado/dist/sqlite/columns.js
-function boolean2(name) {
-  return new Column({
-    name,
-    type: column.integer(),
-    mapFromDriverValue(value) {
-      return value === 1;
-    },
-    mapToDriverValue(value) {
-      return value ? 1 : 0;
-    }
-  });
-}
-function integer2(...args) {
-  const { name, options } = columnConfig(args);
-  if (options?.mode === "timestamp" || options?.mode === "timestamp_ms") {
-    const scale = options.mode === "timestamp" ? 1e3 : 1;
-    return new Column({
-      name,
-      type: column.integer(),
-      mapFromDriverValue(value) {
-        if (value === null) return null;
-        return new Date(value * scale);
-      },
-      mapToDriverValue(value) {
-        return Math.floor(value.getTime() / scale);
-      }
-    });
-  }
-  if (options?.mode === "boolean") return boolean2();
-  return new Column({ name, type: column.integer() });
-}
-function text2(...args) {
-  const { name, options } = columnConfig(args);
-  if (options?.mode === "json")
-    return new JsonColumn({
-      name,
-      type: column.text(options?.length),
-      mapToDriverValue(value) {
-        return JSON.stringify(value);
+    return {
+      [internalTarget]: viewIdentifier(data),
+      ...fields,
+      [internalSelection]: selection(fields),
+      [internalQuery]: getSql(query),
+      get [internalCreate]() {
+        const result = createView(data, query);
+        return [result];
       },
-      mapFromDriverValue(value) {
-        return JSON.parse(value);
+      get [internalDrop]() {
+        return [dropView(data)];
       }
-    });
-  return new Column({ name, type: column.text(options?.length) });
-}
-
-// node_modules/rado/dist/core/Dialect.js
-var Dialect = class {
-  runtime;
-  #createEmitter;
-  constructor(runtime, createEmitter) {
-    this.runtime = runtime;
-    this.#createEmitter = createEmitter;
-  }
-  emit = (input2) => {
-    const sql2 = hasQuery(input2) ? getQuery(input2) : getSql(input2);
-    const emitter = new this.#createEmitter(this.runtime);
-    sql2.emit(emitter);
-    return emitter;
-  };
-  inline = (input2) => {
-    const sql2 = hasQuery(input2) ? getQuery(input2) : getSql(input2);
-    const emitter = new this.#createEmitter(this.runtime);
-    sql2.inlineValues().emit(emitter);
-    return emitter.sql;
-  };
-};
-
-// node_modules/rado/dist/core/Param.js
-var NamedParam = class {
-  constructor(name) {
-    this.name = name;
-  }
-  name;
-};
-var ValueParam = class {
-  constructor(value) {
-    this.value = value;
-  }
-  value;
-};
-
-// node_modules/rado/dist/core/Emitter.js
-var Emitter = class {
-  #runtime;
-  sql = "";
-  params = [];
-  constructor(runtime) {
-    this.#runtime = runtime;
-  }
-  get hasParams() {
-    return this.params.length > 0;
-  }
-  bind(inputs) {
-    return this.params.map((param) => {
-      if (param instanceof ValueParam) return this.processValue(param.value);
-      if (inputs && param.name in inputs)
-        return this.processValue(inputs[param.name]);
-      throw new Error(`Missing input for named parameter: ${param.name}`);
-    });
-  }
-  processValue(value) {
-    return value;
-  }
-  emitIdentifierOrSelf(value) {
-    if (value === Sql.SELF_TARGET) {
-      if (!this.#selfName) throw new Error("Self target not defined");
-      this.emitIdentifier(this.#selfName);
-    } else {
-      this.emitIdentifier(value);
-    }
-  }
-  emitUnsafe(value) {
-    this.sql += value;
-  }
-  #selfName;
-  emitSelf(inner, name) {
-    this.#selfName = name;
-    inner.emit(this);
-    this.#selfName = void 0;
-  }
-  #inlineFields = false;
-  inlineFields(inner, withTableName) {
-    const previous = this.#inlineFields;
-    this.#inlineFields = !withTableName;
-    inner.emit(this);
-    this.#inlineFields = previous;
-  }
-  #inlineValues = false;
-  inlineValues(inner) {
-    const previous = this.#inlineValues;
-    this.#inlineValues = true;
-    inner.emit(this);
-    this.#inlineValues = previous;
-  }
-  emitField({ targetName, fieldName }) {
-    if (this.#inlineFields) return this.emitIdentifier(fieldName);
-    this.emitIdentifierOrSelf(targetName);
-    this.emitUnsafe(".");
-    this.emitIdentifier(fieldName);
-  }
-  emitValueOrInline(value) {
-    if (this.#inlineValues) this.emitInline(value);
-    else this.emitValue(value);
-  }
-  emitUniversal(runtimes) {
-    const sql2 = runtimes[this.#runtime] ?? runtimes.default;
-    if (!sql2) throw new Error("Unsupported runtime");
-    getSql(sql2).emit(this);
-  }
-};
-
-// node_modules/rado/dist/sqlite/dialect.js
-var DOUBLE_QUOTE = '"';
-var ESCAPE_DOUBLE_QUOTE = '""';
-var MATCH_DOUBLE_QUOTE = /"/g;
-var SINGLE_QUOTE = "'";
-var ESCAPE_SINGLE_QUOTE = "''";
-var MATCH_SINGLE_QUOTE = /'/g;
-var sqliteDialect = new Dialect(
-  "sqlite",
-  class extends Emitter {
-    processValue(value) {
-      return typeof value === "boolean" ? value ? 1 : 0 : value;
-    }
-    emitValue(value) {
-      this.params.push(new ValueParam(value));
-      this.sql += "?";
-    }
-    emitPlaceholder(name) {
-      this.params.push(new NamedParam(name));
-      this.sql += "?";
-    }
-    emitJsonPath({ target, asSql, segments }) {
-      target.emit(this);
-      this.sql += asSql ? "->>" : "->";
-      this.sql += this.quoteString(
-        `$${segments.map(
-          (p) => typeof p === "number" ? `[${p}]` : `.${JSON.stringify(p)}`
-        ).join("")}`
-      );
-    }
-    emitInline(value) {
-      if (value === null || value === void 0) return this.sql += "null";
-      if (typeof value === "number") return this.sql += value;
-      if (typeof value === "string")
-        return this.sql += this.quoteString(value);
-      if (typeof value === "boolean") return this.sql += value ? "1" : "0";
-      this.sql += `json(${this.quoteString(JSON.stringify(value))})`;
-    }
-    emitIdentifier(identifier) {
-      this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
-    }
-    quoteString(input2) {
-      return SINGLE_QUOTE + input2.replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
-    }
+    };
   }
-);
-
-// node_modules/rado/dist/sqlite/diff.js
-var TableInfo = table("TableInfo", {
-  cid: integer2().notNull(),
-  name: text2().notNull(),
-  type: text2().notNull(),
-  notnull: boolean2().notNull(),
-  dflt_value: text2(),
-  pk: integer2().notNull()
-});
-var SqliteMaster = table("SqliteMaster", {
-  type: text2().notNull(),
-  name: text2().notNull(),
-  tbl_name: text2().notNull(),
-  rootpage: integer2().notNull(),
-  sql: text2().notNull()
-});
-var inline = (sql2) => sqliteDialect.inline(sql2);
-var sqliteDiff = (targetTable) => {
-  return txGenerator(function* (tx) {
-    const tableApi = getTable(targetTable);
-    const columnInfo = yield* tx.select(TableInfo).from(sql`pragma_table_info(${sql.inline(tableApi.name)}) as "TableInfo"`);
-    if (columnInfo.length === 0) return tableApi.create().map(inline);
-    const indexInfo = yield* tx.select(SqliteMaster).from(sql`sqlite_master as "SqliteMaster"`).where(
-      eq(SqliteMaster.tbl_name, tableApi.name),
-      eq(SqliteMaster.type, "index")
-    );
-    const hasSinglePrimaryKey = columnInfo.reduce((acc, column2) => acc + column2.pk, 0) === 1;
-    const localColumns = new Map(
-      columnInfo.map((column2) => {
-        return [
-          column2.name,
-          inline(
-            formatColumn({
-              type: sql.unsafe(column2.type.toLowerCase()),
-              notNull: column2.notnull,
-              primary: hasSinglePrimaryKey && column2.pk === 1,
-              defaultValue: column2.dflt_value !== null ? sql.unsafe(column2.dflt_value) : void 0
-            })
-          )
-        ];
-      })
-    );
-    const schemaColumns = new Map(
-      Object.entries(tableApi.columns).map(([name, column2]) => {
-        const columnApi = getData(column2);
-        return [columnApi.name ?? name, inline(formatColumn(columnApi))];
-      })
-    );
-    const localIndexes = new Map(
-      indexInfo.filter((index) => !index.name.startsWith("sqlite_autoindex_")).map((index) => [index.name, index.sql])
-    );
-    const schemaIndexes = new Map(
-      Object.entries(tableApi.indexes()).map(([name, index]) => {
-        const indexApi = getData(index);
-        return [name, inline(indexApi.toSql(tableApi.name, name, false))];
-      })
-    );
-    const stmts = [];
-    const columnNames = /* @__PURE__ */ new Set([
-      ...localColumns.keys(),
-      ...schemaColumns.keys()
-    ]);
-    for (const columnName of columnNames) {
-      const localInstruction = localColumns.get(columnName);
-      const schemaInstruction = schemaColumns.get(columnName);
-      if (!schemaInstruction) {
-        stmts.push(
-          sql.query({
-            alterTable: sql.identifier(tableApi.name),
-            dropColumn: sql.identifier(columnName)
-          })
-        );
-      } else if (!localInstruction) {
-        stmts.push(
-          sql.query({
-            alterTable: sql.identifier(tableApi.name),
-            addColumn: [
-              sql.identifier(columnName),
-              sql.unsafe(schemaInstruction)
-            ]
-          })
-        );
-      } else if (localInstruction !== schemaInstruction) {
-        return recreate();
-      }
-    }
-    const indexNames = /* @__PURE__ */ new Set([
-      ...localIndexes.keys(),
-      ...schemaIndexes.keys()
-    ]);
-    for (const indexName of indexNames) {
-      const localInstruction = localIndexes.get(indexName);
-      const schemaInstruction = schemaIndexes.get(indexName);
-      const dropLocal = sql.query({
-        dropIndex: sql.identifier(indexName)
-      });
-      if (!schemaInstruction) {
-        stmts.unshift(dropLocal);
-      } else if (schemaInstruction && !localInstruction) {
-        stmts.push(sql.unsafe(schemaInstruction));
-      } else if (schemaInstruction && localInstruction !== schemaInstruction) {
-        stmts.unshift(dropLocal);
-        stmts.push(sql.unsafe(schemaInstruction));
-      }
-    }
-    try {
-      yield* txGenerator(function* (sp) {
-        yield* sp.batch(stmts);
-        const [tableInfo] = yield* sp.select(SqliteMaster.sql).from(sql`sqlite_master as "SqliteMaster"`).where(
-          eq(SqliteMaster.tbl_name, tableApi.name),
-          eq(SqliteMaster.type, "table")
-        );
-        sp.rollback(tableInfo);
-      });
-    } catch (err) {
-      if (!(err instanceof Rollback)) throw err;
-      const localInstruction = err.data;
-      const schemaInstruction = inline(tableApi.createTable());
-      const stripStmt = (q) => q.slice("create table ".length);
-      if (stripStmt(localInstruction) !== stripStmt(schemaInstruction)) {
-        return recreate();
-      }
-    }
-    return stmts.map(inline);
-    function recreate() {
-      const tempName = `new_${tableApi.name}`;
-      const tempTable = table(tempName, tableApi.columns);
-      const missingColumns = new Set(
-        Array.from(columnNames).filter((name) => !localColumns.has(name))
-      );
-      const selection = Object.fromEntries(
-        Object.entries(tableApi.columns).map(([name, column2]) => {
-          const columnApi = getData(column2);
-          const key = columnApi.name ?? name;
-          if (missingColumns.has(key))
-            return [name, columnApi.defaultValue ?? sql`null`];
-          return [name, targetTable[name]];
-        })
-      );
-      return [
-        // Create a new temporary table with the new definition
-        tableApi.createTable(tempName),
-        // Copy the data from the old table to the new table
-        getQuery(
-          tx.insert(tempTable).select(tx.select(selection).from(targetTable))
-        ),
-        // Drop the old table
-        sql.query({ dropTable: sql.identifier(tableApi.name) }),
-        // Rename the temporary table to the old table name
-        sql.query({
-          alterTable: sql.identifier(tempName),
-          renameTo: sql.identifier(tableApi.name)
-        }),
-        // Create missing indexes
-        ...tableApi.createIndexes()
-      ].map(inline);
-    }
-  });
 };
-
-// node_modules/rado/dist/sqlite/transactions.js
-var locks = /* @__PURE__ */ new WeakMap();
-function execTransaction(driver, depth, wrap, run, options) {
-  const needsLock = options.async;
-  const behavior = options.behavior ?? "deferred";
-  if (!needsLock) return transact();
-  let trigger;
-  const lock = new Promise((resolve) => trigger = resolve);
-  const current = Promise.resolve(locks.get(driver));
-  locks.set(driver, lock);
-  return current.then(transact).finally(trigger);
-  function transact() {
-    try {
-      driver.exec(depth > 0 ? `savepoint d${depth}` : `begin ${behavior}`);
-      const result = run(wrap(depth + 1));
-      if (result instanceof Promise) return result.then(release, rollback);
-      return release(result);
-    } catch (error) {
-      return rollback(error);
-    }
-  }
-  function release(result) {
-    driver.exec(depth > 0 ? `release d${depth}` : "commit");
-    return result;
-  }
-  function rollback(error) {
-    driver.exec(depth > 0 ? `rollback to d${depth}` : "rollback");
-    throw error;
-  }
+function view(name, columns, schemaName) {
+  if (columns) return new DefinedView({ name, columns, schemaName });
+  return new QueryView({ name, columns, schemaName });
 }
 
 // node_modules/rado/dist/driver/better-sqlite3.js
-var PreparedStatement2 = class {
-  constructor(stmt, isSelection) {
-    this.stmt = stmt;
+var PreparedStatement = class extends ReusedStatement {
+  constructor(statements, sql2, isSelection) {
+    super(statements, sql2);
     this.isSelection = isSelection;
   }
-  stmt;
   isSelection;
   all(params) {
     return this.stmt.all(...params);
   }
   run(params) {
-    return this.stmt.run(...params);
+    const result = this.stmt.run(...params);
+    return {
+      affectedRows: result.changes,
+      insertId: result.lastInsertRowid
+    };
   }
   get(params) {
-    return this.stmt.get(...params);
+    return this.stmt.get(...params) ?? null;
   }
   values(params) {
-    if (this.isSelection)
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
+    try {
       return this.stmt.raw(true).all(...params);
-    this.stmt.run(...params);
-    return [];
-  }
-  free() {
+    } finally {
+      this.stmt.raw(false);
+    }
   }
 };
 var BetterSqlite3Driver = class _BetterSqlite3Driver {
-  constructor(client, depth = 0) {
+  constructor(client, depth = 0, statements = new StatementCache(
+    (sql2) => client.prepare(sql2),
+    () => {
+    }
+  )) {
     this.client = client;
     this.depth = depth;
+    this.statements = statements;
   }
   client;
   depth;
+  statements;
   parsesJson = false;
   supportsTransactions = true;
   exec(query) {
+    this.statements.invalidate(query);
     this.client.exec(query);
   }
   close() {
+    this.statements.clear();
     this.client.close();
   }
   prepare(sql2, options) {
-    return new PreparedStatement2(
-      this.client.prepare(sql2),
+    return new PreparedStatement(
+      this.statements,
+      sql2,
       options?.isSelection ?? false
     );
   }
   batch(queries) {
-    return this.transaction(
-      (tx) => queries.map(
-        ({ sql: sql2, params, isSelection }) => tx.prepare(sql2, { isSelection }).values(params)
-      ),
-      {}
-    );
+    return this.transaction((tx) => Batch.run(tx, queries), {});
   }
   transaction(run, options) {
     return execTransaction(
       this,
       this.depth,
-      (depth) => new _BetterSqlite3Driver(this.client, depth),
+      (depth) => new _BetterSqlite3Driver(this.client, depth, this.statements),
       run,
       options
     );
   }
 };
-function connect(db) {
+function connect4(db, options) {
   return new SyncDatabase(
     new BetterSqlite3Driver(db),
     sqliteDialect,
-    sqliteDiff
+    sqliteDiff,
+    options
   );
 }
 
-// node_modules/rado/dist/driver/bun-sqlite.js
-var PreparedStatement3 = class {
-  constructor(stmt, isSelection) {
-    this.stmt = stmt;
-    this.isSelection = isSelection;
-  }
-  stmt;
-  isSelection;
-  all(params) {
-    return this.stmt.all(...params);
-  }
-  run(params) {
-    return this.stmt.run(...params);
-  }
-  get(params) {
-    return this.stmt.get(...params);
-  }
-  values(params) {
-    if (!this.isSelection) {
-      this.stmt.run(...params);
-      return [];
-    }
-    return this.stmt.values(...params);
-  }
-  free() {
-    this.stmt.finalize();
-  }
-};
-var BunSqliteDriver = class _BunSqliteDriver {
-  constructor(client, depth = 0) {
-    this.client = client;
-    this.depth = depth;
-  }
-  client;
-  depth;
-  parsesJson = false;
-  supportsTransactions = true;
-  exec(query) {
-    this.client.exec(query);
-  }
-  close() {
-    this.client.close();
-  }
-  prepare(sql2, options) {
-    return new PreparedStatement3(
-      this.client.prepare(sql2),
-      options?.isSelection ?? false
-    );
-  }
-  batch(queries) {
-    return this.transaction((tx) => {
-      return queries.map(
-        ({ sql: sql2, params, isSelection }) => tx.prepare(sql2, { isSelection }).values(params)
-      );
-    }, {});
-  }
-  transaction(run, options) {
-    return execTransaction(
-      this,
-      this.depth,
-      (depth) => new _BunSqliteDriver(this.client, depth),
-      run,
-      options
-    );
-  }
-};
-function connect2(db) {
-  return new SyncDatabase(new BunSqliteDriver(db), sqliteDialect, sqliteDiff);
-}
-
 // node_modules/rado/dist/driver/d1.js
-var PreparedStatement4 = class {
+var PreparedStatement2 = class {
   constructor(stmt, isSelection) {
     this.stmt = stmt;
     this.isSelection = isSelection;
@@ -866,6 +329,11 @@ var PreparedStatement4 = class {
   }
   async run(params) {
     const results = await this.stmt.bind(...params).run();
+    const meta = results.meta;
+    return {
+      affectedRows: meta.changes ?? meta.rows_written ?? 0,
+      insertId: meta.last_row_id
+    };
   }
   async get(params) {
     return this.stmt.bind(...params).first();
@@ -889,7 +357,7 @@ var D1Driver = class {
     await this.client.exec(query);
   }
   prepare(sql2, options) {
-    return new PreparedStatement4(
+    return new PreparedStatement2(
       this.client.prepare(sql2),
       options?.isSelection ?? false
     );
@@ -911,12 +379,17 @@ var D1Driver = class {
     throw new Error("Transactions are not supported in D1");
   }
 };
-function connect3(client) {
-  return new AsyncDatabase(new D1Driver(client), sqliteDialect, sqliteDiff);
+function connect5(client, options) {
+  return new AsyncDatabase(
+    new D1Driver(client),
+    sqliteDialect,
+    sqliteDiff,
+    options
+  );
 }
 
 // node_modules/rado/dist/driver/libsql.js
-var PreparedStatement5 = class {
+var PreparedStatement3 = class {
   constructor(client, sql2) {
     this.client = client;
     this.sql = sql2;
@@ -929,6 +402,10 @@ var PreparedStatement5 = class {
   }
   async run(params) {
     const result = await this.client.execute({ sql: this.sql, args: params });
+    return {
+      affectedRows: result.rowsAffected,
+      insertId: result.lastInsertRowid
+    };
   }
   async get(params) {
     return (await this.all(params))[0] ?? null;
@@ -953,7 +430,7 @@ var LibSQLClient = class _LibSQLClient {
     await this.client.execute(query);
   }
   prepare(sql2, options) {
-    return new PreparedStatement5(this.client, sql2);
+    return new PreparedStatement3(this.client, sql2);
   }
   async close() {
     if ("close" in this.client) return this.client.close();
@@ -976,17 +453,25 @@ var LibSQLClient = class _LibSQLClient {
       else await client.commit();
       return result;
     } catch (error) {
-      if (this.depth > 0)
-        await client.execute(`rollback to savepoint d${this.depth}`);
-      else await client.rollback();
+      try {
+        if (this.depth > 0)
+          await client.execute(`rollback to savepoint d${this.depth}`);
+        else await client.rollback();
+      } catch {
+      }
       throw error;
     } finally {
       if (this.depth === 0) client.close();
     }
   }
 };
-function connect4(client) {
-  return new AsyncDatabase(new LibSQLClient(client), sqliteDialect, sqliteDiff);
+function connect6(client, options) {
+  return new AsyncDatabase(
+    new LibSQLClient(client),
+    sqliteDialect,
+    sqliteDiff,
+    options
+  );
 }
 
 // node_modules/rado/dist/mysql/dialect.js
@@ -995,9 +480,9 @@ var ESCAPE_BACKTICK = "``";
 var MATCH_BACKTICK = /`/g;
 var ESCAPE_BACKSLASH = "\\\\";
 var MATCH_BACKSLASH = /\\/g;
-var SINGLE_QUOTE2 = "'";
-var ESCAPE_SINGLE_QUOTE2 = "''";
-var MATCH_SINGLE_QUOTE2 = /'/g;
+var SINGLE_QUOTE = "'";
+var ESCAPE_SINGLE_QUOTE = "''";
+var MATCH_SINGLE_QUOTE = /'/g;
 var mysqlDialect = new Dialect(
   "mysql",
   class extends Emitter {
@@ -1028,7 +513,7 @@ var mysqlDialect = new Dialect(
       this.sql += this.quoteString(JSON.stringify(value));
     }
     quoteString(input2) {
-      return SINGLE_QUOTE2 + input2.replace(MATCH_BACKSLASH, ESCAPE_BACKSLASH).replace(MATCH_SINGLE_QUOTE2, ESCAPE_SINGLE_QUOTE2) + SINGLE_QUOTE2;
+      return SINGLE_QUOTE + input2.replace(MATCH_BACKSLASH, ESCAPE_BACKSLASH).replace(MATCH_SINGLE_QUOTE, ESCAPE_SINGLE_QUOTE) + SINGLE_QUOTE;
     }
     emitIdentifier(identifier) {
       this.sql += BACKTICK + identifier.replace(MATCH_BACKTICK, ESCAPE_BACKTICK) + BACKTICK;
@@ -1041,44 +526,47 @@ function schema(schemaName) {
   return {
     table(tableName, columns, config) {
       return table(tableName, columns, config, schemaName);
+    },
+    view(viewName, columns) {
+      return columns ? view(viewName, columns, schemaName) : view(viewName, void 0, schemaName);
     }
   };
 }
 
 // node_modules/rado/dist/mysql/columns.js
-function integer3(name) {
+function integer2(name) {
   return new Column({ name, type: column.integer() });
 }
-function text3(name) {
+function text2(name) {
   return new Column({ name, type: column.text() });
 }
 
 // node_modules/rado/dist/mysql/diff.js
 var ns = schema("information_schema");
 var Information = ns.table("columns", {
-  table_name: text3().notNull(),
-  column_name: text3().notNull(),
-  column_type: text3().notNull(),
-  is_nullable: text3().notNull(),
-  column_default: text3(),
-  extra: text3().notNull(),
-  table_schema: text3().notNull()
+  table_name: text2().notNull(),
+  column_name: text2().notNull(),
+  column_type: text2().notNull(),
+  is_nullable: text2().notNull(),
+  column_default: text2(),
+  extra: text2().notNull(),
+  table_schema: text2().notNull()
 });
 var Statistics = ns.table("statistics", {
-  table_name: text3().notNull(),
-  column_name: text3().notNull(),
-  index_name: text3().notNull(),
-  non_unique: integer3().notNull(),
-  seq_in_index: integer3().notNull(),
-  table_schema: text3().notNull()
+  table_name: text2().notNull(),
+  column_name: text2().notNull(),
+  index_name: text2().notNull(),
+  non_unique: integer2().notNull(),
+  seq_in_index: integer2().notNull(),
+  table_schema: text2().notNull()
 });
 var TableConstraints = ns.table("table_constraints", {
-  constraint_name: text3().notNull(),
-  table_name: text3().notNull(),
-  constraint_type: text3().notNull(),
-  table_schema: text3().notNull()
+  constraint_name: text2().notNull(),
+  table_name: text2().notNull(),
+  constraint_type: text2().notNull(),
+  table_schema: text2().notNull()
 });
-var inline2 = (sql2) => mysqlDialect.inline(sql2);
+var inline = (sql2) => mysqlDialect.inline(sql2);
 var mysqlDiff = (hasTable) => {
   return txGenerator(function* (tx) {
     const tableApi = getTable(hasTable);
@@ -1093,7 +581,7 @@ var mysqlDiff = (hasTable) => {
       eq(Information.table_name, tableApi.name),
       eq(Information.table_schema, sql`database()`)
     );
-    if (columnInfo.length === 0) return tableApi.create().map(inline2);
+    if (columnInfo.length === 0) return tableApi.create().map(inline);
     const indexInfo = yield* tx.select({
       index_name: Statistics.index_name,
       column_name: Statistics.column_name,
@@ -1168,7 +656,7 @@ var mysqlDiff = (hasTable) => {
           })
         );
       } else {
-        if (inline2(localInstruction.type) !== inline2(schemaInstruction.type)) {
+        if (inline(localInstruction.type) !== inline(schemaInstruction.type)) {
           stmts.push(
             sql.query({
               alterTable,
@@ -1189,8 +677,8 @@ var mysqlDiff = (hasTable) => {
         }
         const localDefault = localInstruction.defaultValue;
         const schemaDefault = schemaInstruction.defaultValue;
-        const localDefaultStr = localDefault && inline2(localDefault);
-        const schemaDefaultStr = schemaDefault && inline2(schemaDefault);
+        const localDefaultStr = localDefault && inline(localDefault);
+        const schemaDefaultStr = schemaDefault && inline(schemaDefault);
         if (localDefaultStr !== schemaDefaultStr) {
           stmts.push(
             sql.query({
@@ -1234,7 +722,7 @@ var mysqlDiff = (hasTable) => {
         );
       } else if (!localInstruction) {
         stmts.push(schemaInstruction);
-      } else if (inline2(localInstruction) !== inline2(schemaInstruction)) {
+      } else if (inline(localInstruction) !== inline(schemaInstruction)) {
         if (indexName === "PRIMARY") {
           stmts.unshift(
             sql.query({
@@ -1254,7 +742,7 @@ var mysqlDiff = (hasTable) => {
         }
       }
     }
-    return stmts.map(inline2);
+    return stmts.map(inline);
   });
 };
 
@@ -1275,7 +763,7 @@ function setTransaction(options) {
 }
 
 // node_modules/rado/dist/driver/mysql2.js
-var PreparedStatement6 = class {
+var PreparedStatement4 = class {
   constructor(client, sql2, isSelection, name) {
     this.client = client;
     this.sql = sql2;
@@ -1291,10 +779,25 @@ var PreparedStatement6 = class {
     return param;
   };
   all(params) {
-    return this.client.query(this.sql, params.map(this.#transformParam)).then((res) => res[0]);
+    return this.client.query({
+      sql: this.sql,
+      values: params.map(this.#transformParam),
+      dateStrings: true,
+      supportBigNumbers: true
+    }).then((res) => res[0]);
   }
   async run(params) {
-    await this.client.query(this.sql, params.map(this.#transformParam));
+    const [result] = await this.client.query({
+      sql: this.sql,
+      values: params.map(this.#transformParam),
+      supportBigNumbers: true
+    });
+    const header = result;
+    return {
+      affectedRows: header.affectedRows ?? 0,
+      changedRows: header.changedRows ?? 0,
+      insertId: header.insertId ?? 0
+    };
   }
   get(params) {
     return this.all(params).then((rows) => rows[0] ?? null);
@@ -1304,7 +807,9 @@ var PreparedStatement6 = class {
     return this.client.query({
       sql: this.sql,
       values: params.map(this.#transformParam),
-      rowsAsArray: true
+      rowsAsArray: true,
+      dateStrings: true,
+      supportBigNumbers: true
     }).then((res) => res[0]);
   }
   free() {
@@ -1323,7 +828,7 @@ var Mysql2Driver = class _Mysql2Driver {
     await this.client.query(query);
   }
   prepare(sql2, options) {
-    return new PreparedStatement6(
+    return new PreparedStatement4(
       this.client,
       sql2,
       options?.isSelection ?? false,
@@ -1334,12 +839,7 @@ var Mysql2Driver = class _Mysql2Driver {
     if ("end" in this.client) return this.client.end();
   }
   async batch(queries) {
-    const transact = async (tx) => {
-      const results = [];
-      for (const { sql: sql2, params, isSelection } of queries)
-        results.push(await tx.prepare(sql2, { isSelection }).values(params));
-      return results;
-    };
+    const transact = (tx) => Batch.run(tx, queries);
     if (this.depth > 0) return transact(this);
     return this.transaction(transact, {});
   }
@@ -1347,22 +847,25 @@ var Mysql2Driver = class _Mysql2Driver {
     const client = isPool(this.client) ? await this.client.getConnection() : this.client;
     const driver = new _Mysql2Driver(client, this.depth + 1);
     try {
-      await client.query(
-        this.depth > 0 ? `savepoint d${this.depth}` : startTransaction(options)
-      );
       if (this.depth === 0) {
         const setOptions = setTransaction(options);
         if (setOptions) await client.query(setOptions);
       }
+      await client.query(
+        this.depth > 0 ? `savepoint d${this.depth}` : startTransaction(options)
+      );
       const result = await run(driver);
       await client.query(
         this.depth > 0 ? `release savepoint d${this.depth}` : "commit"
       );
       return result;
     } catch (error) {
-      await client.query(
-        this.depth > 0 ? `rollback to savepoint d${this.depth}` : "rollback"
-      );
+      try {
+        await client.query(
+          this.depth > 0 ? `rollback to savepoint d${this.depth}` : "rollback"
+        );
+      } catch {
+      }
       throw error;
     } finally {
       if (isPool(this.client))
@@ -1373,96 +876,22 @@ var Mysql2Driver = class _Mysql2Driver {
 function isPool(client) {
   return "getConnection" in client;
 }
-function connect5(client) {
+function connect7(client, options) {
   return new AsyncDatabase(
     new Mysql2Driver("promise" in client ? client.promise() : client),
     mysqlDialect,
-    mysqlDiff
+    mysqlDiff,
+    options
   );
 }
 
-// node_modules/rado/dist/driver/node-sqlite.js
-var PreparedStatement7 = class {
-  constructor(stmt, isSelection) {
-    this.stmt = stmt;
-    this.isSelection = isSelection;
-  }
-  stmt;
-  isSelection;
-  all(params) {
-    return this.stmt.all(...params);
-  }
-  run(params) {
-    this.stmt.run(...params);
-  }
-  get(params) {
-    return this.stmt.get(...params);
-  }
-  values(params) {
-    if (!this.isSelection) {
-      this.stmt.run(...params);
-      return [];
-    }
-    this.stmt.setReturnArrays(true);
-    try {
-      return this.stmt.all(...params);
-    } finally {
-      this.stmt.setReturnArrays(false);
-    }
-  }
-  free() {
-  }
-};
-var NodeSqliteDriver = class _NodeSqliteDriver {
-  constructor(client, depth = 0) {
-    this.client = client;
-    this.depth = depth;
-  }
-  client;
-  depth;
-  parsesJson = false;
-  supportsTransactions = true;
-  exec(query) {
-    this.client.exec(query);
-  }
-  close() {
-    this.client.close();
-  }
-  prepare(sql2, options) {
-    return new PreparedStatement7(
-      this.client.prepare(sql2),
-      options?.isSelection ?? false
-    );
-  }
-  batch(queries) {
-    return this.transaction(
-      (tx) => queries.map(
-        ({ sql: sql2, params, isSelection }) => tx.prepare(sql2, { isSelection }).values(params)
-      ),
-      {}
-    );
-  }
-  transaction(run, options) {
-    return execTransaction(
-      this,
-      this.depth,
-      (depth) => new _NodeSqliteDriver(this.client, depth),
-      run,
-      options
-    );
-  }
-};
-function connect6(db) {
-  return new SyncDatabase(new NodeSqliteDriver(db), sqliteDialect, sqliteDiff);
-}
-
 // node_modules/rado/dist/postgres/dialect.js
-var DOUBLE_QUOTE2 = '"';
-var ESCAPE_DOUBLE_QUOTE2 = '""';
-var MATCH_DOUBLE_QUOTE2 = /"/g;
-var SINGLE_QUOTE3 = "'";
-var ESCAPE_SINGLE_QUOTE3 = "''";
-var MATCH_SINGLE_QUOTE3 = /'/g;
+var DOUBLE_QUOTE = '"';
+var ESCAPE_DOUBLE_QUOTE = '""';
+var MATCH_DOUBLE_QUOTE = /"/g;
+var SINGLE_QUOTE2 = "'";
+var ESCAPE_SINGLE_QUOTE2 = "''";
+var MATCH_SINGLE_QUOTE2 = /'/g;
 var postgresDialect = new Dialect(
   "postgres",
   class extends Emitter {
@@ -1494,10 +923,10 @@ var postgresDialect = new Dialect(
       this.sql += this.quoteString(JSON.stringify(value));
     }
     quoteString(input2) {
-      return SINGLE_QUOTE3 + input2.replace(MATCH_SINGLE_QUOTE3, ESCAPE_SINGLE_QUOTE3) + SINGLE_QUOTE3;
+      return SINGLE_QUOTE2 + input2.replace(MATCH_SINGLE_QUOTE2, ESCAPE_SINGLE_QUOTE2) + SINGLE_QUOTE2;
     }
     emitIdentifier(identifier) {
-      this.sql += DOUBLE_QUOTE2 + identifier.replace(MATCH_DOUBLE_QUOTE2, ESCAPE_DOUBLE_QUOTE2) + DOUBLE_QUOTE2;
+      this.sql += DOUBLE_QUOTE + identifier.replace(MATCH_DOUBLE_QUOTE, ESCAPE_DOUBLE_QUOTE) + DOUBLE_QUOTE;
     }
   }
 );
@@ -1532,7 +961,7 @@ var AttrDef = table("pg_attrdef", {
   num: integer("adnum").notNull(),
   bin: text("adbin").notNull()
 });
-var inline3 = (sql2) => postgresDialect.inline(sql2);
+var inline2 = (sql2) => postgresDialect.inline(sql2);
 var columnType = sql`pg_catalog.format_type(${Attr.typId}, ${Attr.typMod})`;
 var columnDefaultValue = when(
   [Attr.hasDef, sql`pg_catalog.pg_get_expr(${AttrDef.bin}, ${AttrDef.relId})`],
@@ -1592,7 +1021,7 @@ var postgresDiff = (hasTable) => {
       notNull: and(def.notNull, isNull(def.identity)),
       defaultValue
     }).from(def);
-    if (columnInfo.length === 0) return tableApi.create().map(inline3);
+    if (columnInfo.length === 0) return tableApi.create().map(inline2);
     const localColumns = new Map(
       columnInfo.map((column2) => {
         return [
@@ -1645,7 +1074,7 @@ var postgresDiff = (hasTable) => {
           })
         );
       } else {
-        if (inline3(localInstruction.type) !== inline3(schemaInstruction.type)) {
+        if (inline2(localInstruction.type) !== inline2(schemaInstruction.type)) {
           stmts.push(
             sql.query({
               alterTable,
@@ -1666,8 +1095,8 @@ var postgresDiff = (hasTable) => {
         }
         const localDefault = localInstruction.defaultValue;
         const schemaDefault = schemaInstruction.defaultValue;
-        const localDefaultStr = localDefault && inline3(localDefault);
-        const schemaDefaultStr = schemaDefault && inline3(schemaDefault);
+        const localDefaultStr = localDefault && inline2(localDefault);
+        const schemaDefaultStr = schemaDefault && inline2(schemaDefault);
         if (localDefaultStr !== schemaDefaultStr) {
           stmts.push(
             sql.query({
@@ -1681,7 +1110,7 @@ var postgresDiff = (hasTable) => {
         }
       }
     }
-    return stmts.map(inline3);
+    return stmts.map(inline2);
   });
 };
 
@@ -1707,7 +1136,7 @@ async function acquireClient(client, depth) {
     release: () => acquired.release()
   };
 }
-var PreparedStatement8 = class {
+var PreparedStatement5 = class {
   constructor(client, sql2, name) {
     this.client = client;
     this.sql = sql2;
@@ -1724,14 +1153,12 @@ var PreparedStatement8 = class {
     }).then((res) => res.rows);
   }
   async run(params) {
-    await this.client.query(
-      {
-        name: this.name,
-        text: this.sql,
-        values: params
-      },
-      params
-    );
+    const result = await this.client.query({
+      name: this.name,
+      text: this.sql,
+      values: params
+    });
+    return { affectedRows: result.rowCount ?? 0 };
   }
   get(params) {
     return this.all(params).then((rows) => rows[0] ?? null);
@@ -1760,7 +1187,7 @@ var PgDriver = class _PgDriver {
     await this.client.query(query);
   }
   prepare(sql2, options) {
-    return new PreparedStatement8(this.client, sql2, options?.name);
+    return new PreparedStatement5(this.client, sql2, options?.name);
   }
   async close() {
     if (this.depth > 0) throw new Error("Cannot close a transaction");
@@ -1768,12 +1195,7 @@ var PgDriver = class _PgDriver {
     if ("end" in this.client) return this.client.end();
   }
   async batch(queries) {
-    return this.transaction(async (tx) => {
-      const results = [];
-      for (const { sql: sql2, params } of queries)
-        results.push(await tx.prepare(sql2).values(params));
-      return results;
-    }, {});
+    return this.transaction((tx) => Batch.run(tx, queries), {});
   }
   async transaction(run, options) {
     const { client, release } = await acquireClient(this.client, this.depth);
@@ -1786,20 +1208,24 @@ var PgDriver = class _PgDriver {
       );
       return result;
     } catch (error) {
-      await client.query(
-        this.depth > 0 ? `rollback to savepoint d${this.depth}` : "rollback"
-      );
+      try {
+        await client.query(
+          this.depth > 0 ? `rollback to savepoint d${this.depth}` : "rollback"
+        );
+      } catch {
+      }
       throw error;
     } finally {
       release?.();
     }
   }
 };
-function connect7(client) {
+function connect8(client, options) {
   return new AsyncDatabase(
     new PgDriver(client),
     postgresDialect,
-    postgresDiff
+    postgresDiff,
+    options
   );
 }
 
@@ -1814,7 +1240,7 @@ var RAW_DATE_TIME_PARSERS = {
   1184: (value) => value
   // timestamptz
 };
-var PreparedStatement9 = class {
+var PreparedStatement6 = class {
   constructor(client, sql2) {
     this.client = client;
     this.sql = sql2;
@@ -1828,10 +1254,11 @@ var PreparedStatement9 = class {
     }).then((res) => res.rows);
   }
   async run(params) {
-    await this.client.query(this.sql, params, {
+    const result = await this.client.query(this.sql, params, {
       rowMode: "array",
       parsers: RAW_DATE_TIME_PARSERS
     });
+    return { affectedRows: result.affectedRows ?? 0 };
   }
   get(params) {
     return this.all(params).then((rows) => rows[0] ?? null);
@@ -1862,15 +1289,10 @@ var PGliteDriver = class _PGliteDriver {
     throw new Error("Cannot close a transaction");
   }
   prepare(sql2) {
-    return new PreparedStatement9(this.client, sql2);
+    return new PreparedStatement6(this.client, sql2);
   }
   async batch(queries) {
-    const transact = async (tx) => {
-      const results = [];
-      for (const { sql: sql2, params } of queries)
-        results.push(await tx.prepare(sql2).values(params));
-      return results;
-    };
+    const transact = (tx) => Batch.run(tx, queries);
     if (this.depth > 0) return transact(this);
     return this.transaction(transact, {});
   }
@@ -1886,87 +1308,21 @@ var PGliteDriver = class _PGliteDriver {
       await this.exec(`release d${this.depth}`);
       return result;
     } catch (error) {
-      await this.exec(`rollback to d${this.depth}`);
+      try {
+        await this.exec(`rollback to d${this.depth}`);
+      } catch {
+      }
       throw error;
     }
   }
 };
-function connect8(db) {
-  return new AsyncDatabase(new PGliteDriver(db), postgresDialect, postgresDiff);
-}
-
-// node_modules/rado/dist/driver/sql.js.js
-var PreparedStatement10 = class {
-  constructor(client, stmt) {
-    this.client = client;
-    this.stmt = stmt;
-  }
-  client;
-  stmt;
-  *iterate(params) {
-    this.stmt.bind(params);
-    while (this.stmt.step()) yield this.stmt.getAsObject();
-    this.stmt.reset();
-  }
-  *iterateValues(params) {
-    this.stmt.bind(params);
-    while (this.stmt.step()) yield this.stmt.get();
-    this.stmt.reset();
-  }
-  all(params) {
-    return Array.from(this.iterate(params));
-  }
-  run(params) {
-    this.stmt.run(params);
-    this.stmt.reset();
-    return { rowsAffected: this.client.getRowsModified() };
-  }
-  get(params) {
-    return this.all(params)[0] ?? null;
-  }
-  values(params) {
-    return Array.from(this.iterateValues(params));
-  }
-  free() {
-    this.stmt.free();
-  }
-};
-var SqlJsDriver = class _SqlJsDriver {
-  constructor(client, depth = 0) {
-    this.client = client;
-    this.depth = depth;
-  }
-  client;
-  depth;
-  parsesJson = false;
-  supportsTransactions = true;
-  exec(query) {
-    this.client.exec(query);
-  }
-  close() {
-    this.client.close();
-  }
-  prepare(sql2) {
-    return new PreparedStatement10(this.client, this.client.prepare(sql2));
-  }
-  batch(queries) {
-    return this.transaction(
-      (tx) => queries.map(({ sql: sql2, params }) => tx.prepare(sql2).values(params)),
-      {}
-    );
-  }
-  transaction(run, options) {
-    return execTransaction(
-      this,
-      this.depth,
-      (depth) => new _SqlJsDriver(this.client, depth),
-      run,
-      options
-    );
-  }
-};
-function connect9(db) {
-  return new SyncDatabase(new SqlJsDriver(db), sqliteDialect, sqliteDiff);
+function connect9(db, options) {
+  return new AsyncDatabase(
+    new PGliteDriver(db),
+    postgresDialect,
+    postgresDiff,
+    options
+  );
 }
 
 export {