drizzle-databend 0.1.10 → 0.1.12

package/dist/index.mjs

@@ -1,195 +1,12 @@
-// src/driver.ts
-import { Client } from "databend-driver";
-import { entityKind as entityKind3 } 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/session.ts
-import { entityKind } from "drizzle-orm/entity";
-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 } from "drizzle-orm/sql/sql";
-
-// src/sql/result-mapper.ts
-import {
-  Column,
-  SQL,
-  getTableName,
-  is
-} from "drizzle-orm";
-import {
-  PgCustomColumn,
-  PgDate,
-  PgDateString,
-  PgTime,
-  PgTimestamp,
-  PgTimestampString
-} from "drizzle-orm/pg-core";
-function toDecoderInput(decoder, value) {
-  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) {
-  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`;
-    return new Date(normalized);
-  }
-  return value;
-}
-function normalizeDateString(value) {
-  if (value instanceof Date) {
-    return value.toISOString().slice(0, 10);
-  }
-  if (typeof value === "string") {
-    return value.slice(0, 10);
-  }
-  return value;
-}
-function normalizeDateValue(value) {
-  if (value instanceof Date) {
-    return value;
-  }
-  if (typeof value === "string") {
-    return new Date(`${value.slice(0, 10)}T00:00:00Z`);
-  }
-  return value;
-}
-function normalizeTime(value) {
-  if (typeof value === "bigint") {
-    const totalMillis = Number(value) / 1000;
-    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 (is(decoder, PgTimestampString)) {
-    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeTimestampString(rawValue, decoder.withTimezone)));
-  }
-  if (is(decoder, PgTimestamp)) {
-    const normalized = normalizeTimestamp(rawValue, decoder.withTimezone);
-    if (normalized instanceof Date) {
-      return normalized;
-    }
-    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
-  }
-  if (is(decoder, PgDateString)) {
-    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeDateString(rawValue)));
-  }
-  if (is(decoder, PgDate)) {
-    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeDateValue(rawValue)));
-  }
-  if (is(decoder, PgTime)) {
-    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalizeTime(rawValue)));
-  }
-  return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
-}
-function mapResultRow(columns, row, joinsNotNullableMap) {
-  const nullifyMap = {};
-  const result = columns.reduce((acc, { path, field }, columnIndex) => {
-    let decoder;
-    if (is(field, Column)) {
-      decoder = field;
-    } else if (is(field, SQL)) {
-      decoder = field.decoder;
-    } else {
-      const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
-      if (is(col, PgCustomColumn)) {
-        decoder = col;
-      } else {
-        decoder = field.sql.decoder;
-      }
-    }
-    let node = acc;
-    for (const [pathChunkIndex, pathChunk] of path.entries()) {
-      if (pathChunkIndex < path.length - 1) {
-        if (!(pathChunk in node)) {
-          node[pathChunk] = {};
-        }
-        node = node[pathChunk];
-        continue;
-      }
-      const rawValue = row[columnIndex];
-      const value = node[pathChunk] = rawValue === null ? null : mapDriverValue(decoder, rawValue);
-      if (joinsNotNullableMap && is(field, Column) && 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] = false;
-        }
-        continue;
-      }
-      if (joinsNotNullableMap && is(field, SQL.Aliased) && path.length === 2) {
-        const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
-        const tableName = col?.table && getTableName(col?.table);
-        if (!tableName) {
-          continue;
-        }
-        const objectName = path[0];
-        if (!(objectName in nullifyMap)) {
-          nullifyMap[objectName] = value === null ? tableName : false;
-          continue;
-        }
-        if (nullifyMap[objectName] && nullifyMap[objectName] !== tableName) {
-          nullifyMap[objectName] = false;
-        }
-        continue;
-      }
-    }
-    return acc;
-  }, {});
-  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
-    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
-      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
-        result[objectName] = null;
-      }
-    }
-  }
-  return result;
-}
-
-// src/session.ts
-import { TransactionRollbackError } from "drizzle-orm/errors";
-
 // src/client.ts
 function isPool(client) {
   return typeof client.acquire === "function";
 }
 function prepareParams(params, typings) {
   return params.map((param, i) => {
-    if (param === undefined)
-      return null;
-    if (param instanceof Date)
-      return param.toISOString().replace(/'/g, "''");
-    if (typeof param === "bigint")
-      return param.toString();
+    if (param === void 0) return null;
+    if (param instanceof Date) return param.toISOString().replace(/'/g, "''");
+    if (typeof param === "bigint") return param.toString();
     if (typeof param === "string") {
       const typing = typings?.[i];
       if (typing === "decimal" && /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(param)) {
@@ -204,27 +21,25 @@ function prepareParams(params, typings) {
   });
 }
 function isTransientError(error) {
-  if (!(error instanceof Error))
-    return false;
+  if (!(error instanceof Error)) return false;
   const msg = error.message?.toLowerCase() ?? "";
   return msg.includes("connection closed") || msg.includes("econnreset") || msg.includes("epipe") || msg.includes("socket hang up") || msg.includes("connection refused");
 }
 async function withRetry(fn, maxRetries = 2) {
   let lastError;
-  for (let attempt = 0;attempt <= maxRetries; attempt++) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
       return await fn();
     } catch (error) {
       lastError = error;
-      if (!isTransientError(error) || attempt === maxRetries)
-        throw error;
-      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, attempt)));
+      if (!isTransientError(error) || attempt === maxRetries) throw error;
+      await new Promise((r) => setTimeout(r, 100 * 2 ** attempt));
     }
   }
   throw lastError;
 }
 function deduplicateColumns(columns) {
-  const counts = new Map;
+  const counts = /* @__PURE__ */ new Map();
   let hasDuplicates = false;
   for (const column of columns) {
     const next = (counts.get(column) ?? 0) + 1;
@@ -256,7 +71,7 @@ async function executeOnClient(client, query, params, typings) {
     });
   }
   const prepared = prepareParams(params, typings);
-  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const paramValue = prepared.length > 0 ? prepared : void 0;
   const rows = await client.queryAll(query, paramValue);
   if (!rows || rows.length === 0) {
     return [];
@@ -275,7 +90,7 @@ async function executeArraysOnClient(client, query, params, typings) {
     });
   }
   const prepared = prepareParams(params, typings);
-  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const paramValue = prepared.length > 0 ? prepared : void 0;
   const iter = await client.queryIter(query, paramValue);
   const schema = iter.schema();
   const fields = schema.fields();
@@ -283,10 +98,8 @@ async function executeArraysOnClient(client, query, params, typings) {
   const rows = [];
   while (true) {
     const row = await iter.next();
-    if (row === null)
-      break;
-    if (row instanceof Error)
-      throw row;
+    if (row === null) break;
+    if (row instanceof Error) throw row;
     rows.push(row.values());
   }
   return { columns, rows };
@@ -303,7 +116,7 @@ async function execOnClient(client, query, params, typings) {
     });
   }
   const prepared = prepareParams(params, typings);
-  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const paramValue = prepared.length > 0 ? prepared : void 0;
   return await client.exec(query, paramValue);
 }
 async function closeClientConnection(connection) {
@@ -312,482 +125,140 @@ async function closeClientConnection(connection) {
   }
 }
 
-// src/session.ts
-class DatabendPreparedQuery extends PgPreparedQuery {
-  client;
-  queryString;
-  params;
-  logger;
-  fields;
-  _isResponseInArrayMode;
-  customResultMapper;
-  typings;
-  static [entityKind] = "DatabendPreparedQuery";
-  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, typings) {
-    super({ sql: queryString, params });
-    this.client = client;
-    this.queryString = queryString;
-    this.params = params;
-    this.logger = logger;
-    this.fields = fields;
-    this._isResponseInArrayMode = _isResponseInArrayMode;
-    this.customResultMapper = customResultMapper;
-    this.typings = typings;
-  }
-  async execute(placeholderValues = {}) {
-    const params = fillPlaceholders(this.params, placeholderValues);
-    this.logger.logQuery(this.queryString, params);
-    const { fields, joinsNotNullableMap, customResultMapper, typings } = this;
-    if (fields) {
-      const { rows: rows2 } = await executeArraysOnClient(this.client, this.queryString, params, typings);
-      if (rows2.length === 0) {
-        return [];
-      }
-      return customResultMapper ? customResultMapper(rows2) : rows2.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
-    }
-    const rows = await executeOnClient(this.client, this.queryString, params, typings);
-    return rows;
+// 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;
   }
-  all(placeholderValues = {}) {
-    return this.execute(placeholderValues);
+  unique(name, config) {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
   }
-  isResponseInArrayMode() {
-    return this._isResponseInArrayMode;
+  /** @internal */
+  buildForeignKeys(_column, _table) {
+    return [];
   }
-}
-
-class DatabendSession extends PgSession {
-  client;
-  schema;
-  options;
-  static [entityKind] = "DatabendSession";
-  dialect;
-  logger;
-  rollbackOnly = false;
-  constructor(client, dialect, schema, options = {}) {
-    super(dialect);
-    this.client = client;
-    this.schema = schema;
-    this.options = options;
-    this.dialect = dialect;
-    this.logger = options.logger ?? new NoopLogger;
+  /** @internal */
+  buildExtraConfigColumn(table) {
+    return new DatabendExtraConfigColumn(table, this.config);
   }
-  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
-    return new DatabendPreparedQuery(this.client, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, query.typings);
+};
+var DatabendColumn = class extends Column {
+  static [entityKind] = "DatabendColumn";
+  constructor(table, config) {
+    super(table, config);
   }
-  async transaction(transaction, config) {
-    let pinnedConnection;
-    let pool;
-    let clientForTx = this.client;
-    if (isPool(this.client)) {
-      pool = this.client;
-      pinnedConnection = await pool.acquire();
-      clientForTx = pinnedConnection;
-    }
-    const session = new DatabendSession(clientForTx, this.dialect, this.schema, this.options);
-    const tx = new DatabendTransaction(this.dialect, session, this.schema);
-    try {
-      await tx.execute(sql`BEGIN`);
-      if (config) {
-        await tx.setTransaction(config);
-      }
-      try {
-        const result = await transaction(tx);
-        if (session.isRollbackOnly()) {
-          await tx.execute(sql`ROLLBACK`);
-          throw new TransactionRollbackError;
-        }
-        await tx.execute(sql`COMMIT`);
-        return result;
-      } catch (error) {
-        await tx.execute(sql`ROLLBACK`);
-        throw error;
-      }
-    } finally {
-      if (pinnedConnection && pool) {
-        await pool.release(pinnedConnection);
-      }
-    }
+  getSQLType() {
+    return "";
   }
-  markRollbackOnly() {
-    this.rollbackOnly = true;
+};
+var DatabendExtraConfigColumn = class extends DatabendColumn {
+  static [entityKind] = "DatabendExtraConfigColumn";
+  getSQLType() {
+    return this.getSQLType();
   }
-  isRollbackOnly() {
-    return this.rollbackOnly;
+  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;
   }
-}
-var VALID_TRANSACTION_ISOLATION_LEVELS = new Set([
-  "read uncommitted",
-  "read committed",
-  "repeatable read",
-  "serializable"
-]);
-var VALID_TRANSACTION_ACCESS_MODES = new Set([
-  "read only",
-  "read write"
-]);
-
-class DatabendTransaction extends PgTransaction {
-  static [entityKind] = "DatabendTransaction";
-  rollback() {
-    throw new TransactionRollbackError;
+  desc() {
+    this.indexConfig.order = "desc";
+    return this;
   }
-  getTransactionConfigSQL(config) {
-    if (config.isolationLevel && !VALID_TRANSACTION_ISOLATION_LEVELS.has(config.isolationLevel)) {
-      throw new Error(`Invalid transaction isolation level "${config.isolationLevel}". Expected one of: ${Array.from(VALID_TRANSACTION_ISOLATION_LEVELS).join(", ")}.`);
-    }
-    if (config.accessMode && !VALID_TRANSACTION_ACCESS_MODES.has(config.accessMode)) {
-      throw new Error(`Invalid transaction access mode "${config.accessMode}". Expected one of: ${Array.from(VALID_TRANSACTION_ACCESS_MODES).join(", ")}.`);
-    }
-    const chunks = [];
-    if (config.isolationLevel) {
-      chunks.push(`isolation level ${config.isolationLevel}`);
-    }
-    if (config.accessMode) {
-      chunks.push(config.accessMode);
-    }
-    return sql.raw(chunks.join(" "));
+  nullsFirst() {
+    this.indexConfig.nulls = "first";
+    return this;
   }
-  setTransaction(config) {
-    return this.session.execute(sql`SET TRANSACTION ${this.getTransactionConfigSQL(config)}`);
+  nullsLast() {
+    this.indexConfig.nulls = "last";
+    return this;
   }
-  async transaction(transaction) {
-    const internals = this;
-    const nestedTx = new DatabendTransaction(internals.dialect, internals.session, this.schema, this.nestedIndex + 1);
-    return transaction(nestedTx).catch((error) => {
-      internals.session.markRollbackOnly();
-      throw error;
-    });
+};
+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/dialect.ts
-import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
-import {
-  PgBigInt53,
-  PgBigInt64,
-  PgDate as PgDate2,
-  PgDateString as PgDateString2,
-  PgDialect,
-  PgDoublePrecision,
-  PgInteger,
-  PgNumeric,
-  PgReal,
-  PgSmallInt,
-  PgTime as PgTime2,
-  PgTimestamp as PgTimestamp2,
-  PgTimestampString as PgTimestampString2,
-  PgUUID
-} from "drizzle-orm/pg-core";
-import {
-  sql as sql2
-} from "drizzle-orm";
+};
 
-class DatabendDialect extends PgDialect {
-  static [entityKind2] = "DatabendPgDialect";
-  areSavepointsUnsupported() {
-    return true;
+// 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;
   }
-  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 = sql2`
-      CREATE TABLE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} (
-        id INT NOT NULL,
-        hash VARCHAR NOT NULL,
-        created_at BIGINT
-      )
-    `;
-    await session.execute(migrationTableCreate);
-    const dbMigrations = await session.all(sql2`SELECT id, hash, created_at FROM ${sql2.identifier(migrationsSchema)}.${sql2.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(sql2.raw(stmt));
-          }
-          await tx.execute(sql2`INSERT INTO ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} (id, hash, created_at)
-              VALUES (
-                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)}),
-                ${migration.hash},
-                ${migration.folderMillis}
-              )`);
-        }
-      }
-    });
+  /** @internal */
+  build(table) {
+    return new DatabendCustomColumn(
+      table,
+      this.config,
+      this.sqlDataType,
+      this.mapTo,
+      this.mapFrom
+    );
   }
