drizzle-databend 0.1.0

package/dist/index.mjs

@@ -0,0 +1,887 @@
+// 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) {
+  return params.map((param) => {
+    if (param === undefined)
+      return null;
+    if (param instanceof Date)
+      return param.toISOString();
+    if (typeof param === "bigint")
+      return param.toString();
+    return param;
+  });
+}
+function deduplicateColumns(columns) {
+  const counts = new Map;
+  let hasDuplicates = false;
+  for (const column of columns) {
+    const next = (counts.get(column) ?? 0) + 1;
+    counts.set(column, next);
+    if (next > 1) {
+      hasDuplicates = true;
+      break;
+    }
+  }
+  if (!hasDuplicates) {
+    return columns;
+  }
+  counts.clear();
+  return columns.map((column) => {
+    const count = counts.get(column) ?? 0;
+    counts.set(column, count + 1);
+    return count === 0 ? column : `${column}_${count}`;
+  });
+}
+async function executeOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
+  const prepared = prepareParams(params);
+  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const rows = await client.queryAll(query, paramValue);
+  if (!rows || rows.length === 0) {
+    return [];
+  }
+  return rows.map((r) => r.data());
+}
+async function executeArraysOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await executeArraysOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
+  const prepared = prepareParams(params);
+  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const iter = await client.queryIter(query, paramValue);
+  const schema = iter.schema();
+  const fields = schema.fields();
+  const columns = deduplicateColumns(fields.map((f) => f.name));
+  const rows = [];
+  while (true) {
+    const row = await iter.next();
+    if (row === null)
+      break;
+    if (row instanceof Error)
+      throw row;
+    rows.push(row.values());
+  }
+  return { columns, rows };
+}
+async function execOnClient(client, query, params) {
+  if (isPool(client)) {
+    const connection = await client.acquire();
+    try {
+      return await execOnClient(connection, query, params);
+    } finally {
+      await client.release(connection);
+    }
+  }
+  const prepared = prepareParams(params);
+  const paramValue = prepared.length > 0 ? prepared : undefined;
+  return await client.exec(query, paramValue);
+}
+async function closeClientConnection(connection) {
+  if ("close" in connection && typeof connection.close === "function") {
+    await connection.close();
+  }
+}
+
+// src/session.ts
+class DatabendPreparedQuery extends PgPreparedQuery {
+  client;
+  queryString;
+  params;
+  logger;
+  fields;
+  _isResponseInArrayMode;
+  customResultMapper;
+  static [entityKind] = "DatabendPreparedQuery";
+  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper) {
+    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;
+  }
+  async execute(placeholderValues = {}) {
+    const params = prepareParams(fillPlaceholders(this.params, placeholderValues));
+    this.logger.logQuery(this.queryString, params);
+    const { fields, joinsNotNullableMap, customResultMapper } = this;
+    if (fields) {
+      const { rows: rows2 } = await executeArraysOnClient(this.client, this.queryString, params);
+      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);
+    return rows;
+  }
+  all(placeholderValues = {}) {
+    return this.execute(placeholderValues);
+  }
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+}
+
+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;
+  }
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new DatabendPreparedQuery(this.client, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper);
+  }
+  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);
+      }
+    }
+  }
+  markRollbackOnly() {
+    this.rollbackOnly = true;
+  }
+  isRollbackOnly() {
+    return this.rollbackOnly;
+  }
+}
+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;
+  }
+  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(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(sql`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/dialect.ts
+import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
+import {
+  PgDate as PgDate2,
+  PgDateString as PgDateString2,
+  PgDialect,
+  PgNumeric,
+  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;
+  }
+  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}
+              )`);
+        }
+      }
+    });
+  }
+  prepareTyping(encoder) {
+    if (is2(encoder, PgNumeric)) {
+      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";
+    }
+  }
+}
+
+// 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";
+  },
+  toDriver(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+})(name);
+var databendArray = (name, elementType) => customType({
+  dataType() {
+    return `ARRAY(${elementType})`;
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return [];
+      }
+    }
+    return value;
+  }
+})(name);
+var databendTuple = (name, types) => customType({
+  dataType() {
+    return `TUPLE(${types.join(", ")})`;
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+})(name);
+var databendMap = (name, keyType, valueType) => customType({
+  dataType() {
+    return `MAP(${keyType}, ${valueType})`;
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+})(name);
+var databendTimestamp = (name) => customType({
+  dataType() {
+    return "TIMESTAMP";
+  },
+  toDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return value;
+  },
+  fromDriver(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);
+  }
+})(name);
+var databendDate = (name) => customType({
+  dataType() {
+    return "DATE";
+  },
+  toDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    return value;
+  },
+  fromDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    return value.slice(0, 10);
+  }
+})(name);
+// src/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 {
+  prepareParams,
+  migrate,
+  isPool,
+  executeOnClient,
+  executeArraysOnClient,
+  execOnClient,
+  drizzle,
+  databendVariant,
+  databendTuple,
+  databendTimestamp,
+  databendMap,
+  databendDate,
+  databendArray,
+  createDatabendConnectionPool,
+  closeClientConnection,
+  DatabendTransaction,
+  DatabendSession,
+  DatabendPreparedQuery,
+  DatabendDriver,
+  DatabendDatabase
+};