drizzle-databend 0.1.11 → 0.1.12

package/dist/index.mjs

@@ -125,8 +125,140 @@ async function closeClientConnection(connection) {
   }
 }
 
+// src/databend-core/columns/custom.ts
+import { entityKind as entityKind2 } from "drizzle-orm/entity";
+
+// src/databend-core/columns/common.ts
+import { Column } from "drizzle-orm/column";
+import { ColumnBuilder } from "drizzle-orm/column-builder";
+import { entityKind } from "drizzle-orm/entity";
+var DatabendColumnBuilder = class extends ColumnBuilder {
+  static [entityKind] = "DatabendColumnBuilder";
+  generatedAlwaysAs(as, _config) {
+    this.config.generated = { as, type: "always", mode: "stored" };
+    return this;
+  }
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
+  }
+  /** @internal */
+  buildForeignKeys(_column, _table) {
+    return [];
+  }
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new DatabendExtraConfigColumn(table, this.config);
+  }
+};
+var DatabendColumn = class extends Column {
+  static [entityKind] = "DatabendColumn";
+  constructor(table, config) {
+    super(table, config);
+  }
+  getSQLType() {
+    return "";
+  }
+};
+var DatabendExtraConfigColumn = class extends DatabendColumn {
+  static [entityKind] = "DatabendExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
+  }
+  indexConfig = {
+    order: this.config.order ?? "asc",
+    nulls: this.config.nulls ?? "last",
+    opClass: this.config.opClass
+  };
+  defaultConfig = {
+    order: "asc",
+    nulls: "last",
+    opClass: void 0
+  };
+  asc() {
+    this.indexConfig.order = "asc";
+    return this;
+  }
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
+  }
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
+  }
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
+  }
+};
+var IndexedColumn = class {
+  static [entityKind] = "IndexedColumn";
+  name;
+  keyAsName;
+  type;
+  indexConfig;
+  constructor(name, keyAsName, type, indexConfig) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+};
+
+// src/databend-core/columns/custom.ts
+var DatabendCustomColumnBuilder = class extends DatabendColumnBuilder {
+  static [entityKind2] = "DatabendCustomColumnBuilder";
+  sqlDataType;
+  mapTo;
+  mapFrom;
+  constructor(name, fieldConfig, customTypeParams) {
+    super(name, "custom", "DatabendCustomColumn");
+    this.sqlDataType = customTypeParams.dataType(fieldConfig);
+    this.mapTo = customTypeParams.toDriver;
+    this.mapFrom = customTypeParams.fromDriver;
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendCustomColumn(
+      table,
+      this.config,
+      this.sqlDataType,
+      this.mapTo,
+      this.mapFrom
+    );
+  }
+};
+var DatabendCustomColumn = class extends DatabendColumn {
+  static [entityKind2] = "DatabendCustomColumn";
+  sqlDataType;
+  mapTo;
+  mapFrom;
+  constructor(table, config, sqlDataType, mapTo, mapFrom) {
+    super(table, config);
+    this.sqlDataType = sqlDataType;
+    this.mapTo = mapTo;
+    this.mapFrom = mapFrom;
+  }
+  getSQLType() {
+    return this.sqlDataType;
+  }
+  mapFromDriverValue(value) {
+    return this.mapFrom ? this.mapFrom(value) : value;
+  }
+  mapToDriverValue(value) {
+    return this.mapTo ? this.mapTo(value) : value;
+  }
+};
+function customType(customTypeParams) {
+  return (dbName, fieldConfig) => {
+    return new DatabendCustomColumnBuilder(dbName, fieldConfig, customTypeParams);
+  };
+}
+
 // src/columns.ts