-  prepareTyping(encoder) {
-    if (is2(encoder, PgNumeric) || is2(encoder, PgInteger) || is2(encoder, PgSmallInt) || is2(encoder, PgReal) || is2(encoder, PgDoublePrecision) || is2(encoder, PgBigInt53) || is2(encoder, PgBigInt64)) {
-      return "decimal";
-    } else if (is2(encoder, PgTime2)) {
-      return "time";
-    } else if (is2(encoder, PgTimestamp2) || is2(encoder, PgTimestampString2)) {
-      return "timestamp";
-    } else if (is2(encoder, PgDate2) || is2(encoder, PgDateString2)) {
-      return "date";
-    } else if (is2(encoder, PgUUID)) {
-      return "uuid";
-    } else {
-      return "none";
-    }
+};
+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/pool.ts
-function createDatabendConnectionPool(client, options = {}) {
-  const size = options.size && options.size > 0 ? options.size : 4;
-  const acquireTimeout = options.acquireTimeout ?? 30000;
-  const maxWaitingRequests = options.maxWaitingRequests ?? 100;
-  const maxLifetimeMs = options.maxLifetimeMs;
-  const idleTimeoutMs = options.idleTimeoutMs;
-  const metadata = new WeakMap;
-  const idle = [];
-  const waiting = [];
-  let total = 0;
-  let closed = false;
-  let pendingAcquires = 0;
-  const shouldRecycle = (conn, now) => {
-    if (maxLifetimeMs !== undefined && now - conn.createdAt >= maxLifetimeMs) {
-      return true;
-    }
-    if (idleTimeoutMs !== undefined && now - conn.lastUsedAt >= idleTimeoutMs) {
-      return true;
-    }
-    return false;
-  };
-  const acquire = async () => {
-    if (closed) {
-      throw new Error("Databend connection pool is closed");
-    }
-    while (idle.length > 0) {
-      const pooled = idle.pop();
-      const now = Date.now();
-      if (shouldRecycle(pooled, now)) {
-        await closeClientConnection(pooled.connection);
-        total = Math.max(0, total - 1);
-        metadata.delete(pooled.connection);
-        continue;
-      }
-      pooled.lastUsedAt = now;
-      metadata.set(pooled.connection, {
-        createdAt: pooled.createdAt,
-        lastUsedAt: pooled.lastUsedAt
-      });
-      return pooled.connection;
-    }
-    if (total < size) {
-      pendingAcquires += 1;
-      total += 1;
-      try {
-        const connection = await client.getConn();
-        if (closed) {
-          await closeClientConnection(connection);
-          total -= 1;
-          throw new Error("Databend connection pool is closed");
-        }
-        const now = Date.now();
-        metadata.set(connection, { createdAt: now, lastUsedAt: now });
-        return connection;
-      } catch (error) {
-        total -= 1;
-        throw error;
-      } finally {
-        pendingAcquires -= 1;
-      }
-    }
-    if (waiting.length >= maxWaitingRequests) {
-      throw new Error(`Databend connection pool queue is full (max ${maxWaitingRequests} waiting requests)`);
-    }
-    return await new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        const idx = waiting.findIndex((w) => w.timeoutId === timeoutId);
-        if (idx !== -1) {
-          waiting.splice(idx, 1);
-        }
-        reject(new Error(`Databend connection pool acquire timeout after ${acquireTimeout}ms`));
-      }, acquireTimeout);
-      waiting.push({ resolve, reject, timeoutId });
-    });
-  };
-  const release = async (connection) => {
-    const waiter = waiting.shift();
-    if (waiter) {
-      clearTimeout(waiter.timeoutId);
-      const now2 = Date.now();
-      const meta = metadata.get(connection) ?? { createdAt: now2, lastUsedAt: now2 };
-      const expired = maxLifetimeMs !== undefined && now2 - meta.createdAt >= maxLifetimeMs;
-      if (closed) {
-        await closeClientConnection(connection);
-        total = Math.max(0, total - 1);
-        metadata.delete(connection);
-        waiter.reject(new Error("Databend connection pool is closed"));
-        return;
-      }
-      if (expired) {
-        await closeClientConnection(connection);
-        total = Math.max(0, total - 1);
-        metadata.delete(connection);
-        try {
-          const replacement = await acquire();
-          waiter.resolve(replacement);
-        } catch (error) {
-          waiter.reject(error);
-        }
-        return;
-      }
-      meta.lastUsedAt = now2;
-      metadata.set(connection, meta);
-      waiter.resolve(connection);
-      return;
-    }
-    if (closed) {
-      await closeClientConnection(connection);
-      metadata.delete(connection);
-      total = Math.max(0, total - 1);
-      return;
-    }
-    const now = Date.now();
-    const existingMeta = metadata.get(connection) ?? { createdAt: now, lastUsedAt: now };
-    existingMeta.lastUsedAt = now;
-    metadata.set(connection, existingMeta);
-    if (maxLifetimeMs !== undefined && now - existingMeta.createdAt >= maxLifetimeMs) {
-      await closeClientConnection(connection);
-      total -= 1;
-      metadata.delete(connection);
-      return;
-    }
-    idle.push({
-      connection,
-      createdAt: existingMeta.createdAt,
-      lastUsedAt: existingMeta.lastUsedAt
-    });
-  };
-  const close = async () => {
-    closed = true;
-    const waiters = waiting.splice(0, waiting.length);
-    for (const waiter of waiters) {
-      clearTimeout(waiter.timeoutId);
-      waiter.reject(new Error("Databend connection pool is closed"));
-    }
-    const toClose = idle.splice(0, idle.length);
-    await Promise.allSettled(toClose.map((item) => closeClientConnection(item.connection)));
-    total = Math.max(0, total - toClose.length);
-    toClose.forEach((item) => metadata.delete(item.connection));
-    const maxWait = 5000;
-    const start = Date.now();
-    while (pendingAcquires > 0 && Date.now() - start < maxWait) {
-      await new Promise((r) => setTimeout(r, 10));
-    }
-  };
-  return {
-    acquire,
-    release,
-    close,
-    size
-  };
-}
-
-// src/driver.ts
-class DatabendDriver {
-  client;
-  dialect;
-  options;
-  static [entityKind3] = "DatabendDriver";
-  constructor(client, dialect, options = {}) {
-    this.client = client;
-    this.dialect = dialect;
-    this.options = options;
-  }
-  createSession(schema) {
-    return new DatabendSession(this.client, this.dialect, schema, {
-      logger: this.options.logger
-    });
-  }
-}
-function isConfigObject(data) {
-  if (typeof data !== "object" || data === null)
-    return false;
-  if (data.constructor?.name !== "Object")
-    return false;
-  return "connection" in data || "client" in data || "pool" in data || "schema" in data || "logger" in data;
-}
-function createFromClient(client, config = {}, databendClient) {
-  const dialect = new DatabendDialect;
-  const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
-  let schema;
-  if (config.schema) {
-    const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
-    schema = {
-      fullSchema: config.schema,
-      schema: tablesConfig.tables,
-      tableNamesMap: tablesConfig.tableNamesMap
-    };
-  }
-  const driver = new DatabendDriver(client, dialect, { logger });
-  const session = driver.createSession(schema);
-  const db = new DatabendDatabase(dialect, session, schema, client, databendClient);
-  return db;
-}
-async function createFromDsn(dsn, config = {}) {
-  const databendClient = new Client(dsn);
-  if (config.pool === false) {
-    const connection = await databendClient.getConn();
-    return createFromClient(connection, config, databendClient);
-  }
-  const poolSize = config.pool?.size ?? 4;
-  const pool = createDatabendConnectionPool(databendClient, { size: poolSize });
-  return createFromClient(pool, config, databendClient);
-}
-function drizzle(clientOrConfigOrDsn, config) {
-  if (typeof clientOrConfigOrDsn === "string") {
-    return createFromDsn(clientOrConfigOrDsn, config);
-  }
-  if (isConfigObject(clientOrConfigOrDsn)) {
-    const configObj = clientOrConfigOrDsn;
-    if ("connection" in configObj) {
-      const connConfig = configObj;
-      const { connection, ...restConfig } = connConfig;
-      return createFromDsn(connection, restConfig);
-    }
-    if ("client" in configObj) {
-      const clientConfig = configObj;
-      const { client: clientValue, ...restConfig } = clientConfig;
-      return createFromClient(clientValue, restConfig);
-    }
-    throw new Error("Invalid drizzle config: either connection or client must be provided");
-  }
-  return createFromClient(clientOrConfigOrDsn, config);
-}
-
-class DatabendDatabase extends PgDatabase {
-  dialect;
-  session;
-  static [entityKind3] = "DatabendDatabase";
-  $client;
-  $databendClient;
-  constructor(dialect, session, schema, client, databendClient) {
-    super(dialect, session, schema);
-    this.dialect = dialect;
-    this.session = session;
-    this.$client = client;
-    this.$databendClient = databendClient;
-  }
-  async close() {
-    if (isPool(this.$client) && this.$client.close) {
-      await this.$client.close();
-    }
-    if (!isPool(this.$client)) {
-      await closeClientConnection(this.$client);
-    }
-  }
-  async transaction(transaction) {
-    return await this.session.transaction(transaction);
-  }
-}
 // src/columns.ts