-import { customType } from "drizzle-orm/pg-core";
 var databendVariant = (name) => customType({
   dataType() {
     return "VARIANT";
@@ -221,118 +353,2331 @@ var databendTimestamp = (name) => customType({
     const normalized = hasOffset ? str.replace(" ", "T") : `${str.replace(" ", "T")}Z`;
     return new Date(normalized);
   }
-})(name);
-var databendDate = (name) => customType({
-  dataType() {
-    return "DATE";
-  },
-  toDriver(value) {
-    if (value instanceof Date) {
-      return value.toISOString().slice(0, 10);
-    }
-    return value;
-  },
-  fromDriver(value) {
-    if (value instanceof Date) {
-      return value.toISOString().slice(0, 10);
+})(name);
+var databendDate = (name) => customType({
+  dataType() {
+    return "DATE";
+  },
+  toDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    return value;
+  },
+  fromDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    return value.slice(0, 10);
+  }
+})(name);
+
+// src/databend-core/alias.ts
+import { TableAliasProxyHandler } from "drizzle-orm/alias";
+function alias(table, alias2) {
+  return new Proxy(table, new TableAliasProxyHandler(alias2, false));
+}
+
+// src/databend-core/columns/bigint.ts
+import { entityKind as entityKind3 } from "drizzle-orm/entity";
+var DatabendBigInt53Builder = class extends DatabendColumnBuilder {
+  static [entityKind3] = "DatabendBigInt53Builder";
+  constructor(name) {
+    super(name, "number", "DatabendBigInt53");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendBigInt53(table, this.config);
+  }
+};
+var DatabendBigInt53 = class extends DatabendColumn {
+  static [entityKind3] = "DatabendBigInt53";
+  getSQLType() {
+    return "bigint";
+  }
+};
+var DatabendBigInt64Builder = class extends DatabendColumnBuilder {
+  static [entityKind3] = "DatabendBigInt64Builder";
+  constructor(name) {
+    super(name, "bigint", "DatabendBigInt64");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendBigInt64(table, this.config);
+  }
+};
+var DatabendBigInt64 = class extends DatabendColumn {
+  static [entityKind3] = "DatabendBigInt64";
+  getSQLType() {
+    return "bigint";
+  }
+  mapFromDriverValue(value) {
+    return BigInt(value);
+  }
+};
+function bigint(name) {
+  return new DatabendBigInt53Builder(name ?? "");
+}
+
+// src/databend-core/columns/binary.ts
+import { entityKind as entityKind4 } from "drizzle-orm/entity";
+var DatabendBinaryBuilder = class extends DatabendColumnBuilder {
+  static [entityKind4] = "DatabendBinaryBuilder";
+  constructor(name) {
+    super(name, "string", "DatabendBinary");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendBinary(table, this.config);
+  }
+};
+var DatabendBinary = class extends DatabendColumn {
+  static [entityKind4] = "DatabendBinary";
+  getSQLType() {
+    return "binary";
+  }
+};
+function binary(name) {
+  return new DatabendBinaryBuilder(name ?? "");
+}
+
+// src/databend-core/columns/bitmap.ts
+import { entityKind as entityKind5 } from "drizzle-orm/entity";
+var DatabendBitmapBuilder = class extends DatabendColumnBuilder {
+  static [entityKind5] = "DatabendBitmapBuilder";
+  constructor(name) {
+    super(name, "string", "DatabendBitmap");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendBitmap(table, this.config);
+  }
+};
+var DatabendBitmap = class extends DatabendColumn {
+  static [entityKind5] = "DatabendBitmap";
+  getSQLType() {
+    return "bitmap";
+  }
+};
+function bitmap(name) {
+  return new DatabendBitmapBuilder(name ?? "");
+}
+
+// src/databend-core/columns/boolean.ts
+import { entityKind as entityKind6 } from "drizzle-orm/entity";
+var DatabendBooleanBuilder = class extends DatabendColumnBuilder {
+  static [entityKind6] = "DatabendBooleanBuilder";
+  constructor(name) {
+    super(name, "boolean", "DatabendBoolean");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendBoolean(table, this.config);
+  }
+};
+var DatabendBoolean = class extends DatabendColumn {
+  static [entityKind6] = "DatabendBoolean";
+  getSQLType() {
+    return "boolean";
+  }
+};
+function boolean(name) {
+  return new DatabendBooleanBuilder(name ?? "");
+}
+
+// src/databend-core/columns/date.ts
+import { entityKind as entityKind7 } from "drizzle-orm/entity";
+import { sql } from "drizzle-orm/sql/sql";
+var DatabendDateBuilder = class extends DatabendColumnBuilder {
+  static [entityKind7] = "DatabendDateBuilder";
+  constructor(name) {
+    super(name, "string", "DatabendDate");
+  }
+  defaultNow() {
+    return this.default(sql`now()`);
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendDate(table, this.config);
+  }
+};
+var DatabendDate = class extends DatabendColumn {
+  static [entityKind7] = "DatabendDate";
+  getSQLType() {
+    return "date";
+  }
+  mapFromDriverValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    if (typeof value === "string") {
+      return value.slice(0, 10);
+    }
+    return value;
+  }
+  mapToDriverValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    return value;
+  }
+};
+function date(name) {
+  return new DatabendDateBuilder(name ?? "");
+}
+
+// src/databend-core/columns/decimal.ts
+import { entityKind as entityKind8 } from "drizzle-orm/entity";
+var DatabendDecimalBuilder = class extends DatabendColumnBuilder {
+  static [entityKind8] = "DatabendDecimalBuilder";
+  constructor(name, precision, scale) {
+    super(name, "string", "DatabendDecimal");
+    this.config.precision = precision;
+    this.config.scale = scale;
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendDecimal(table, this.config);
+  }
+};
+var DatabendDecimal = class extends DatabendColumn {
+  static [entityKind8] = "DatabendDecimal";
+  precision;
+  scale;
+  constructor(table, config) {
+    super(table, config);
+    this.precision = config.precision;
+    this.scale = config.scale;
+  }
+  getSQLType() {
+    if (this.precision !== void 0 && this.scale !== void 0) {
+      return `decimal(${this.precision}, ${this.scale})`;
+    }
+    if (this.precision !== void 0) {
+      return `decimal(${this.precision})`;
+    }
+    return "decimal";
+  }
+};
+function decimal(name, config) {
+  return new DatabendDecimalBuilder(name ?? "", config?.precision, config?.scale);
+}
+
+// src/databend-core/columns/double.ts
+import { entityKind as entityKind9 } from "drizzle-orm/entity";
+var DatabendDoublePrecisionBuilder = class extends DatabendColumnBuilder {
+  static [entityKind9] = "DatabendDoublePrecisionBuilder";
+  constructor(name) {
+    super(name, "number", "DatabendDoublePrecision");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendDoublePrecision(table, this.config);
+  }
+};
+var DatabendDoublePrecision = class extends DatabendColumn {
+  static [entityKind9] = "DatabendDoublePrecision";
+  getSQLType() {
+    return "double";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      return Number.parseFloat(value);
+    }
+    return value;
+  }
+};
+function doublePrecision(name) {
+  return new DatabendDoublePrecisionBuilder(name ?? "");
+}
+
+// src/databend-core/columns/float.ts
+import { entityKind as entityKind10 } from "drizzle-orm/entity";
+var DatabendRealBuilder = class extends DatabendColumnBuilder {
+  static [entityKind10] = "DatabendRealBuilder";
+  constructor(name) {
+    super(name, "number", "DatabendReal");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendReal(table, this.config);
+  }
+};
+var DatabendReal = class extends DatabendColumn {
+  static [entityKind10] = "DatabendReal";
+  getSQLType() {
+    return "real";
+  }
+};
+function real(name) {
+  return new DatabendRealBuilder(name ?? "");
+}
+function float(name) {
+  return new DatabendRealBuilder(name ?? "");
+}
+
+// src/databend-core/columns/integer.ts
+import { entityKind as entityKind11 } from "drizzle-orm/entity";
+var DatabendIntegerBuilder = class extends DatabendColumnBuilder {
+  static [entityKind11] = "DatabendIntegerBuilder";
+  constructor(name) {
+    super(name, "number", "DatabendInteger");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendInteger(table, this.config);
+  }
+};
+var DatabendInteger = class extends DatabendColumn {
+  static [entityKind11] = "DatabendInteger";
+  getSQLType() {
+    return "integer";
+  }
+};
+function integer(name) {
+  return new DatabendIntegerBuilder(name ?? "");
+}
+
+// src/databend-core/columns/smallint.ts
+import { entityKind as entityKind12 } from "drizzle-orm/entity";
+var DatabendSmallIntBuilder = class extends DatabendColumnBuilder {
+  static [entityKind12] = "DatabendSmallIntBuilder";
+  constructor(name) {
+    super(name, "number", "DatabendSmallInt");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendSmallInt(table, this.config);
+  }
+};
+var DatabendSmallInt = class extends DatabendColumn {
+  static [entityKind12] = "DatabendSmallInt";
+  getSQLType() {
+    return "smallint";
+  }
+};
+function smallint(name) {
+  return new DatabendSmallIntBuilder(name ?? "");
+}
+
+// src/databend-core/columns/text.ts
+import { entityKind as entityKind13 } from "drizzle-orm/entity";
+var DatabendTextBuilder = class extends DatabendColumnBuilder {
+  static [entityKind13] = "DatabendTextBuilder";
+  constructor(name) {
+    super(name, "string", "DatabendText");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendText(table, this.config);
+  }
+};
+var DatabendText = class extends DatabendColumn {
+  static [entityKind13] = "DatabendText";
+  getSQLType() {
+    return "text";
+  }
+};
+function text(name) {
+  return new DatabendTextBuilder(name ?? "");
+}
+
+// src/databend-core/columns/timestamp.ts
+import { entityKind as entityKind14 } from "drizzle-orm/entity";
+import { sql as sql2 } from "drizzle-orm/sql/sql";
+var DatabendTimestampBuilder = class extends DatabendColumnBuilder {
+  static [entityKind14] = "DatabendTimestampBuilder";
+  constructor(name) {
+    super(name, "date", "DatabendTimestamp");
+  }
+  defaultNow() {
+    return this.default(sql2`now()`);
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendTimestamp(table, this.config);
+  }
+};
+var DatabendTimestamp = class extends DatabendColumn {
+  static [entityKind14] = "DatabendTimestamp";
+  getSQLType() {
+    return "timestamp";
+  }
+  mapFromDriverValue(value) {
+    if (value instanceof Date) {
+      return value;
+    }
+    const str = String(value);
+    const hasOffset = str.endsWith("Z") || /[+-]\d{2}:?\d{2}$/.test(str);
+    const normalized = hasOffset ? str.replace(" ", "T") : `${str.replace(" ", "T")}Z`;
+    return new Date(normalized);
+  }
+  mapToDriverValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return value;
+  }
+};
+function timestamp(name) {
+  return new DatabendTimestampBuilder(name ?? "");
+}
+
+// src/databend-core/columns/tinyint.ts
+import { entityKind as entityKind15 } from "drizzle-orm/entity";
+var DatabendTinyIntBuilder = class extends DatabendColumnBuilder {
+  static [entityKind15] = "DatabendTinyIntBuilder";
+  constructor(name) {
+    super(name, "number", "DatabendTinyInt");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendTinyInt(table, this.config);
+  }
+};
+var DatabendTinyInt = class extends DatabendColumn {
+  static [entityKind15] = "DatabendTinyInt";
+  getSQLType() {
+    return "tinyint";
+  }
+};
+function tinyint(name) {
+  return new DatabendTinyIntBuilder(name ?? "");
+}
+
+// src/databend-core/columns/varchar.ts
+import { entityKind as entityKind16 } from "drizzle-orm/entity";
+var DatabendVarcharBuilder = class extends DatabendColumnBuilder {
+  static [entityKind16] = "DatabendVarcharBuilder";
+  constructor(name, length) {
+    super(name, "string", "DatabendVarchar");
+    this.config.length = length;
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendVarchar(table, this.config);
+  }
+};
+var DatabendVarchar = class extends DatabendColumn {
+  static [entityKind16] = "DatabendVarchar";
+  length;
+  constructor(table, config) {
+    super(table, config);
+    this.length = config.length;
+  }
+  getSQLType() {
+    return this.length ? `varchar(${this.length})` : "varchar";
+  }
+};
+function varchar(name, config) {
+  return new DatabendVarcharBuilder(name ?? "", config?.length);
+}
+
+// src/databend-core/columns/variant.ts
+import { entityKind as entityKind17 } from "drizzle-orm/entity";
+var DatabendVariantBuilder = class extends DatabendColumnBuilder {
+  static [entityKind17] = "DatabendVariantBuilder";
+  constructor(name) {
+    super(name, "json", "DatabendVariant");
+  }
+  /** @internal */
+  build(table) {
+    return new DatabendVariant(table, this.config);
+  }
+};
+var DatabendVariant = class extends DatabendColumn {
+  static [entityKind17] = "DatabendVariant";
+  getSQLType() {
+    return "variant";
+  }
+  mapFromDriverValue(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+  mapToDriverValue(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+};
+function variant(name) {
+  return new DatabendVariantBuilder(name ?? "");
+}
+
+// src/databend-core/columns/all.ts
+function getDatabendColumnBuilders() {
+  return {
+    bigint,
+    binary,
+    bitmap,
+    boolean,
+    customType,
+    date,
+    decimal,
+    doublePrecision,
+    float,
+    integer,
+    real,
+    smallint,
+    text,
+    timestamp,
+    tinyint,
+    varchar,
+    variant
+  };
+}
+
+// src/databend-core/dialect.ts
+import { aliasedTable, aliasedTableColumn, mapColumnsInAliasedSQLToAlias, mapColumnsInSQLToAlias } from "drizzle-orm/alias";
+import { CasingCache } from "drizzle-orm/casing";
+import { Column as Column2 } from "drizzle-orm/column";
+import { entityKind as entityKind20, is } from "drizzle-orm/entity";
+import { DrizzleError } from "drizzle-orm/errors";
+import {
+  getOperators,
+  getOrderByOperators,
+  Many,
+  normalizeRelation,
+  One
+} from "drizzle-orm/relations";
+import { and, eq, View as View2 } from "drizzle-orm/sql";
+import { Param, SQL, sql as sql3 } from "drizzle-orm/sql/sql";
+import { Subquery } from "drizzle-orm/subquery";
+import { getTableName, getTableUniqueName, Table as Table2 } from "drizzle-orm/table";
+import { orderSelectedFields } from "drizzle-orm/utils";
+import { ViewBaseConfig } from "drizzle-orm/view-common";
+
+// src/databend-core/table.ts
+import { entityKind as entityKind18 } from "drizzle-orm/entity";
+import { Table } from "drizzle-orm/table";
+var DatabendTable = class extends Table {
+  static [entityKind18] = "DatabendTable";
+  /** @internal */
+  static Symbol = Object.assign({}, Table.Symbol, {});
+  constructor(name, schema, baseName) {
+    super(name, schema, baseName);
+    this[Table.Symbol.ExtraConfigBuilder] = void 0;
+    this[Table.Symbol.ExtraConfigColumns] = {};
+  }
+};
+function databendTableWithSchema(name, columns, extraConfig, schema, baseName = name) {
+  const rawTable = new DatabendTable(name, schema, baseName);
+  const parsedColumns = typeof columns === "function" ? columns(getDatabendColumnBuilders()) : columns;
+  const builtColumns = Object.fromEntries(
+    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+      const colBuilder = colBuilderBase;
+      colBuilder.setName(name2);
+      const column = colBuilder.build(rawTable);
+      return [name2, column];
+    })
+  );
+  const builtColumnsForExtraConfig = Object.fromEntries(
+    Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+      const colBuilder = colBuilderBase;
+      colBuilder.setName(name2);
+      const column = colBuilder.buildExtraConfigColumn(rawTable);
+      return [name2, column];
+    })
+  );
+  const table = Object.assign(rawTable, builtColumns);
+  table[Table.Symbol.Columns] = builtColumns;
+  table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
+  if (extraConfig) {
+    table[DatabendTable.Symbol.ExtraConfigBuilder] = extraConfig;
+  }
+  return table;
+}
+var databendTable = (name, columns, extraConfig) => {
+  return databendTableWithSchema(name, columns, extraConfig, void 0);
+};
+function databendTableCreator(customizeTableName) {
+  return (name, columns, extraConfig) => {
+    return databendTableWithSchema(customizeTableName(name), columns, extraConfig, void 0, name);
+  };
+}
+
+// src/databend-core/view-base.ts
+import { entityKind as entityKind19 } from "drizzle-orm/entity";
+import { View } from "drizzle-orm/sql/sql";
+var DatabendViewBase = class extends View {
+  static [entityKind19] = "DatabendViewBase";
+};
+
+// src/databend-core/dialect.ts
+var DatabendDialect = class {
+  static [entityKind20] = "DatabendDialect";
+  /** @internal */
+  casing;
+  constructor(config) {
+    this.casing = new CasingCache(config?.casing);
+  }
+  async migrate(migrations, session, config) {
+    const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
+    const migrationsSchema = migrationConfig.migrationsSchema ?? "default";
+    const migrationsTable = migrationConfig.migrationsTable ?? "__drizzle_migrations";
+    const migrationTableCreate = sql3`
+      CREATE TABLE IF NOT EXISTS ${sql3.identifier(migrationsSchema)}.${sql3.identifier(
+      migrationsTable
+    )} (
+        id INT NOT NULL,
+        hash VARCHAR NOT NULL,
+        created_at BIGINT
+      )
+    `;
+    await session.execute(migrationTableCreate);
+    const dbMigrations = await session.all(
+      sql3`SELECT id, hash, created_at FROM ${sql3.identifier(
+        migrationsSchema
+      )}.${sql3.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
+    );
+    const lastDbMigration = dbMigrations[0];
+    await session.transaction(async (tx) => {
+      for await (const migration of migrations) {
+        if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
+          for (const stmt of migration.sql) {
+            await tx.execute(sql3.raw(stmt));
+          }
+          await tx.execute(
+            sql3`INSERT INTO ${sql3.identifier(
+              migrationsSchema
+            )}.${sql3.identifier(migrationsTable)} (id, hash, created_at)
+              VALUES (
+                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql3.identifier(
+              migrationsSchema
+            )}.${sql3.identifier(migrationsTable)}),
+                ${migration.hash},
+                ${migration.folderMillis}
+              )`
+          );
+        }
+      }
+    });
+  }
+  escapeName(name) {
+    return `"${name}"`;
+  }
+  escapeParam(num) {
+    return `$${num + 1}`;
+  }
+  escapeString(str) {
+    return `'${str.replace(/'/g, "''")}'`;
+  }
+  buildWithCTE(queries) {
+    if (!queries?.length) return void 0;
+    const withSqlChunks = [sql3`with `];
+    for (const [i, w] of queries.entries()) {
+      withSqlChunks.push(sql3`${sql3.identifier(w._.alias)} as (${w._.sql})`);
+      if (i < queries.length - 1) {
+        withSqlChunks.push(sql3`, `);
+      }
+    }
+    withSqlChunks.push(sql3` `);
+    return sql3.join(withSqlChunks);
+  }
+  buildDeleteQuery({ table, where, withList }) {
+    const withSql = this.buildWithCTE(withList);
+    const whereSql = where ? sql3` where ${where}` : void 0;
+    return sql3`${withSql}delete from ${table}${whereSql}`;
+  }
+  buildUpdateSet(table, set) {
+    const tableColumns = table[Table2.Symbol.Columns];
+    const columnNames = Object.keys(tableColumns).filter(
+      (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0
+    );
+    const setSize = columnNames.length;
+    return sql3.join(
+      columnNames.flatMap((colName, i) => {
+        const col = tableColumns[colName];
+        const value = set[colName] ?? sql3.param(col.onUpdateFn(), col);
+        const res = sql3`${sql3.identifier(this.casing.getColumnCasing(col))} = ${value}`;
+        if (i < setSize - 1) {
+          return [res, sql3.raw(", ")];
+        }
+        return [res];
+      })
+    );
+  }
+  buildUpdateQuery({ table, set, where, withList }) {
+    const withSql = this.buildWithCTE(withList);
+    const tableName = table[DatabendTable.Symbol.Name];
+    const tableSchema = table[DatabendTable.Symbol.Schema];
+    const origTableName = table[DatabendTable.Symbol.OriginalName];
+    const alias2 = tableName === origTableName ? void 0 : tableName;
+    const tableSql = sql3`${tableSchema ? sql3`${sql3.identifier(tableSchema)}.` : void 0}${sql3.identifier(origTableName)}${alias2 && sql3` ${sql3.identifier(alias2)}`}`;
+    const setSql = this.buildUpdateSet(table, set);
+    const whereSql = where ? sql3` where ${where}` : void 0;
+    return sql3`${withSql}update ${tableSql} set ${setSql}${whereSql}`;
+  }
+  buildSelection(fields, { isSingleTable = false } = {}) {
+    const columnsLen = fields.length;
+    const chunks = fields.flatMap(({ field }, i) => {
+      const chunk = [];
+      if (is(field, SQL.Aliased) && field.isSelectionField) {
+        chunk.push(sql3.identifier(field.fieldAlias));
+      } else if (is(field, SQL.Aliased) || is(field, SQL)) {
+        const query = is(field, SQL.Aliased) ? field.sql : field;
+        if (isSingleTable) {
+          chunk.push(
+            new SQL(
+              query.queryChunks.map((c) => {
+                if (is(c, DatabendColumn)) {
+                  return sql3.identifier(this.casing.getColumnCasing(c));
+                }
+                return c;
+              })
+            )
+          );
+        } else {
+          chunk.push(query);
+        }
+        if (is(field, SQL.Aliased)) {
+          chunk.push(sql3` as ${sql3.identifier(field.fieldAlias)}`);
+        }
+      } else if (is(field, Column2)) {
+        if (isSingleTable) {
+          chunk.push(sql3.identifier(this.casing.getColumnCasing(field)));
+        } else {
+          chunk.push(field);
+        }
+      }
+      if (i < columnsLen - 1) {
+        chunk.push(sql3`, `);
+      }
+      return chunk;
+    });
+    return sql3.join(chunks);
+  }
+  buildJoins(joins) {
+    if (!joins || joins.length === 0) {
+      return void 0;
+    }
+    const joinsArray = [];
+    for (const [index2, joinMeta] of joins.entries()) {
+      if (index2 === 0) {
+        joinsArray.push(sql3` `);
+      }
+      const table = joinMeta.table;
+      const lateralSql = joinMeta.lateral ? sql3` lateral` : void 0;
+      if (is(table, DatabendTable)) {
+        const t = table;
+        const tableName = t[DatabendTable.Symbol.Name];
+        const tableSchema = t[DatabendTable.Symbol.Schema];
+        const origTableName = t[DatabendTable.Symbol.OriginalName];
+        const alias2 = tableName === origTableName ? void 0 : joinMeta.alias;
+        joinsArray.push(
+          sql3`${sql3.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql3`${sql3.identifier(tableSchema)}.` : void 0}${sql3.identifier(origTableName)}${alias2 && sql3` ${sql3.identifier(alias2)}`} on ${joinMeta.on}`
+        );
+      } else if (is(table, View2)) {
+        const viewName = table[ViewBaseConfig].name;
+        const viewSchema = table[ViewBaseConfig].schema;
+        const origViewName = table[ViewBaseConfig].originalName;
+        const alias2 = viewName === origViewName ? void 0 : joinMeta.alias;
+        joinsArray.push(
+          sql3`${sql3.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql3`${sql3.identifier(viewSchema)}.` : void 0}${sql3.identifier(origViewName)}${alias2 && sql3` ${sql3.identifier(alias2)}`} on ${joinMeta.on}`
+        );
+      } else {
+        joinsArray.push(
+          sql3`${sql3.raw(joinMeta.joinType)} join${lateralSql} ${table} on ${joinMeta.on}`
+        );
+      }
+      if (index2 < joins.length - 1) {
+        joinsArray.push(sql3` `);
+      }
+    }
+    return sql3.join(joinsArray);
+  }
+  buildFromTable(table) {
+    if (is(table, Table2)) {
+      const t = table;
+      if (t[Table2.Symbol.OriginalName] !== t[Table2.Symbol.Name]) {
+        let fullName = sql3`${sql3.identifier(t[Table2.Symbol.OriginalName])}`;
+        if (t[Table2.Symbol.Schema]) {
+          fullName = sql3`${sql3.identifier(t[Table2.Symbol.Schema])}.${fullName}`;
+        }
+        return sql3`${fullName} ${sql3.identifier(t[Table2.Symbol.Name])}`;
+      }
+    }
+    return table;
+  }
+  buildSelectQuery({
+    withList,
+    fields,
+    fieldsFlat,
+    where,
+    having,
+    table,
+    joins,
+    orderBy,
+    groupBy,
+    limit,
+    offset,
+    distinct,
+    setOperators
+  }) {
+    const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
+    for (const f of fieldsList) {
+      if (is(f.field, Column2) && getTableName(f.field.table) !== (is(table, Subquery) ? table._.alias : is(table, DatabendViewBase) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : getTableName(table)) && !((table2) => joins?.some(
+        ({ alias: alias2 }) => alias2 === (table2[Table2.Symbol.IsAlias] ? getTableName(table2) : table2[Table2.Symbol.BaseName])
+      ))(f.field.table)) {
+        const tableName = getTableName(f.field.table);
+        throw new Error(
+          `Your "${f.path.join("->")}" field references a column "${tableName}"."${f.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`
+        );
+      }
+    }
+    const isSingleTable = !joins || joins.length === 0;
+    const withSql = this.buildWithCTE(withList);
+    let distinctSql;
+    if (distinct) {
+      distinctSql = distinct === true ? sql3` distinct` : sql3` distinct on (${sql3.join(distinct.on, sql3`, `)})`;
+    }
+    const selection = this.buildSelection(fieldsList, { isSingleTable });
+    const tableSql = this.buildFromTable(table);
+    const joinsSql = this.buildJoins(joins);
+    const whereSql = where ? sql3` where ${where}` : void 0;
+    const havingSql = having ? sql3` having ${having}` : void 0;
+    let orderBySql;
+    if (orderBy && orderBy.length > 0) {
+      orderBySql = sql3` order by ${sql3.join(orderBy, sql3`, `)}`;
+    }
+    let groupBySql;
+    if (groupBy && groupBy.length > 0) {
+      groupBySql = sql3` group by ${sql3.join(groupBy, sql3`, `)}`;
+    }
+    const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql3` limit ${limit}` : void 0;
+    const offsetSql = offset ? sql3` offset ${offset}` : void 0;
+    const finalQuery = sql3`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
+    if (setOperators.length > 0) {
+      return this.buildSetOperations(finalQuery, setOperators);
+    }
+    return finalQuery;
+  }
+  buildSetOperations(leftSelect, setOperators) {
+    const [setOperator, ...rest] = setOperators;
+    if (!setOperator) {
+      throw new Error("Cannot pass undefined values to any set operator");
+    }
+    if (rest.length === 0) {
+      return this.buildSetOperationQuery({ leftSelect, setOperator });
+    }
+    return this.buildSetOperations(
+      this.buildSetOperationQuery({ leftSelect, setOperator }),
+      rest
+    );
+  }
+  buildSetOperationQuery({
+    leftSelect,
+    setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
+  }) {
+    const leftChunk = sql3`(${leftSelect.getSQL()}) `;
+    const rightChunk = sql3`(${rightSelect.getSQL()})`;
+    let orderBySql;
+    if (orderBy && orderBy.length > 0) {
+      const orderByValues = [];
+      for (const singleOrderBy of orderBy) {
+        if (is(singleOrderBy, DatabendColumn)) {
+          orderByValues.push(sql3.identifier(singleOrderBy.name));
+        } else if (is(singleOrderBy, SQL)) {
+          for (let i = 0; i < singleOrderBy.queryChunks.length; i++) {
+            const chunk = singleOrderBy.queryChunks[i];
+            if (is(chunk, DatabendColumn)) {
+              singleOrderBy.queryChunks[i] = sql3.identifier(chunk.name);
+            }
+          }
+          orderByValues.push(sql3`${singleOrderBy}`);
+        } else {
+          orderByValues.push(sql3`${singleOrderBy}`);
+        }
+      }
+      orderBySql = sql3` order by ${sql3.join(orderByValues, sql3`, `)} `;
+    }
+    const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql3` limit ${limit}` : void 0;
+    const operatorChunk = sql3.raw(`${type} ${isAll ? "all " : ""}`);
+    const offsetSql = offset ? sql3` offset ${offset}` : void 0;
+    return sql3`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
+  }
+  buildInsertQuery({ table, values: valuesOrSelect, withList, select }) {
+    const valuesSqlList = [];
+    const columns = table[Table2.Symbol.Columns];
+    const colEntries = Object.entries(columns).filter(([_, col]) => !col.shouldDisableInsert());
+    const insertOrder = colEntries.map(
+      ([, column]) => sql3.identifier(this.casing.getColumnCasing(column))
+    );
+    if (select) {
+      const select2 = valuesOrSelect;
+      if (is(select2, SQL)) {
+        valuesSqlList.push(select2);
+      } else {
+        valuesSqlList.push(select2.getSQL());
+      }
+    } else {
+      const values = valuesOrSelect;
+      valuesSqlList.push(sql3.raw("values "));
+      for (const [valueIndex, value] of values.entries()) {
+        const valueList = [];
+        for (const [fieldName, col] of colEntries) {
+          const colValue = value[fieldName];
+          if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
+            if (col.defaultFn !== void 0) {
+              const defaultFnResult = col.defaultFn();
+              const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql3.param(defaultFnResult, col);
+              valueList.push(defaultValue);
+            } else if (!col.default && col.onUpdateFn !== void 0) {
+              const onUpdateFnResult = col.onUpdateFn();
+              const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql3.param(onUpdateFnResult, col);
+              valueList.push(newValue);
+            } else {
+              valueList.push(sql3`default`);
+            }
+          } else {
+            valueList.push(colValue);
+          }
+        }
+        valuesSqlList.push(valueList);
+        if (valueIndex < values.length - 1) {
+          valuesSqlList.push(sql3`, `);
+        }
+      }
+    }
+    const withSql = this.buildWithCTE(withList);
+    const valuesSql = sql3.join(valuesSqlList);
+    return sql3`${withSql}insert into ${table} ${insertOrder} ${valuesSql}`;
+  }
+  prepareTyping(encoder) {
+    if (is(encoder, DatabendDecimal) || is(encoder, DatabendColumn)) {
+      const sqlType = encoder.getSQLType?.();
+      if (sqlType) {
+        const lower = sqlType.toLowerCase();
+        if (lower === "integer" || lower === "int" || lower === "smallint" || lower === "tinyint" || lower === "bigint" || lower === "real" || lower === "double" || lower === "float" || lower.startsWith("decimal")) {
+          return "decimal";
+        }
+        if (lower === "timestamp") {
+          return "timestamp";
+        }
+        if (lower === "date") {
+          return "date";
+        }
+      }
+    }
+    if (is(encoder, DatabendTimestamp)) {
+      return "timestamp";
+    }
+    if (is(encoder, DatabendVariant)) {
+      return "none";
+    }
+    return "none";
+  }
+  sqlToQuery(sql22, invokeSource) {
+    return sql22.toQuery({
+      casing: this.casing,
+      escapeName: this.escapeName,
+      escapeParam: this.escapeParam,
+      escapeString: this.escapeString,
+      prepareTyping: this.prepareTyping.bind(this),
+      invokeSource
+    });
+  }
+  buildRelationalQueryWithoutPK({
+    fullSchema,
+    schema,
+    tableNamesMap,
+    table,
+    tableConfig,
+    queryConfig: config,
+    tableAlias,
+    nestedQueryRelation,
+    joinOn
+  }) {
+    let selection = [];
+    let limit, offset, orderBy = [], where;
+    const joins = [];
+    if (config === true) {
+      const selectionEntries = Object.entries(tableConfig.columns);
+      selection = selectionEntries.map(([key, value]) => ({
+        dbKey: value.name,
+        tsKey: key,
+        field: aliasedTableColumn(value, tableAlias),
+        relationTableTsKey: void 0,
+        isJson: false,
+        selection: []
+      }));
+    } else {
+      const aliasedColumns = Object.fromEntries(
+        Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])
+      );
+      if (config.where) {
+        const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
+        where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
+      }
+      const fieldsSelection = [];
+      let selectedColumns = [];
+      if (config.columns) {
+        let isIncludeMode = false;
+        for (const [field, value] of Object.entries(config.columns)) {
+          if (value === void 0) continue;
+          if (field in tableConfig.columns) {
+            if (!isIncludeMode && value === true) {
+              isIncludeMode = true;
+            }
+            selectedColumns.push(field);
+          }
+        }
+        if (selectedColumns.length > 0) {
+          selectedColumns = isIncludeMode ? selectedColumns.filter((c) => config.columns?.[c] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
+        }
+      } else {
+        selectedColumns = Object.keys(tableConfig.columns);
+      }
+      for (const field of selectedColumns) {
+        const column = tableConfig.columns[field];
+        fieldsSelection.push({ tsKey: field, value: column });
+      }
+      let selectedRelations = [];
+      if (config.with) {
+        selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({
+          tsKey,
+          queryConfig,
+          relation: tableConfig.relations[tsKey]
+        }));
+      }
+      if (config.extras) {
+        const extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql: sql3 }) : config.extras;
+        for (const [tsKey, value] of Object.entries(extras)) {
+          fieldsSelection.push({
+            tsKey,
+            value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
+          });
+        }
+      }
+      for (const { tsKey, value } of fieldsSelection) {
+        selection.push({
+          dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
+          tsKey,
+          field: is(value, Column2) ? aliasedTableColumn(value, tableAlias) : value,
+          relationTableTsKey: void 0,
+          isJson: false,
+          selection: []
+        });
+      }
+      let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
+      if (!Array.isArray(orderByOrig)) {
+        orderByOrig = [orderByOrig];
+      }
+      orderBy = orderByOrig.map((orderByValue) => {
+        if (is(orderByValue, Column2)) {
+          return aliasedTableColumn(orderByValue, tableAlias);
+        }
+        return mapColumnsInSQLToAlias(orderByValue, tableAlias);
+      });
+      limit = config.limit;
+      offset = config.offset;
+      for (const {
+        tsKey: selectedRelationTsKey,
+        queryConfig: selectedRelationConfigValue,
+        relation
+      } of selectedRelations) {
+        const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
+        const relationTableName = getTableUniqueName(relation.referencedTable);
+        const relationTableTsName = tableNamesMap[relationTableName];
+        const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
+        const joinOn2 = and(
+          ...normalizedRelation.fields.map(
+            (field2, i) => eq(
+              aliasedTableColumn(normalizedRelation.references[i], relationTableAlias),
+              aliasedTableColumn(field2, tableAlias)
+            )
+          )
+        );
+        const builtRelation = this.buildRelationalQueryWithoutPK({
+          fullSchema,
+          schema,
+          tableNamesMap,
+          table: fullSchema[relationTableTsName],
+          tableConfig: schema[relationTableTsName],
+          queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
+          tableAlias: relationTableAlias,
+          joinOn: joinOn2,
+          nestedQueryRelation: relation
+        });
+        const field = sql3`${sql3.identifier(relationTableAlias)}.${sql3.identifier("data")}`.as(selectedRelationTsKey);
+        joins.push({
+          on: sql3`true`,
+          table: new Subquery(builtRelation.sql, {}, relationTableAlias),
+          alias: relationTableAlias,
+          joinType: "left",
+          lateral: true
+        });
+        selection.push({
+          dbKey: selectedRelationTsKey,
+          tsKey: selectedRelationTsKey,
+          field,
+          relationTableTsKey: relationTableTsName,
+          isJson: true,
+          selection: builtRelation.selection
+        });
+      }
+    }
+    if (selection.length === 0) {
+      throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
+    }
+    let result;
+    where = and(joinOn, where);
+    if (nestedQueryRelation) {
+      let field = sql3`json_build_array(${sql3.join(
+        selection.map(
+          ({ field: field2, tsKey, isJson }) => isJson ? sql3`${sql3.identifier(`${tableAlias}_${tsKey}`)}.${sql3.identifier("data")}` : is(field2, SQL.Aliased) ? field2.sql : field2
+        ),
+        sql3`, `
+      )})`;
+      if (is(nestedQueryRelation, Many)) {
+        field = sql3`coalesce(json_agg(${field}${orderBy.length > 0 ? sql3` order by ${sql3.join(orderBy, sql3`, `)}` : void 0}), '[]'::json)`;
+      }
+      const nestedSelection = [{
+        dbKey: "data",
+        tsKey: "data",
+        field: field.as("data"),
+        isJson: true,
+        relationTableTsKey: tableConfig.tsName,
+        selection
+      }];
+      const needsSubquery = limit !== void 0 || offset !== void 0 || orderBy.length > 0;
+      if (needsSubquery) {
+        result = this.buildSelectQuery({
+          table: aliasedTable(table, tableAlias),
+          fields: {},
+          fieldsFlat: [{ path: [], field: sql3.raw("*") }],
+          where,
+          limit,
+          offset,
+          orderBy,
+          setOperators: []
+        });
+        where = void 0;
+        limit = void 0;
+        offset = void 0;
+        orderBy = [];
+      } else {
+        result = aliasedTable(table, tableAlias);
+      }
+      result = this.buildSelectQuery({
+        table: is(result, DatabendTable) ? result : new Subquery(result, {}, tableAlias),
+        fields: {},
+        fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
+          path: [],
+          field: is(field2, Column2) ? aliasedTableColumn(field2, tableAlias) : field2
+        })),
+        joins,
+        where,
+        limit,
+        offset,
+        orderBy,
+        setOperators: []
+      });
+    } else {
+      result = this.buildSelectQuery({
+        table: aliasedTable(table, tableAlias),
+        fields: {},
+        fieldsFlat: selection.map(({ field }) => ({
+          path: [],
+          field: is(field, Column2) ? aliasedTableColumn(field, tableAlias) : field
+        })),
+        joins,
+        where,
+        limit,
+        offset,
+        orderBy,
+        setOperators: []
+      });
+    }
+    return {
+      tableTsKey: tableConfig.tsName,
+      sql: result,
+      selection
+    };
+  }
+};
+
+// src/databend-core/indexes.ts
+import { entityKind as entityKind21, is as is2 } from "drizzle-orm/entity";
+import { SQL as SQL2 } from "drizzle-orm/sql/sql";
+var IndexBuilderOn = class {
+  constructor(unique, name) {
+    this.unique = unique;
+    this.name = name;
+  }
+  static [entityKind21] = "DatabendIndexBuilderOn";
+  on(...columns) {
+    return new IndexBuilder(
+      columns.map((it) => {
+        if (is2(it, SQL2)) {
+          return it;
+        }
+        const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+        it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+        return clonedIndexedColumn;
+      }),
+      this.unique,
+      this.name
+    );
+  }
+};
+var IndexBuilder = class {
+  static [entityKind21] = "DatabendIndexBuilder";
+  /** @internal */
+  config;
+  constructor(columns, unique, name) {
+    this.config = {
+      name,
+      columns,
+      unique
+    };
+  }
+  where(condition) {
+    this.config.where = condition;
+    return this;
+  }
+  /** @internal */
+  build(table) {
+    return new Index(this.config, table);
+  }
+};
+var Index = class {
+  static [entityKind21] = "DatabendIndex";
+  config;
+  constructor(config, table) {
+    this.config = { ...config, table };
+  }
+};
+function index(name) {
+  return new IndexBuilderOn(false, name);
+}
+function uniqueIndex(name) {
+  return new IndexBuilderOn(true, name);
+}
+
+// src/databend-core/primary-keys.ts
+import { entityKind as entityKind22 } from "drizzle-orm/entity";
+function primaryKey(...config) {
+  if (config[0].columns) {
+    return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+  }
+  return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+  static [entityKind22] = "DatabendPrimaryKeyBuilder";
+  /** @internal */
+  columns;
+  /** @internal */
+  name;
+  constructor(columns, name) {
+    this.columns = columns;
+    this.name = name;
+  }
+  /** @internal */
+  build(table) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+};
+var PrimaryKey = class {
+  constructor(table, columns, name) {
+    this.table = table;
+    this.columns = columns;
+    this.name = name;
+  }
+  static [entityKind22] = "DatabendPrimaryKey";
+  columns;
+  name;
+  getName() {
+    return this.name ?? `${this.table[DatabendTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+  }
+};
+
+// src/databend-core/schema.ts
+import { entityKind as entityKind23, is as is3 } from "drizzle-orm/entity";
+import { SQL as SQL3, sql as sql4 } from "drizzle-orm/sql/sql";
+var DatabendSchema = class {
+  constructor(schemaName) {
+    this.schemaName = schemaName;
+  }
+  static [entityKind23] = "DatabendSchema";
+  table = (name, columns, extraConfig) => {
+    return databendTableWithSchema(name, columns, extraConfig, this.schemaName);
+  };
+  getSQL() {
+    return new SQL3([sql4.identifier(this.schemaName)]);
+  }
+  shouldOmitSQLParens() {
+    return true;
+  }
+};
+function databendSchema(name) {
+  return new DatabendSchema(name);
+}
+
+// src/databend-core/utils.ts
+import { is as is4 } from "drizzle-orm/entity";
+import { Table as Table3 } from "drizzle-orm/table";
+function getTableConfig(table) {
+  const columns = Object.values(table[Table3.Symbol.Columns]);
+  const indexes = [];
+  const primaryKeys = [];
+  const name = table[Table3.Symbol.Name];
+  const schema = table[Table3.Symbol.Schema];
+  const extraConfigBuilder = table[DatabendTable.Symbol.ExtraConfigBuilder];
+  if (extraConfigBuilder !== void 0) {
+    const extraConfig = extraConfigBuilder(table[Table3.Symbol.ExtraConfigColumns]);
+    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
+    for (const builder of extraValues) {
+      if (is4(builder, IndexBuilder)) {
+        indexes.push(builder.build(table));
+      } else if (is4(builder, PrimaryKeyBuilder)) {
+        primaryKeys.push(builder.build(table));
+      }
+    }
+  }
+  return {
+    columns,
+    indexes,
+    primaryKeys,
+    name,
+    schema
+  };
+}
+
+// src/databend-core/view.ts
+import { entityKind as entityKind26, is as is7 } from "drizzle-orm/entity";
+import { SelectionProxyHandler as SelectionProxyHandler3 } from "drizzle-orm/selection-proxy";
+import { getTableColumns as getTableColumns2 } from "drizzle-orm/utils";
+
+// src/databend-core/query-builders/query-builder.ts
+import { entityKind as entityKind25, is as is6 } from "drizzle-orm/entity";
+import { SelectionProxyHandler as SelectionProxyHandler2 } from "drizzle-orm/selection-proxy";
+import { WithSubquery } from "drizzle-orm/subquery";
+
+// src/databend-core/query-builders/select.ts
+import { entityKind as entityKind24, is as is5 } from "drizzle-orm/entity";
+import { TypedQueryBuilder } from "drizzle-orm/query-builders/query-builder";
+import { QueryPromise } from "drizzle-orm/query-promise";
+import { SelectionProxyHandler } from "drizzle-orm/selection-proxy";
+import { SQL as SQL4, View as View3 } from "drizzle-orm/sql/sql";
+import { Subquery as Subquery2 } from "drizzle-orm/subquery";
+import { Table as Table4 } from "drizzle-orm/table";
+import { tracer } from "drizzle-orm/tracing";
+import {
+  applyMixins,
+  getTableColumns,
+  getTableLikeName,
+  haveSameKeys,
+  orderSelectedFields as orderSelectedFields2
+} from "drizzle-orm/utils";
+import { ViewBaseConfig as ViewBaseConfig2 } from "drizzle-orm/view-common";
+var DatabendSelectBuilder = class {
+  static [entityKind24] = "DatabendSelectBuilder";
+  fields;
+  session;
+  dialect;
+  withList = [];
+  distinct;
+  constructor(config) {
+    this.fields = config.fields;
+    this.session = config.session;
+    this.dialect = config.dialect;
+    if (config.withList) {
+      this.withList = config.withList;
+    }
+    this.distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this.fields;
+    let fields;
+    if (this.fields) {
+      fields = this.fields;
+    } else if (is5(source, Subquery2)) {
+      fields = Object.fromEntries(
+        Object.keys(source._.selectedFields).map((key) => [key, source[key]])
+      );
+    } else if (is5(source, DatabendViewBase)) {
+      fields = source[ViewBaseConfig2].selectedFields;
+    } else if (is5(source, SQL4)) {
+      fields = {};
+    } else {
+      fields = getTableColumns(source);
+    }
+    return new DatabendSelectBase({
+      table: source,
+      fields,
+      isPartialSelect,
+      session: this.session,
+      dialect: this.dialect,
+      withList: this.withList,
+      distinct: this.distinct
+    });
+  }
+};
+var DatabendSelectQueryBuilderBase = class extends TypedQueryBuilder {
+  static [entityKind24] = "DatabendSelectQueryBuilder";
+  _;
+  config;
+  joinsNotNullableMap;
+  tableName;
+  isPartialSelect;
+  session;
+  dialect;
+  constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }) {
+    super();
+    this.config = {
+      withList,
+      table,
+      fields: { ...fields },
+      distinct,
+      setOperators: []
+    };
+    this.isPartialSelect = isPartialSelect;
+    this.session = session;
+    this.dialect = dialect;
+    this._ = {
+      selectedFields: fields
+    };
+    this.tableName = getTableLikeName(table);
+    this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
+  }
+  createJoin(joinType) {
+    return (table, on) => {
+      const baseTableName = this.tableName;
+      const tableName = getTableLikeName(table);
+      if (typeof tableName === "string" && this.config.joins?.some((join) => join.alias === tableName)) {
+        throw new Error(`Alias "${tableName}" is already used in this query`);
+      }
+      if (!this.isPartialSelect) {
+        if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
+          this.config.fields = {
+            [baseTableName]: this.config.fields
+          };
+        }
+        if (typeof tableName === "string" && !is5(table, SQL4)) {
+          const selection = is5(table, Subquery2) ? table._.selectedFields : is5(table, View3) ? table[ViewBaseConfig2].selectedFields : table[Table4.Symbol.Columns];
+          this.config.fields[tableName] = selection;
+        }
+      }
+      if (typeof on === "function") {
+        on = on(
+          new Proxy(
+            this.config.fields,
+            new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+          )
+        );
+      }
+      if (!this.config.joins) {
+        this.config.joins = [];
+      }
+      this.config.joins.push({ on, table, joinType, alias: tableName });
+      if (typeof tableName === "string") {
+        switch (joinType) {
+          case "left":
+            this.joinsNotNullableMap[tableName] = false;
+            break;
+          case "right":
+            this.joinsNotNullableMap = Object.fromEntries(
+              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
+            );
+            this.joinsNotNullableMap[tableName] = true;
+            break;
+          case "inner":
+            this.joinsNotNullableMap[tableName] = true;
+            break;
+          case "full":
+            this.joinsNotNullableMap = Object.fromEntries(
+              Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
+            );
+            this.joinsNotNullableMap[tableName] = false;
+            break;
+        }
+      }
+      return this;
+    };
+  }
+  leftJoin = this.createJoin("left");
+  rightJoin = this.createJoin("right");
+  innerJoin = this.createJoin("inner");
+  fullJoin = this.createJoin("full");
+  createSetOperator(type, isAll) {
+    return (rightSelection) => {
+      const rightSelect = typeof rightSelection === "function" ? rightSelection(getDatabendSetOperators()) : rightSelection;
+      if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
+        throw new Error(
+          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
+        );
+      }
+      this.config.setOperators.push({ type, isAll, rightSelect });
+      return this;
+    };
+  }
+  union = this.createSetOperator("union", false);
+  unionAll = this.createSetOperator("union", true);
+  intersect = this.createSetOperator("intersect", false);
+  intersectAll = this.createSetOperator("intersect", true);
+  except = this.createSetOperator("except", false);
+  exceptAll = this.createSetOperator("except", true);
+  /** @internal */
+  addSetOperators(setOperators) {
+    this.config.setOperators.push(...setOperators);
+    return this;
+  }
+  where(where) {
+    if (typeof where === "function") {
+      where = where(
+        new Proxy(
+          this.config.fields,
+          new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+        )
+      );
+    }
+    this.config.where = where;
+    return this;
+  }
+  having(having) {
+    if (typeof having === "function") {
+      having = having(
+        new Proxy(
+          this.config.fields,
+          new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+        )
+      );
+    }
+    this.config.having = having;
+    return this;
+  }
+  groupBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const groupBy = columns[0](
+        new Proxy(
+          this.config.fields,
+          new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
+        )
+      );
+      this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
+    } else {
+      this.config.groupBy = columns;
+    }
+    return this;
+  }
+  orderBy(...columns) {
+    if (typeof columns[0] === "function") {
+      const orderBy = columns[0](
+        new Proxy(
+          this.config.fields,
+          new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
+        )
+      );
+      const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+      if (this.config.setOperators.length > 0) {
+        this.config.setOperators.at(-1).orderBy = orderByArray;
+      } else {
+        this.config.orderBy = orderByArray;
+      }
+    } else {
+      const orderByArray = columns;
+      if (this.config.setOperators.length > 0) {
+        this.config.setOperators.at(-1).orderBy = orderByArray;
+      } else {
+        this.config.orderBy = orderByArray;
+      }
+    }
+    return this;
+  }
+  limit(limit) {
+    if (this.config.setOperators.length > 0) {
+      this.config.setOperators.at(-1).limit = limit;
+    } else {
+      this.config.limit = limit;
+    }
+    return this;
+  }
+  offset(offset) {
+    if (this.config.setOperators.length > 0) {
+      this.config.setOperators.at(-1).offset = offset;
+    } else {
+      this.config.offset = offset;
+    }
+    return this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildSelectQuery(this.config);
+  }
+  toSQL() {
+    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+    return rest;
+  }
+  as(alias2) {
+    return new Proxy(
+      new Subquery2(this.getSQL(), this.config.fields, alias2),
+      new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+    );
+  }
+  /** @internal */
+  getSelectedFields() {
+    return new Proxy(
+      this.config.fields,
+      new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+    );
+  }
+  $dynamic() {
+    return this;
+  }
+};
+var DatabendSelectBase = class extends DatabendSelectQueryBuilderBase {
+  static [entityKind24] = "DatabendSelect";
+  /** @internal */
+  _prepare(name) {
+    const { session, config, dialect, joinsNotNullableMap } = this;
+    if (!session) {
+      throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
+    }
+    return tracer.startActiveSpan("drizzle.prepareQuery", () => {
+      const fieldsList = orderSelectedFields2(config.fields);
+      const query = session.prepareQuery(dialect.sqlToQuery(this.getSQL()), fieldsList, name, true);
+      query.joinsNotNullableMap = joinsNotNullableMap;
+      return query;
+    });
+  }
+  prepare(name) {
+    return this._prepare(name);
+  }
+  execute = (placeholderValues) => {
+    return tracer.startActiveSpan("drizzle.operation", () => {
+      return this._prepare().execute(placeholderValues);
+    });
+  };
+};
+applyMixins(DatabendSelectBase, [QueryPromise]);
+function createSetOperator(type, isAll) {
+  return (leftSelect, rightSelect, ...restSelects) => {
+    const setOperators = [rightSelect, ...restSelects].map((select) => ({
+      type,
+      isAll,
+      rightSelect: select
+    }));
+    for (const setOperator of setOperators) {
+      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
+        throw new Error(
+          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
+        );
+      }
+    }
+    return leftSelect.addSetOperators(setOperators);
+  };
+}
+var getDatabendSetOperators = () => ({
+  union,
+  unionAll,
+  intersect,
+  intersectAll,
+  except,
+  exceptAll
+});
+var union = createSetOperator("union", false);
+var unionAll = createSetOperator("union", true);
+var intersect = createSetOperator("intersect", false);
+var intersectAll = createSetOperator("intersect", true);
+var except = createSetOperator("except", false);
+var exceptAll = createSetOperator("except", true);
+
+// src/databend-core/query-builders/query-builder.ts
+var QueryBuilder = class {
+  static [entityKind25] = "DatabendQueryBuilder";
+  dialect;
+  dialectConfig;
+  constructor(dialect) {
+    this.dialect = is6(dialect, DatabendDialect) ? dialect : void 0;
+    this.dialectConfig = is6(dialect, DatabendDialect) ? void 0 : dialect;
+  }
+  $with(alias2) {
+    const queryBuilder = this;
+    return {
+      as(qb) {
+        if (typeof qb === "function") {
+          qb = qb(queryBuilder);
+        }
+        return new Proxy(
+          new WithSubquery(qb.getSQL(), qb.getSelectedFields(), alias2, true),
+          new SelectionProxyHandler2({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+        );
+      }
+    };
+  }
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? void 0,
+        session: void 0,
+        dialect: self.getDialect(),
+        withList: queries
+      });
+    }
+    function selectDistinct(fields) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? void 0,
+        session: void 0,
+        dialect: self.getDialect(),
+        distinct: true
+      });
+    }
+    return { select, selectDistinct };
+  }
+  select(fields) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? void 0,
+      session: void 0,
+      dialect: this.getDialect()
+    });
+  }
+  selectDistinct(fields) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? void 0,
+      session: void 0,
+      dialect: this.getDialect(),
+      distinct: true
+    });
+  }
+  getDialect() {
+    if (!this.dialect) {
+      this.dialect = new DatabendDialect(this.dialectConfig);
+    }
+    return this.dialect;
+  }
+};
+
+// src/databend-core/view-common.ts
+var DatabendViewConfig = Symbol.for("drizzle:DatabendViewConfig");
+
+// src/databend-core/view.ts
+var DefaultViewBuilderCore = class {
+  constructor(name, schema) {
+    this.name = name;
+    this.schema = schema;
+  }
+  static [entityKind26] = "DatabendDefaultViewBuilderCore";
+  config = {};
+  with(config) {
+    this.config.with = config;
+    return this;
+  }
+};
+var ViewBuilder = class extends DefaultViewBuilderCore {
+  static [entityKind26] = "DatabendViewBuilder";
+  as(qb) {
+    if (typeof qb === "function") {
+      qb = qb(new QueryBuilder());
+    }
+    const selectionProxy = new SelectionProxyHandler3({
+      alias: this.name,
+      sqlBehavior: "error",
+      sqlAliasedBehavior: "alias",
+      replaceOriginalName: true
+    });
+    const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+    return new Proxy(
+      new DatabendView({
+        databendConfig: this.config,
+        config: {
+          name: this.name,
+          schema: this.schema,
+          selectedFields: aliasedSelection,
+          query: qb.getSQL().inlineParams()
+        }
+      }),
+      selectionProxy
+    );
+  }
+};
+var ManualViewBuilder = class extends DefaultViewBuilderCore {
+  static [entityKind26] = "DatabendManualViewBuilder";
+  columns;
+  constructor(name, columns, schema) {
+    super(name, schema);
+    this.columns = getTableColumns2(databendTable(name, columns));
+  }
+  existing() {
+    return new Proxy(
+      new DatabendView({
+        databendConfig: void 0,
+        config: {
+          name: this.name,
+          schema: this.schema,
+          selectedFields: this.columns,
+          query: void 0
+        }
+      }),
+      new SelectionProxyHandler3({
+        alias: this.name,
+        sqlBehavior: "error",
+        sqlAliasedBehavior: "alias",
+        replaceOriginalName: true
+      })
+    );
+  }
+  as(query) {
+    return new Proxy(
+      new DatabendView({
+        databendConfig: this.config,
+        config: {
+          name: this.name,
+          schema: this.schema,
+          selectedFields: this.columns,
+          query: query.inlineParams()
+        }
+      }),
+      new SelectionProxyHandler3({
+        alias: this.name,
+        sqlBehavior: "error",
+        sqlAliasedBehavior: "alias",
+        replaceOriginalName: true
+      })
+    );
+  }
+};
+var DatabendView = class extends DatabendViewBase {
+  static [entityKind26] = "DatabendView";
+  [DatabendViewConfig];
+  constructor({ databendConfig, config }) {
+    super(config);
+    if (databendConfig) {
+      this[DatabendViewConfig] = {
+        with: databendConfig.with
+      };
     }
-    return value.slice(0, 10);
   }
-})(name);
+};
+function databendViewWithSchema(name, selection, schema) {
+  if (selection) {
+    return new ManualViewBuilder(name, selection, schema);
+  }
+  return new ViewBuilder(name, schema);
+}
+function databendView(name, columns) {
+  return databendViewWithSchema(name, columns, void 0);
+}
 
 // src/driver.ts
 import { Client } from "databend-driver";
-import { entityKind as entityKind3 } from "drizzle-orm/entity";
+import { entityKind as entityKind36 } from "drizzle-orm/entity";
 import { DefaultLogger } from "drizzle-orm/logger";
-import { PgDatabase } from "drizzle-orm/pg-core/db";
 import {
   createTableRelationsHelpers,
   extractTablesRelationalConfig
 } from "drizzle-orm/relations";
 
-// src/dialect.ts
-import {
-  sql
-} from "drizzle-orm";
-import { entityKind, is } from "drizzle-orm/entity";
-import {
-  PgBigInt53,
-  PgBigInt64,
-  PgDate,
-  PgDateString,
-  PgDialect,
-  PgDoublePrecision,
-  PgInteger,
-  PgNumeric,
-  PgReal,
-  PgSmallInt,
-  PgTime,
-  PgTimestamp,
-  PgTimestampString,
-  PgUUID
-} from "drizzle-orm/pg-core";
-var DatabendDialect = class extends PgDialect {
-  static [entityKind] = "DatabendPgDialect";
-  // Databend does not support savepoints
-  areSavepointsUnsupported() {
-    return true;
+// src/databend-core/db.ts
+import { entityKind as entityKind33 } from "drizzle-orm/entity";
+import { SelectionProxyHandler as SelectionProxyHandler4 } from "drizzle-orm/selection-proxy";
+import { sql as sql6 } from "drizzle-orm/sql/sql";
+import { WithSubquery as WithSubquery2 } from "drizzle-orm/subquery";
+
+// src/databend-core/query-builders/count.ts
+import { entityKind as entityKind27 } from "drizzle-orm/entity";
+import { SQL as SQL5, sql as sql5 } from "drizzle-orm/sql/sql";
+var DatabendCountBuilder = class _DatabendCountBuilder extends SQL5 {
+  static [entityKind27] = "DatabendCountBuilder";
+  [Symbol.toStringTag] = "DatabendCountBuilder";
+  sql;
+  session;
+  constructor(params) {
+    super(_DatabendCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
+    this.mapWith(Number);
+    this.session = params.session;
+    this.sql = _DatabendCountBuilder.buildCount(params.source, params.filters);
   }
-  async migrate(migrations, session, config) {
-    const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
-    const migrationsSchema = migrationConfig.migrationsSchema ?? "default";
-    const migrationsTable = migrationConfig.migrationsTable ?? "__drizzle_migrations";
-    const migrationTableCreate = sql`
-      CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(
-      migrationsTable
-    )} (
-        id INT NOT NULL,
-        hash VARCHAR NOT NULL,
-        created_at BIGINT
-      )
-    `;
-    await session.execute(migrationTableCreate);
-    const dbMigrations = await session.all(
-      sql`SELECT id, hash, created_at FROM ${sql.identifier(
-        migrationsSchema
-      )}.${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
+  static buildEmbeddedCount(source, filters) {
+    return sql5`(select count(*) from ${source}${sql5.raw(" where ").if(filters)}${filters})`;
+  }
+  static buildCount(source, filters) {
+    return sql5`select count(*) as count from ${source}${sql5.raw(" where ").if(filters)}${filters};`;
+  }
+  // biome-ignore lint/suspicious/noThenProperty: Promise-like interface required for await support
+  then(onfulfilled, onrejected) {
+    return Promise.resolve(this.session.count(this.sql)).then(onfulfilled, onrejected);
+  }
+  catch(onRejected) {
+    return this.then(void 0, onRejected);
+  }
+  finally(onFinally) {
+    return this.then(
+      (value) => {
+        onFinally?.();
+        return value;
+      },
+      (reason) => {
+        onFinally?.();
+        throw reason;
+      }
     );
-    const lastDbMigration = dbMigrations[0];
-    await session.transaction(async (tx) => {
-      for await (const migration of migrations) {
-        if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
-          for (const stmt of migration.sql) {
-            await tx.execute(sql.raw(stmt));
-          }
-          await tx.execute(
-            sql`INSERT INTO ${sql.identifier(
-              migrationsSchema
-            )}.${sql.identifier(migrationsTable)} (id, hash, created_at)
-              VALUES (
-                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql.identifier(
-              migrationsSchema
-            )}.${sql.identifier(migrationsTable)}),
-                ${migration.hash},
-                ${migration.folderMillis}
-              )`
+  }
+};
+
+// src/databend-core/query-builders/delete.ts
+import { entityKind as entityKind28 } from "drizzle-orm/entity";
+import { QueryPromise as QueryPromise2 } from "drizzle-orm/query-promise";
+import { tracer as tracer2 } from "drizzle-orm/tracing";
+var DatabendDeleteBase = class extends QueryPromise2 {
+  constructor(table, session, dialect, withList) {
+    super();
+    this.session = session;
+    this.dialect = dialect;
+    this.config = { table, withList };
+  }
+  static [entityKind28] = "DatabendDelete";
+  config;
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildDeleteQuery(this.config);
+  }
+  toSQL() {
+    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+    return rest;
+  }
+  /** @internal */
+  _prepare(name) {
+    return tracer2.startActiveSpan("drizzle.prepareQuery", () => {
+      return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, name, true);
+    });
+  }
+  prepare(name) {
+    return this._prepare(name);
+  }
+  execute = (placeholderValues) => {
+    return tracer2.startActiveSpan("drizzle.operation", () => {
+      return this._prepare().execute(placeholderValues);
+    });
+  };
+  $dynamic() {
+    return this;
+  }
+};
+
+// src/databend-core/query-builders/insert.ts
+import { entityKind as entityKind29, is as is8 } from "drizzle-orm/entity";
+import { QueryPromise as QueryPromise3 } from "drizzle-orm/query-promise";
+import { Param as Param2, SQL as SQL6 } from "drizzle-orm/sql/sql";
+import { Table as Table5 } from "drizzle-orm/table";
+import { tracer as tracer3 } from "drizzle-orm/tracing";
+import { haveSameKeys as haveSameKeys2 } from "drizzle-orm/utils";
+var DatabendInsertBuilder = class {
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  static [entityKind29] = "DatabendInsertBuilder";
+  values(values) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error("values() must be called with at least one value");
+    }
+    const mappedValues = values.map((entry) => {
+      const result = {};
+      const cols = this.table[Table5.Symbol.Columns];
+      for (const colKey of Object.keys(entry)) {
+        const colValue = entry[colKey];
+        result[colKey] = is8(colValue, SQL6) ? colValue : new Param2(colValue, cols[colKey]);
+      }
+      return result;
+    });
+    return new DatabendInsertBase(
+      this.table,
+      mappedValues,
+      this.session,
+      this.dialect,
+      this.withList,
+      false
+    );
+  }
+  select(selectQuery) {
+    const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
+    if (!is8(select, SQL6) && !haveSameKeys2(this.table[Table5.Symbol.Columns], select._.selectedFields)) {
+      throw new Error(
+        "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
+      );
+    }
+    return new DatabendInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+};
+var DatabendInsertBase = class extends QueryPromise3 {
+  constructor(table, values, session, dialect, withList, select) {
+    super();
+    this.session = session;
+    this.dialect = dialect;
+    this.config = { table, values, withList, select };
+  }
+  static [entityKind29] = "DatabendInsert";
+  config;
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildInsertQuery(this.config);
+  }
+  toSQL() {
+    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+    return rest;
+  }
+  /** @internal */
+  _prepare(name) {
+    return tracer3.startActiveSpan("drizzle.prepareQuery", () => {
+      return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, name, true);
+    });
+  }
+  prepare(name) {
+    return this._prepare(name);
+  }
+  execute = (placeholderValues) => {
+    return tracer3.startActiveSpan("drizzle.operation", () => {
+      return this._prepare().execute(placeholderValues);
+    });
+  };
+  $dynamic() {
+    return this;
+  }
+};
+
+// src/databend-core/query-builders/update.ts
+import { entityKind as entityKind30 } from "drizzle-orm/entity";
+import { QueryPromise as QueryPromise4 } from "drizzle-orm/query-promise";
+import "drizzle-orm/sql/sql";
+import "drizzle-orm/table";
+import { tracer as tracer4 } from "drizzle-orm/tracing";
+import { mapUpdateSet } from "drizzle-orm/utils";
+var DatabendUpdateBuilder = class {
+  constructor(table, session, dialect, withList) {
+    this.table = table;
+    this.session = session;
+    this.dialect = dialect;
+    this.withList = withList;
+  }
+  static [entityKind30] = "DatabendUpdateBuilder";
+  set(values) {
+    return new DatabendUpdateBase(
+      this.table,
+      mapUpdateSet(this.table, values),
+      this.session,
+      this.dialect,
+      this.withList
+    );
+  }
+};
+var DatabendUpdateBase = class extends QueryPromise4 {
+  constructor(table, set, session, dialect, withList) {
+    super();
+    this.session = session;
+    this.dialect = dialect;
+    this.config = { set, table, withList };
+  }
+  static [entityKind30] = "DatabendUpdate";
+  config;
+  where(where) {
+    this.config.where = where;
+    return this;
+  }
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildUpdateQuery(this.config);
+  }
+  toSQL() {
+    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+    return rest;
+  }
+  /** @internal */
+  _prepare(name) {
+    return tracer4.startActiveSpan("drizzle.prepareQuery", () => {
+      return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, name, true);
+    });
+  }
+  prepare(name) {
+    return this._prepare(name);
+  }
+  execute = (placeholderValues) => {
+    return tracer4.startActiveSpan("drizzle.operation", () => {
+      return this._prepare().execute(placeholderValues);
+    });
+  };
+  $dynamic() {
+    return this;
+  }
+};
+
+// src/databend-core/query-builders/query.ts
+import { entityKind as entityKind31 } from "drizzle-orm/entity";
+import { QueryPromise as QueryPromise5 } from "drizzle-orm/query-promise";
+import { mapRelationalRow } from "drizzle-orm/relations";
+import { tracer as tracer5 } from "drizzle-orm/tracing";
+var RelationalQueryBuilder = class {
+  constructor(fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session) {
+    this.fullSchema = fullSchema;
+    this.schema = schema;
+    this.tableNamesMap = tableNamesMap;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+  }
+  static [entityKind31] = "DatabendRelationalQueryBuilder";
+  findMany(config) {
+    return new DatabendRelationalQuery(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      config ? config : {},
+      "many"
+    );
+  }
+  findFirst(config) {
+    return new DatabendRelationalQuery(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      config ? { ...config, limit: 1 } : { limit: 1 },
+      "first"
+    );
+  }
+};
+var DatabendRelationalQuery = class extends QueryPromise5 {
+  constructor(fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session, config, mode) {
+    super();
+    this.fullSchema = fullSchema;
+    this.schema = schema;
+    this.tableNamesMap = tableNamesMap;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config;
+    this.mode = mode;
+  }
+  static [entityKind31] = "DatabendRelationalQuery";
+  /** @internal */
+  _prepare(name) {
+    return tracer5.startActiveSpan("drizzle.prepareQuery", () => {
+      const { query, builtQuery } = this._toSQL();
+      return this.session.prepareQuery(
+        builtQuery,
+        void 0,
+        name,
+        true,
+        (rawRows, mapColumnValue) => {
+          const rows = rawRows.map(
+            (row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
           );
+          if (this.mode === "first") {
+            return rows[0];
+          }
+          return rows;
         }
-      }
+      );
     });
   }
-  prepareTyping(encoder) {
-    if (is(encoder, PgNumeric) || is(encoder, PgInteger) || is(encoder, PgSmallInt) || is(encoder, PgReal) || is(encoder, PgDoublePrecision) || is(encoder, PgBigInt53) || is(encoder, PgBigInt64)) {
-      return "decimal";
-    } else if (is(encoder, PgTime)) {
-      return "time";
-    } else if (is(encoder, PgTimestamp) || is(encoder, PgTimestampString)) {
-      return "timestamp";
-    } else if (is(encoder, PgDate) || is(encoder, PgDateString)) {
-      return "date";
-    } else if (is(encoder, PgUUID)) {
-      return "uuid";
-    } else {
-      return "none";
+  prepare(name) {
+    return this._prepare(name);
+  }
+  _getQuery() {
+    return this.dialect.buildRelationalQueryWithoutPK({
+      fullSchema: this.fullSchema,
+      schema: this.schema,
+      tableNamesMap: this.tableNamesMap,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      tableAlias: this.tableConfig.tsName
+    });
+  }
+  /** @internal */
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    const builtQuery = this.dialect.sqlToQuery(query.sql);
+    return { query, builtQuery };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+  execute() {
+    return tracer5.startActiveSpan("drizzle.operation", () => {
+      return this._prepare().execute(void 0);
+    });
+  }
+};
+
+// src/databend-core/query-builders/raw.ts
+import { entityKind as entityKind32 } from "drizzle-orm/entity";
+import { QueryPromise as QueryPromise6 } from "drizzle-orm/query-promise";
+var DatabendRaw = class extends QueryPromise6 {
+  constructor(execute, sql8, query, mapBatchResult) {
+    super();
+    this.execute = execute;
+    this.sql = sql8;
+    this.query = query;
+    this.mapBatchResult = mapBatchResult;
+  }
+  static [entityKind32] = "DatabendRaw";
+  /** @internal */
+  getSQL() {
+    return this.sql;
+  }
+  getQuery() {
+    return this.query;
+  }
+  mapResult(result, isFromBatch) {
+    return isFromBatch ? this.mapBatchResult(result) : result;
+  }
+  _prepare() {
+    return this;
+  }
+  /** @internal */
+  isResponseInArrayMode() {
+    return false;
+  }
+};
+
+// src/databend-core/db.ts
+var DatabendDatabase = class {
+  constructor(dialect, session, schema) {
+    this.dialect = dialect;
+    this.session = session;
+    this._ = schema ? {
+      schema: schema.schema,
+      fullSchema: schema.fullSchema,
+      tableNamesMap: schema.tableNamesMap,
+      session
+    } : {
+      schema: void 0,
+      fullSchema: {},
+      tableNamesMap: {},
+      session
+    };
+    this.query = {};
+    if (this._.schema) {
+      for (const [tableName, columns] of Object.entries(this._.schema)) {
+        this.query[tableName] = new RelationalQueryBuilder(
+          schema.fullSchema,
+          this._.schema,
+          this._.tableNamesMap,
+          schema.fullSchema[tableName],
+          columns,
+          dialect,
+          session
+        );
+      }
+    }
+  }
+  static [entityKind33] = "DatabendDatabase";
+  _;
+  query;
+  $with(alias2) {
+    const self = this;
+    return {
+      as(qb) {
+        if (typeof qb === "function") {
+          qb = qb(new QueryBuilder(self.dialect));
+        }
+        const sqlObj = typeof qb.getSQL === "function" ? qb.getSQL() : qb;
+        const fields = typeof qb.getSelectedFields === "function" ? qb.getSelectedFields() : {};
+        return new Proxy(
+          new WithSubquery2(sqlObj, fields, alias2, true),
+          new SelectionProxyHandler4({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+        );
+      }
+    };
+  }
+  $count(source, filters) {
+    return new DatabendCountBuilder({ source, filters, session: this.session });
+  }
+  with(...queries) {
+    const self = this;
+    function select(fields) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? void 0,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries
+      });
     }
+    function selectDistinct(fields) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? void 0,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true
+      });
+    }
+    function update(table) {
+      return new DatabendUpdateBuilder(table, self.session, self.dialect, queries);
+    }
+    function insert(table) {
+      return new DatabendInsertBuilder(table, self.session, self.dialect, queries);
+    }
+    function delete_(table) {
+      return new DatabendDeleteBase(table, self.session, self.dialect, queries);
+    }
+    return { select, selectDistinct, update, insert, delete: delete_ };
+  }
+  select(fields) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? void 0,
+      session: this.session,
+      dialect: this.dialect
+    });
+  }
+  selectDistinct(fields) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? void 0,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true
+    });
+  }
+  update(table) {
+    return new DatabendUpdateBuilder(table, this.session, this.dialect);
+  }
+  insert(table) {
+    return new DatabendInsertBuilder(table, this.session, this.dialect);
+  }
+  delete(table) {
+    return new DatabendDeleteBase(table, this.session, this.dialect);
+  }
+  execute(query) {
+    const sequel = typeof query === "string" ? sql6.raw(query) : query.getSQL();
+    const builtQuery = this.dialect.sqlToQuery(sequel);
+    const prepared = this.session.prepareQuery(builtQuery, void 0, void 0, false);
+    return new DatabendRaw(
+      () => prepared.execute(void 0),
+      sequel,
+      builtQuery,
+      (result) => prepared.mapResult(result, true)
+    );
+  }
+  transaction(transaction) {
+    return this.session.transaction(transaction);
   }
 };
 
@@ -501,54 +2846,97 @@ function createDatabendConnectionPool(client, options = {}) {
 }
 
 // src/session.ts
-import { entityKind as entityKind2 } from "drizzle-orm/entity";
-import { TransactionRollbackError } from "drizzle-orm/errors";
+import { entityKind as entityKind35 } from "drizzle-orm/entity";
+import { TransactionRollbackError as TransactionRollbackError2 } from "drizzle-orm/errors";
 import { NoopLogger } from "drizzle-orm/logger";
-import { PgTransaction } from "drizzle-orm/pg-core";
-import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
-import { fillPlaceholders, sql as sql2 } from "drizzle-orm/sql/sql";
+import { fillPlaceholders, sql as sql7 } from "drizzle-orm/sql/sql";
+
+// src/databend-core/session.ts
+import { entityKind as entityKind34 } from "drizzle-orm/entity";
+import { TransactionRollbackError } from "drizzle-orm/errors";
+import { tracer as tracer6 } from "drizzle-orm/tracing";
+var DatabendPreparedQuery = class {
+  constructor(query) {
+    this.query = query;
+  }
+  static [entityKind34] = "DatabendPreparedQuery";
+  /** @internal */
+  joinsNotNullableMap;
+  getQuery() {
+    return this.query;
+  }
+  mapResult(response, _isFromBatch) {
+    return response;
+  }
+};
+var DatabendSession = class {
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  static [entityKind34] = "DatabendSession";
+  execute(query) {
+    return tracer6.startActiveSpan("drizzle.operation", () => {
+      const prepared = tracer6.startActiveSpan("drizzle.prepareQuery", () => {
+        return this.prepareQuery(
+          this.dialect.sqlToQuery(query),
+          void 0,
+          void 0,
+          false
+        );
+      });
+      return prepared.execute(void 0);
+    });
+  }
+  all(query) {
+    return this.prepareQuery(
+      this.dialect.sqlToQuery(query),
+      void 0,
+      void 0,
+      false
+    ).all();
+  }
+  async count(sql8) {
+    const res = await this.execute(sql8);
+    return Number(res[0]["count"]);
+  }
+  prepareQuery(_query, _fields, _name, _isResponseInArrayMode, _customResultMapper) {
+    throw new Error("prepareQuery not implemented");
+  }
+  transaction(_transaction, _config) {
+    throw new Error("transaction not implemented");
+  }
+};
+var DatabendTransaction = class extends DatabendDatabase {
+  constructor(dialect, session, schema, nestedIndex = 0) {
+    super(dialect, session, schema);
+    this.nestedIndex = nestedIndex;
+    this.schema = schema;
+  }
+  static [entityKind34] = "DatabendTransaction";
+  rollback() {
+    throw new TransactionRollbackError();
+  }
+};
 
 // src/sql/result-mapper.ts
 import {
-  Column,
-  getTableName,
-  is as is2,
-  SQL
+  Column as Column3,
+  getTableName as getTableName2,
+  is as is10,
+  SQL as SQL8
 } from "drizzle-orm";