-import { customType } from "drizzle-orm/pg-core";
 var databendVariant = (name) => customType({
   dataType() {
     return "VARIANT";
@@ -900,32 +371,3012 @@ var databendDate = (name) => customType({
     return value.slice(0, 10);
   }
 })(name);
-// src/migrator.ts
-import { readMigrationFiles } from "drizzle-orm/migrator";
-async function migrate(db, config) {
-  const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
-  const migrations = readMigrationFiles(migrationConfig);
-  await db.dialect.migrate(migrations, db.session, migrationConfig);
+
+// src/databend-core/alias.ts
+import { TableAliasProxyHandler } from "drizzle-orm/alias";
+function alias(table, alias2) {
+  return new Proxy(table, new TableAliasProxyHandler(alias2, false));
 }
-export {
-  prepareParams,
-  migrate,
-  isPool,
-  executeOnClient,
-  executeArraysOnClient,
-  execOnClient,
-  drizzle,
-  databendVariant,
-  databendTuple,
-  databendTimestamp,
-  databendMap,
-  databendDate,
-  databendArray,
-  createDatabendConnectionPool,
-  closeClientConnection,
-  DatabendTransaction,
-  DatabendSession,
-  DatabendPreparedQuery,
-  DatabendDriver,
-  DatabendDatabase
+
+// 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
+      };
+    }
+  }
+};
+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 entityKind36 } from "drizzle-orm/entity";
+import { DefaultLogger } from "drizzle-orm/logger";
+import {
+  createTableRelationsHelpers,
+  extractTablesRelationalConfig
+} from "drizzle-orm/relations";
+
+// 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);
+  }
+  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;
+      }
+    );
+  }
+};
+
+// 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;
+        }
+      );
+    });
+  }
+  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);
+  }
+};
+
+// src/pool.ts
+function createDatabendConnectionPool(client, options = {}) {
+  const size = options.size && options.size > 0 ? options.size : 4;
+  const acquireTimeout = options.acquireTimeout ?? 3e4;
+  const maxWaitingRequests = options.maxWaitingRequests ?? 100;
+  const maxLifetimeMs = options.maxLifetimeMs;
+  const idleTimeoutMs = options.idleTimeoutMs;
+  const metadata = /* @__PURE__ */ new WeakMap();
+  const idle = [];
+  const waiting = [];
+  let total = 0;
+  let closed = false;
+  let pendingAcquires = 0;
+  const shouldRecycle = (conn, now) => {
+    if (maxLifetimeMs !== void 0 && now - conn.createdAt >= maxLifetimeMs) {
+      return true;
+    }
+    if (idleTimeoutMs !== void 0 && now - conn.lastUsedAt >= idleTimeoutMs) {
+      return true;
+    }
+    return false;
+  };
+  const acquire = async () => {
+    if (closed) {
+      throw new Error("Databend connection pool is closed");
+    }
+    while (idle.length > 0) {
+      const pooled = idle.pop();
+      const now = Date.now();
+      if (shouldRecycle(pooled, now)) {
+        await closeClientConnection(pooled.connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(pooled.connection);
+        continue;
+      }
+      pooled.lastUsedAt = now;
+      metadata.set(pooled.connection, {
+        createdAt: pooled.createdAt,
+        lastUsedAt: pooled.lastUsedAt
+      });
+      return pooled.connection;
+    }
+    if (total < size) {
+      pendingAcquires += 1;
+      total += 1;
+      try {
+        const connection = await client.getConn();
+        if (closed) {
+          await closeClientConnection(connection);
+          total -= 1;
+          throw new Error("Databend connection pool is closed");
+        }
+        const now = Date.now();
+        metadata.set(connection, { createdAt: now, lastUsedAt: now });
+        return connection;
+      } catch (error) {
+        total -= 1;
+        throw error;
+      } finally {
+        pendingAcquires -= 1;
+      }
+    }
+    if (waiting.length >= maxWaitingRequests) {
+      throw new Error(
+        `Databend connection pool queue is full (max ${maxWaitingRequests} waiting requests)`
+      );
+    }
+    return await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = waiting.findIndex((w) => w.timeoutId === timeoutId);
+        if (idx !== -1) {
+          waiting.splice(idx, 1);
+        }
+        reject(
+          new Error(
+            `Databend connection pool acquire timeout after ${acquireTimeout}ms`
+          )
+        );
+      }, acquireTimeout);
+      waiting.push({ resolve, reject, timeoutId });
+    });
+  };
+  const release = async (connection) => {
+    const waiter = waiting.shift();
+    if (waiter) {
+      clearTimeout(waiter.timeoutId);
+      const now2 = Date.now();
+      const meta = metadata.get(connection) ?? { createdAt: now2, lastUsedAt: now2 };
+      const expired = maxLifetimeMs !== void 0 && now2 - meta.createdAt >= maxLifetimeMs;
+      if (closed) {
+        await closeClientConnection(connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(connection);
+        waiter.reject(new Error("Databend connection pool is closed"));
+        return;
+      }
+      if (expired) {
+        await closeClientConnection(connection);
+        total = Math.max(0, total - 1);
+        metadata.delete(connection);
+        try {
+          const replacement = await acquire();
+          waiter.resolve(replacement);
+        } catch (error) {
+          waiter.reject(error);
+        }
+        return;
+      }
+      meta.lastUsedAt = now2;
+      metadata.set(connection, meta);
+      waiter.resolve(connection);
+      return;
+    }
+    if (closed) {
+      await closeClientConnection(connection);
+      metadata.delete(connection);
+      total = Math.max(0, total - 1);
+      return;
+    }
+    const now = Date.now();
+    const existingMeta = metadata.get(connection) ?? { createdAt: now, lastUsedAt: now };
+    existingMeta.lastUsedAt = now;
+    metadata.set(connection, existingMeta);
+    if (maxLifetimeMs !== void 0 && now - existingMeta.createdAt >= maxLifetimeMs) {
+      await closeClientConnection(connection);
+      total -= 1;
+      metadata.delete(connection);
+      return;
+    }
+    idle.push({
+      connection,
+      createdAt: existingMeta.createdAt,
+      lastUsedAt: existingMeta.lastUsedAt
+    });
+  };
+  const close = async () => {
+    closed = true;
+    const waiters = waiting.splice(0, waiting.length);
+    for (const waiter of waiters) {
+      clearTimeout(waiter.timeoutId);
+      waiter.reject(new Error("Databend connection pool is closed"));
+    }
+    const toClose = idle.splice(0, idle.length);
+    await Promise.allSettled(
+      toClose.map((item) => closeClientConnection(item.connection))
+    );
+    total = Math.max(0, total - toClose.length);
+    for (const item of toClose) {
+      metadata.delete(item.connection);
+    }
+    const maxWait = 5e3;
+    const start = Date.now();
+    while (pendingAcquires > 0 && Date.now() - start < maxWait) {
+      await new Promise((r) => setTimeout(r, 10));
+    }
+  };
+  return {
+    acquire,
+    release,
+    close,
+    size
+  };
+}
+
+// src/session.ts
+import { entityKind as entityKind35 } from "drizzle-orm/entity";
+import { TransactionRollbackError as TransactionRollbackError2 } from "drizzle-orm/errors";
+import { NoopLogger } from "drizzle-orm/logger";
+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 as Column3,
+  getTableName as getTableName2,
+  is as is10,
+  SQL as SQL8
+} from "drizzle-orm";
+function toDecoderInput(decoder, value) {
+  void decoder;
+  return value;
+}
+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 = hasOffset ? spaced : `${spaced}Z`;
+    return new Date(normalized);
+  }
+  return value;
+}
+function normalizeDateString(value) {
+  if (value instanceof Date) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value === "string") {
+    return value.slice(0, 10);
+  }
+  return value;
+}
+function mapDriverValue(decoder, rawValue) {
+  if (is10(decoder, DatabendTimestamp)) {
+    const normalized = normalizeTimestamp(rawValue, false);
+    if (normalized instanceof Date) {
+      return normalized;
+    }
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
+  }
+  if (is10(decoder, DatabendDate)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeDateString(rawValue))
+    );
+  }
+  return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
+}
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce(
+    (acc, { path, field }, columnIndex) => {
+      let decoder;
+      if (is10(field, Column3)) {
+        decoder = field;
+      } else if (is10(field, SQL8)) {
+        decoder = field.decoder;
+      } else {
+        const col = field.sql.queryChunks.find((chunk) => is10(chunk, Column3));
+        if (is10(col, DatabendCustomColumn)) {
+          decoder = col;
+        } else {
+          decoder = field.sql.decoder;
+        }
+      }
+      let node = acc;
+      for (const [pathChunkIndex, pathChunk] of path.entries()) {
+        if (pathChunkIndex < path.length - 1) {
+          if (!(pathChunk in node)) {
+            node[pathChunk] = {};
+          }
+          node = node[pathChunk];
+          continue;
+        }
+        const rawValue = row[columnIndex];
+        const value = node[pathChunk] = rawValue === null ? null : mapDriverValue(decoder, rawValue);
+        if (joinsNotNullableMap && is10(field, Column3) && path.length === 2) {
+          const objectName = path[0];
+          if (!(objectName in nullifyMap)) {
+            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 && 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;
+          }
+          const objectName = path[0];
+          if (!(objectName in nullifyMap)) {
+            nullifyMap[objectName] = value === null ? tableName : false;
+            continue;
+          }
+          if (nullifyMap[objectName] && nullifyMap[objectName] !== tableName) {
+            nullifyMap[objectName] = false;
+          }
+        }
+      }
+      return acc;
+    },
+    {}
+  );
+  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
+        result[objectName] = null;
+      }
+    }
+  }
+  return result;
+}
+
+// src/session.ts
+var DatabendPreparedQuery2 = class extends DatabendPreparedQuery {
+  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, typings) {
+    super({ sql: queryString, params });
+    this.client = client;
+    this.queryString = queryString;
+    this.params = params;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+    this.typings = typings;
+  }
+  static [entityKind35] = "DatabendPreparedQuery";
+  async execute(placeholderValues = {}) {
+    const params = fillPlaceholders(this.params, placeholderValues);
+    this.logger.logQuery(this.queryString, params);
+    const { fields, joinsNotNullableMap, customResultMapper, typings } = this;
+    if (fields) {
+      const { rows: rows2 } = await executeArraysOnClient(
+        this.client,
+        this.queryString,
+        params,
+        typings
+      );
+      if (rows2.length === 0) {
+        return [];
+      }
+      return customResultMapper ? customResultMapper(rows2) : rows2.map(
+        (row) => mapResultRow(fields, row, joinsNotNullableMap)
+      );
+    }
+    const rows = await executeOnClient(this.client, this.queryString, params, typings);
+    return rows;
+  }
+  all(placeholderValues = {}) {
+    return this.execute(placeholderValues);
+  }
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+};
+var DatabendSession2 = class _DatabendSession extends DatabendSession {
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.dialect = dialect;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  static [entityKind35] = "DatabendSession";
+  dialect;
+  logger;
+  rollbackOnly = false;
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    void name;
+    return new DatabendPreparedQuery2(
+      this.client,
+      query.sql,
+      query.params,
+      this.logger,
+      fields,
+      isResponseInArrayMode,
+      customResultMapper,
+      query.typings
+    );
+  }
+  async transaction(transaction, config) {
+    let pinnedConnection;
+    let pool;
+    let clientForTx = this.client;
+    if (isPool(this.client)) {
+      pool = this.client;
+      pinnedConnection = await pool.acquire();
+      clientForTx = pinnedConnection;
+    }
+    const session = new _DatabendSession(
+      clientForTx,
+      this.dialect,
+      this.schema,
+      this.options
+    );
+    const tx = new DatabendTransaction2(
+      this.dialect,
+      session,
+      this.schema
+    );
+    try {
+      await tx.execute(sql7`BEGIN`);
+      if (config) {
+        await tx.setTransaction(config);
+      }
+      try {
+        const result = await transaction(tx);
+        if (session.isRollbackOnly()) {
+          await tx.execute(sql7`ROLLBACK`);
+          throw new TransactionRollbackError2();
+        }
+        await tx.execute(sql7`COMMIT`);
+        return result;
+      } catch (error) {
+        await tx.execute(sql7`ROLLBACK`);
+        throw error;
+      }
+    } finally {
+      if (pinnedConnection && pool) {
+        await pool.release(pinnedConnection);
+      }
+    }
+  }
+  markRollbackOnly() {
+    this.rollbackOnly = true;
+  }
+  isRollbackOnly() {
+    return this.rollbackOnly;
+  }
+};
+var VALID_TRANSACTION_ISOLATION_LEVELS = /* @__PURE__ */ new Set([
+  "read uncommitted",
+  "read committed",
+  "repeatable read",
+  "serializable"
+]);
+var VALID_TRANSACTION_ACCESS_MODES = /* @__PURE__ */ new Set([
+  "read only",
+  "read write"
+]);
+var DatabendTransaction2 = class _DatabendTransaction extends DatabendTransaction {
+  static [entityKind35] = "DatabendTransaction";
+  rollback() {
+    throw new TransactionRollbackError2();
+  }
+  getTransactionConfigSQL(config) {
+    if (config.isolationLevel && !VALID_TRANSACTION_ISOLATION_LEVELS.has(config.isolationLevel)) {
+      throw new Error(
+        `Invalid transaction isolation level "${config.isolationLevel}". Expected one of: ${Array.from(
+          VALID_TRANSACTION_ISOLATION_LEVELS
+        ).join(", ")}.`
+      );
+    }
+    if (config.accessMode && !VALID_TRANSACTION_ACCESS_MODES.has(config.accessMode)) {
+      throw new Error(
+        `Invalid transaction access mode "${config.accessMode}". Expected one of: ${Array.from(
+          VALID_TRANSACTION_ACCESS_MODES
+        ).join(", ")}.`
+      );
+    }
+    const chunks = [];
+    if (config.isolationLevel) {
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    }
+    if (config.accessMode) {
+      chunks.push(config.accessMode);
+    }
+    return sql7.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(
+      sql7`SET TRANSACTION ${this.getTransactionConfigSQL(config)}`
+    );
+  }
+  async transaction(transaction) {
+    const internals = this;
+    const nestedTx = new _DatabendTransaction(
+      internals.dialect,
+      internals.session,
+      this.schema,
+      this.nestedIndex + 1
+    );
+    return transaction(nestedTx).catch((error) => {
+      internals.session.markRollbackOnly();
+      throw error;
+    });
+  }
+};
+
+// src/driver.ts
+var DatabendDriver = class {
+  constructor(client, dialect, options = {}) {
+    this.client = client;
+    this.dialect = dialect;
+    this.options = options;
+  }
+  static [entityKind36] = "DatabendDriver";
+  createSession(schema) {
+    return new DatabendSession2(this.client, this.dialect, schema, {
+      logger: this.options.logger
+    });
+  }
+};
+function isConfigObject(data) {
+  if (typeof data !== "object" || data === null) return false;
+  if (data.constructor?.name !== "Object") return false;
+  return "connection" in data || "client" in data || "pool" in data || "schema" in data || "logger" in data;
+}
+function createFromClient(client, config = {}, databendClient) {
+  const dialect = new DatabendDialect();
+  const logger = config.logger === true ? new DefaultLogger() : config.logger || void 0;
+  let schema;
+  if (config.schema) {
+    const tablesConfig = extractTablesRelationalConfig(
+      config.schema,
+      createTableRelationsHelpers
+    );
+    schema = {
+      fullSchema: config.schema,
+      schema: tablesConfig.tables,
+      tableNamesMap: tablesConfig.tableNamesMap
+    };
+  }
+  const driver = new DatabendDriver(client, dialect, { logger });
+  const session = driver.createSession(schema);
+  const db = new DatabendDatabase2(
+    dialect,
+    session,
+    schema,
+    client,
+    databendClient
+  );
+  return db;
+}
+async function createFromDsn(dsn, config = {}) {
+  const databendClient = new Client(dsn);
+  if (config.pool === false) {
+    const connection = await databendClient.getConn();
+    return createFromClient(connection, config, databendClient);
+  }
+  const poolSize = config.pool?.size ?? 4;
+  const pool = createDatabendConnectionPool(databendClient, { size: poolSize });
+  return createFromClient(pool, config, databendClient);
+}
+function drizzle(clientOrConfigOrDsn, config) {
+  if (typeof clientOrConfigOrDsn === "string") {
+    return createFromDsn(clientOrConfigOrDsn, config);
+  }
+  if (isConfigObject(clientOrConfigOrDsn)) {
+    const configObj = clientOrConfigOrDsn;
+    if ("connection" in configObj) {
+      const connConfig = configObj;
+      const { connection, ...restConfig } = connConfig;
+      return createFromDsn(
+        connection,
+        restConfig
+      );
+    }
+    if ("client" in configObj) {
+      const clientConfig = configObj;
+      const { client: clientValue, ...restConfig } = clientConfig;
+      return createFromClient(
+        clientValue,
+        restConfig
+      );
+    }
+    throw new Error(
+      "Invalid drizzle config: either connection or client must be provided"
+    );
+  }
+  return createFromClient(clientOrConfigOrDsn, config);
+}
+var DatabendDatabase2 = class extends DatabendDatabase {
+  constructor(dialect, session, schema, client, databendClient) {
+    super(dialect, session, schema);
+    this.dialect = dialect;
+    this.session = session;
+    this.$client = client;
+    this.$databendClient = databendClient;
+  }
+  static [entityKind36] = "DatabendDatabase";
+  /** The underlying connection or pool */
+  $client;
+  /** The Databend Client instance (when created from DSN) */
+  $databendClient;
+  async close() {
+    if (isPool(this.$client) && this.$client.close) {
+      await this.$client.close();
+    }
+    if (!isPool(this.$client)) {
+      await closeClientConnection(this.$client);
+    }
+  }
+  async transaction(transaction) {
+    return await this.session.transaction(transaction);
+  }
+};
+
+// src/migrator.ts
+import { readMigrationFiles } from "drizzle-orm/migrator";
+async function migrate(db, config) {
+  const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
+  const migrations = readMigrationFiles(migrationConfig);
+  await db.dialect.migrate(
+    migrations,
+    db.session,
+    migrationConfig
+  );
+}
+export {
+  DatabendColumn,
+  DatabendColumnBuilder,
+  DatabendDatabase2 as DatabendDatabase,
+  DatabendDialect,
+  DatabendDriver,
+  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,
+  primaryKey,
+  real,
+  smallint,
+  text,
+  timestamp,
+  tinyint,
+  uniqueIndex,
+  varchar,
+  variant
 };