-import {
-  PgCustomColumn,
-  PgDate as PgDate2,
-  PgDateString as PgDateString2,
-  PgTime as PgTime2,
-  PgTimestamp as PgTimestamp2,
-  PgTimestampString as PgTimestampString2
-} from "drizzle-orm/pg-core";
 function toDecoderInput(decoder, value) {
   void decoder;
   return value;
 }
-function normalizeTimestampString(value, withTimezone) {
-  if (value instanceof Date) {
-    const iso = value.toISOString().replace("T", " ");
-    return withTimezone ? iso.replace("Z", "+00") : iso.replace("Z", "");
-  }
-  if (typeof value === "string") {
-    const normalized = value.replace("T", " ");
-    if (withTimezone) {
-      return normalized.includes("+") ? normalized : `${normalized}+00`;
-    }
-    return normalized.replace(/\+00$/, "");
-  }
-  return value;
-}
-function normalizeTimestamp(value, withTimezone) {
+function normalizeTimestamp(value, _withTimezone) {
   if (value instanceof Date) {
     return value;
   }
   if (typeof value === "string") {
     const hasOffset = value.endsWith("Z") || /[+-]\d{2}:?\d{2}$/.test(value.trim());
     const spaced = value.replace(" ", "T");
-    const normalized = withTimezone || hasOffset ? spaced : `${spaced}+00`;
+    const normalized = hasOffset ? spaced : `${spaced}Z`;
     return new Date(normalized);
   }
   return value;
@@ -562,57 +2950,19 @@ function normalizeDateString(value) {
   }
   return value;
 }
-function normalizeDateValue(value) {
-  if (value instanceof Date) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return /* @__PURE__ */ new Date(`${value.slice(0, 10)}T00:00:00Z`);
-  }
-  return value;
-}
-function normalizeTime(value) {
-  if (typeof value === "bigint") {
-    const totalMillis = Number(value) / 1e3;
-    const date = new Date(totalMillis);
-    return date.toISOString().split("T")[1].replace("Z", "");
-  }
-  if (value instanceof Date) {
-    return value.toISOString().split("T")[1].replace("Z", "");
-  }
-  return value;
-}
 function mapDriverValue(decoder, rawValue) {
-  if (is2(decoder, PgTimestampString2)) {
-    return decoder.mapFromDriverValue(
-      toDecoderInput(
-        decoder,
-        normalizeTimestampString(rawValue, decoder.withTimezone)
-      )
-    );
-  }
-  if (is2(decoder, PgTimestamp2)) {
-    const normalized = normalizeTimestamp(rawValue, decoder.withTimezone);
+  if (is10(decoder, DatabendTimestamp)) {
+    const normalized = normalizeTimestamp(rawValue, false);
     if (normalized instanceof Date) {
       return normalized;
     }
     return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
   }
-  if (is2(decoder, PgDateString2)) {
+  if (is10(decoder, DatabendDate)) {
     return decoder.mapFromDriverValue(
       toDecoderInput(decoder, normalizeDateString(rawValue))
     );
   }
-  if (is2(decoder, PgDate2)) {
-    return decoder.mapFromDriverValue(
-      toDecoderInput(decoder, normalizeDateValue(rawValue))
-    );
-  }
-  if (is2(decoder, PgTime2)) {
-    return decoder.mapFromDriverValue(
-      toDecoderInput(decoder, normalizeTime(rawValue))
-    );
-  }
   return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
 }
 function mapResultRow(columns, row, joinsNotNullableMap) {
@@ -620,13 +2970,13 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
   const result = columns.reduce(
     (acc, { path, field }, columnIndex) => {
       let decoder;
-      if (is2(field, Column)) {
+      if (is10(field, Column3)) {
         decoder = field;
-      } else if (is2(field, SQL)) {
+      } else if (is10(field, SQL8)) {
         decoder = field.decoder;
       } else {
-        const col = field.sql.queryChunks.find((chunk) => is2(chunk, Column));
-        if (is2(col, PgCustomColumn)) {
+        const col = field.sql.queryChunks.find((chunk) => is10(chunk, Column3));
+        if (is10(col, DatabendCustomColumn)) {
           decoder = col;
         } else {
           decoder = field.sql.decoder;
@@ -643,18 +2993,18 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         }
         const rawValue = row[columnIndex];
         const value = node[pathChunk] = rawValue === null ? null : mapDriverValue(decoder, rawValue);
-        if (joinsNotNullableMap && is2(field, Column) && path.length === 2) {
+        if (joinsNotNullableMap && is10(field, Column3) && path.length === 2) {
           const objectName = path[0];
           if (!(objectName in nullifyMap)) {
-            nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
-          } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
+            nullifyMap[objectName] = value === null ? getTableName2(field.table) : false;
+          } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName2(field.table)) {
             nullifyMap[objectName] = false;
           }
           continue;
         }
-        if (joinsNotNullableMap && is2(field, SQL.Aliased) && path.length === 2) {
-          const col = field.sql.queryChunks.find((chunk) => is2(chunk, Column));
-          const tableName = col?.table && getTableName(col?.table);
+        if (joinsNotNullableMap && is10(field, SQL8.Aliased) && path.length === 2) {
+          const col = field.sql.queryChunks.find((chunk) => is10(chunk, Column3));
+          const tableName = col?.table && getTableName2(col?.table);
           if (!tableName) {
             continue;
           }
@@ -683,7 +3033,7 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
 }
 
 // src/session.ts
-var DatabendPreparedQuery = class extends PgPreparedQuery {
+var DatabendPreparedQuery2 = class extends DatabendPreparedQuery {
   constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, typings) {
     super({ sql: queryString, params });
     this.client = client;
@@ -695,7 +3045,7 @@ var DatabendPreparedQuery = class extends PgPreparedQuery {
     this.customResultMapper = customResultMapper;
     this.typings = typings;
   }
-  static [entityKind2] = "DatabendPreparedQuery";
+  static [entityKind35] = "DatabendPreparedQuery";
   async execute(placeholderValues = {}) {
     const params = fillPlaceholders(this.params, placeholderValues);
     this.logger.logQuery(this.queryString, params);
@@ -724,7 +3074,7 @@ var DatabendPreparedQuery = class extends PgPreparedQuery {
     return this._isResponseInArrayMode;
   }
 };
-var DatabendSession = class _DatabendSession extends PgSession {
+var DatabendSession2 = class _DatabendSession extends DatabendSession {
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
     this.client = client;
@@ -733,13 +3083,13 @@ var DatabendSession = class _DatabendSession extends PgSession {
     this.dialect = dialect;
     this.logger = options.logger ?? new NoopLogger();
   }
-  static [entityKind2] = "DatabendSession";
+  static [entityKind35] = "DatabendSession";
   dialect;
   logger;
   rollbackOnly = false;
   prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
     void name;
-    return new DatabendPreparedQuery(
+    return new DatabendPreparedQuery2(
       this.client,
       query.sql,
       query.params,
@@ -765,26 +3115,26 @@ var DatabendSession = class _DatabendSession extends PgSession {
       this.schema,
       this.options
     );
-    const tx = new DatabendTransaction(
+    const tx = new DatabendTransaction2(
       this.dialect,
       session,
       this.schema
     );
     try {
-      await tx.execute(sql2`BEGIN`);
+      await tx.execute(sql7`BEGIN`);
       if (config) {
         await tx.setTransaction(config);
       }
       try {
         const result = await transaction(tx);
         if (session.isRollbackOnly()) {
-          await tx.execute(sql2`ROLLBACK`);
-          throw new TransactionRollbackError();
+          await tx.execute(sql7`ROLLBACK`);
+          throw new TransactionRollbackError2();
         }
-        await tx.execute(sql2`COMMIT`);
+        await tx.execute(sql7`COMMIT`);
         return result;
       } catch (error) {
-        await tx.execute(sql2`ROLLBACK`);
+        await tx.execute(sql7`ROLLBACK`);
         throw error;
       }
     } finally {
@@ -810,10 +3160,10 @@ var VALID_TRANSACTION_ACCESS_MODES = /* @__PURE__ */ new Set([
   "read only",
   "read write"
 ]);
-var DatabendTransaction = class _DatabendTransaction extends PgTransaction {
-  static [entityKind2] = "DatabendTransaction";
+var DatabendTransaction2 = class _DatabendTransaction extends DatabendTransaction {
+  static [entityKind35] = "DatabendTransaction";
   rollback() {
-    throw new TransactionRollbackError();
+    throw new TransactionRollbackError2();
   }
   getTransactionConfigSQL(config) {
     if (config.isolationLevel && !VALID_TRANSACTION_ISOLATION_LEVELS.has(config.isolationLevel)) {
@@ -837,11 +3187,11 @@ var DatabendTransaction = class _DatabendTransaction extends PgTransaction {
     if (config.accessMode) {
       chunks.push(config.accessMode);
     }
-    return sql2.raw(chunks.join(" "));
+    return sql7.raw(chunks.join(" "));
   }
   setTransaction(config) {
     return this.session.execute(
-      sql2`SET TRANSACTION ${this.getTransactionConfigSQL(config)}`
+      sql7`SET TRANSACTION ${this.getTransactionConfigSQL(config)}`
     );
   }
   async transaction(transaction) {
@@ -866,9 +3216,9 @@ var DatabendDriver = class {
     this.dialect = dialect;
     this.options = options;
   }
-  static [entityKind3] = "DatabendDriver";
+  static [entityKind36] = "DatabendDriver";
   createSession(schema) {
-    return new DatabendSession(this.client, this.dialect, schema, {
+    return new DatabendSession2(this.client, this.dialect, schema, {
       logger: this.options.logger
     });
   }
@@ -895,7 +3245,7 @@ function createFromClient(client, config = {}, databendClient) {
   }
   const driver = new DatabendDriver(client, dialect, { logger });
   const session = driver.createSession(schema);
-  const db = new DatabendDatabase(
+  const db = new DatabendDatabase2(
     dialect,
     session,
     schema,
@@ -942,7 +3292,7 @@ function drizzle(clientOrConfigOrDsn, config) {
   }
   return createFromClient(clientOrConfigOrDsn, config);
 }
-var DatabendDatabase = class extends PgDatabase {
+var DatabendDatabase2 = class extends DatabendDatabase {
   constructor(dialect, session, schema, client, databendClient) {
     super(dialect, session, schema);
     this.dialect = dialect;
@@ -950,7 +3300,7 @@ var DatabendDatabase = class extends PgDatabase {
     this.$client = client;
     this.$databendClient = databendClient;
   }
-  static [entityKind3] = "DatabendDatabase";
+  static [entityKind36] = "DatabendDatabase";
   /** The underlying connection or pool */
   $client;
   /** The Databend Client instance (when created from DSN) */
@@ -980,24 +3330,53 @@ async function migrate(db, config) {
   );
 }
 export {
-  DatabendDatabase,
+  DatabendColumn,
+  DatabendColumnBuilder,
+  DatabendDatabase2 as DatabendDatabase,
+  DatabendDialect,
   DatabendDriver,
-  DatabendPreparedQuery,
-  DatabendSession,
-  DatabendTransaction,
+  DatabendPreparedQuery2 as DatabendPreparedQuery,
+  DatabendSession2 as DatabendSession,
+  DatabendTable,
+  DatabendTransaction2 as DatabendTransaction,
+  alias,
+  bigint,
+  binary,
+  bitmap,
+  boolean,
   closeClientConnection,
   createDatabendConnectionPool,
   databendArray,
   databendDate,
   databendMap,
+  databendSchema,
+  databendTable,
+  databendTableCreator,
   databendTimestamp,
   databendTuple,
   databendVariant,
+  databendView,
+  date,
+  decimal,
+  doublePrecision,
   drizzle,
   execOnClient,
   executeArraysOnClient,
   executeOnClient,
+  float,
+  getTableConfig,
+  index,
+  integer,
   isPool,
   migrate,
-  prepareParams
+  prepareParams,
+  primaryKey,
+  real,
+  smallint,
+  text,
+  timestamp,
+  tinyint,
+  uniqueIndex,
+  varchar,
+  variant
 };