drizzle-databend 0.1.9 → 0.1.11

package/dist/index.mjs

@@ -1,200 +1,45 @@
-// 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();
+function prepareParams(params, typings) {
+  return params.map((param, i) => {
+    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)) {
+        return Number(param);
+      }
+      return param.replace(/'/g, "''");
+    }
+    if (typeof param === "object" && param !== null) {
+      return JSON.stringify(param).replace(/'/g, "''");
+    }
     return param;
   });
 }
+function isTransientError(error) {
+  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++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      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;
@@ -214,34 +59,38 @@ function deduplicateColumns(columns) {
     return count === 0 ? column : `${column}_${count}`;
   });
 }
-async function executeOnClient(client, query, params) {
+async function executeOnClient(client, query, params, typings) {
   if (isPool(client)) {
-    const connection = await client.acquire();
-    try {
-      return await executeOnClient(connection, query, params);
-    } finally {
-      await client.release(connection);
-    }
+    return withRetry(async () => {
+      const connection = await client.acquire();
+      try {
+        return await executeOnClient(connection, query, params, typings);
+      } finally {
+        await client.release(connection);
+      }
+    });
   }
-  const prepared = prepareParams(params);
-  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const prepared = prepareParams(params, typings);
+  const paramValue = prepared.length > 0 ? prepared : void 0;
   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) {
+async function executeArraysOnClient(client, query, params, typings) {
   if (isPool(client)) {
-    const connection = await client.acquire();
-    try {
-      return await executeArraysOnClient(connection, query, params);
-    } finally {
-      await client.release(connection);
-    }
+    return withRetry(async () => {
+      const connection = await client.acquire();
+      try {
+        return await executeArraysOnClient(connection, query, params, typings);
+      } finally {
+        await client.release(connection);
+      }
+    });
   }
-  const prepared = prepareParams(params);
-  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const prepared = prepareParams(params, typings);
+  const paramValue = prepared.length > 0 ? prepared : void 0;
   const iter = await client.queryIter(query, paramValue);
   const schema = iter.schema();
   const fields = schema.fields();
@@ -249,25 +98,25 @@ async function executeArraysOnClient(client, query, params) {
   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 };
 }
-async function execOnClient(client, query, params) {
+async function execOnClient(client, query, params, typings) {
   if (isPool(client)) {
-    const connection = await client.acquire();
-    try {
-      return await execOnClient(connection, query, params);
-    } finally {
-      await client.release(connection);
-    }
+    return withRetry(async () => {
+      const connection = await client.acquire();
+      try {
+        return await execOnClient(connection, query, params, typings);
+      } finally {
+        await client.release(connection);
+      }
+    });
   }
-  const prepared = prepareParams(params);
-  const paramValue = prepared.length > 0 ? prepared : undefined;
+  const prepared = prepareParams(params, typings);
+  const paramValue = prepared.length > 0 ? prepared : void 0;
   return await client.exec(query, paramValue);
 }
 async function closeClientConnection(connection) {
@@ -276,171 +125,155 @@ async function closeClientConnection(connection) {
   }
 }
 
-// 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;
+// 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;
   }
-  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) {
+})(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 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);
+    return value;
   }
-  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);
-      }
+})(name);
+var databendTuple = (name, types) => customType({
+  dataType() {
+    return `TUPLE(${types.join(", ")})`;
+  },
+  toDriver(value) {
+    return value;
+  },
+  fromDriver(value) {
+    if (typeof value === "string") {
       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);
+        return JSON.parse(value);
+      } catch {
+        return value;
       }
     }
+    return value;
   }
-  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;
+})(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;
   }
-  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(", ")}.`);
+})(name);
+var databendTimestamp = (name) => customType({
+  dataType() {
+    return "TIMESTAMP";
+  },
+  toDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
     }
-    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(", ")}.`);
+    return value;
+  },
+  fromDriver(value) {
+    if (value instanceof Date) {
+      return value;
     }
-    const chunks = [];
-    if (config.isolationLevel) {
-      chunks.push(`isolation level ${config.isolationLevel}`);
+    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);
     }
-    if (config.accessMode) {
-      chunks.push(config.accessMode);
+    return value;
+  },
+  fromDriver(value) {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
     }
-    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;
-    });
+    return value.slice(0, 10);
   }
-}
+})(name);
+
+// 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/dialect.ts
-import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
 import {
-  PgDate as PgDate2,
-  PgDateString as PgDateString2,
+  sql
+} from "drizzle-orm";
+import { entityKind, is } from "drizzle-orm/entity";
+import {
+  PgBigInt53,
+  PgBigInt64,
+  PgDate,
+  PgDateString,
   PgDialect,
+  PgDoublePrecision,
+  PgInteger,
   PgNumeric,
-  PgTime as PgTime2,
-  PgTimestamp as PgTimestamp2,
-  PgTimestampString as PgTimestampString2,
+  PgReal,
+  PgSmallInt,
+  PgTime,
+  PgTimestamp,
+  PgTimestampString,
   PgUUID
 } from "drizzle-orm/pg-core";
-import {
-  sql as sql2
-} from "drizzle-orm";
-
-class DatabendDialect extends PgDialect {
-  static [entityKind2] = "DatabendPgDialect";
+var DatabendDialect = class extends PgDialect {
+  static [entityKind] = "DatabendPgDialect";
+  // Databend does not support savepoints
   areSavepointsUnsupported() {
     return true;
   }
@@ -448,67 +281,79 @@ class DatabendDialect extends PgDialect {
     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)} (
+    const migrationTableCreate = sql`
+      CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(
+      migrationsTable
+    )} (
         id INT NOT NULL,
         hash VARCHAR NOT NULL,
         created_at BIGINT
       )
     `;
     await session.execute(migrationTableCreate);
-    const dbMigrations = await session.all(sql2`SELECT id, hash, created_at FROM ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`);
+    const dbMigrations = await session.all(
+      sql`SELECT id, hash, created_at FROM ${sql.identifier(
+        migrationsSchema
+      )}.${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
+    );
     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(sql.raw(stmt));
           }
-          await tx.execute(sql2`INSERT INTO ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} (id, hash, created_at)
+          await tx.execute(
+            sql`INSERT INTO ${sql.identifier(
+              migrationsSchema
+            )}.${sql.identifier(migrationsTable)} (id, hash, created_at)
               VALUES (
-                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)}),
+                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql.identifier(
+              migrationsSchema
+            )}.${sql.identifier(migrationsTable)}),
                 ${migration.hash},
                 ${migration.folderMillis}
-              )`);
+              )`
+          );
         }
       }
     });
   }
   prepareTyping(encoder) {
-    if (is2(encoder, PgNumeric)) {
+    if (is(encoder, PgNumeric) || is(encoder, PgInteger) || is(encoder, PgSmallInt) || is(encoder, PgReal) || is(encoder, PgDoublePrecision) || is(encoder, PgBigInt53) || is(encoder, PgBigInt64)) {
       return "decimal";
-    } else if (is2(encoder, PgTime2)) {
+    } else if (is(encoder, PgTime)) {
       return "time";
-    } else if (is2(encoder, PgTimestamp2) || is2(encoder, PgTimestampString2)) {
+    } else if (is(encoder, PgTimestamp) || is(encoder, PgTimestampString)) {
       return "timestamp";
-    } else if (is2(encoder, PgDate2) || is2(encoder, PgDateString2)) {
+    } else if (is(encoder, PgDate) || is(encoder, PgDateString)) {
       return "date";
-    } else if (is2(encoder, PgUUID)) {
+    } else if (is(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 acquireTimeout = options.acquireTimeout ?? 3e4;
   const maxWaitingRequests = options.maxWaitingRequests ?? 100;
   const maxLifetimeMs = options.maxLifetimeMs;
   const idleTimeoutMs = options.idleTimeoutMs;
-  const metadata = new WeakMap;
+  const metadata = /* @__PURE__ */ 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) {
+    if (maxLifetimeMs !== void 0 && now - conn.createdAt >= maxLifetimeMs) {
       return true;
     }
-    if (idleTimeoutMs !== undefined && now - conn.lastUsedAt >= idleTimeoutMs) {
+    if (idleTimeoutMs !== void 0 && now - conn.lastUsedAt >= idleTimeoutMs) {
       return true;
     }
     return false;
@@ -554,7 +399,9 @@ function createDatabendConnectionPool(client, options = {}) {
       }
     }
     if (waiting.length >= maxWaitingRequests) {
-      throw new Error(`Databend connection pool queue is full (max ${maxWaitingRequests} waiting requests)`);
+      throw new Error(
+        `Databend connection pool queue is full (max ${maxWaitingRequests} waiting requests)`
+      );
     }
     return await new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
@@ -562,7 +409,11 @@ function createDatabendConnectionPool(client, options = {}) {
         if (idx !== -1) {
           waiting.splice(idx, 1);
         }
-        reject(new Error(`Databend connection pool acquire timeout after ${acquireTimeout}ms`));
+        reject(
+          new Error(
+            `Databend connection pool acquire timeout after ${acquireTimeout}ms`
+          )
+        );
       }, acquireTimeout);
       waiting.push({ resolve, reject, timeoutId });
     });
@@ -573,7 +424,7 @@ function createDatabendConnectionPool(client, options = {}) {
       clearTimeout(waiter.timeoutId);
       const now2 = Date.now();
       const meta = metadata.get(connection) ?? { createdAt: now2, lastUsedAt: now2 };
-      const expired = maxLifetimeMs !== undefined && now2 - meta.createdAt >= maxLifetimeMs;
+      const expired = maxLifetimeMs !== void 0 && now2 - meta.createdAt >= maxLifetimeMs;
       if (closed) {
         await closeClientConnection(connection);
         total = Math.max(0, total - 1);
@@ -591,90 +442,451 @@ function createDatabendConnectionPool(client, options = {}) {
         } catch (error) {
           waiter.reject(error);
         }
-        return;
+        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 entityKind2 } from "drizzle-orm/entity";
+import { TransactionRollbackError } from "drizzle-orm/errors";
+import { NoopLogger } from "drizzle-orm/logger";
+import { PgTransaction } from "drizzle-orm/pg-core";
+import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
+import { fillPlaceholders, sql as sql2 } from "drizzle-orm/sql/sql";
+
+// src/sql/result-mapper.ts
+import {
+  Column,
+  getTableName,
+  is as is2,
+  SQL
+} from "drizzle-orm";
+import {
+  PgCustomColumn,
+  PgDate as PgDate2,
+  PgDateString as PgDateString2,
+  PgTime as PgTime2,
+  PgTimestamp as PgTimestamp2,
+  PgTimestampString as PgTimestampString2
+} from "drizzle-orm/pg-core";
+function toDecoderInput(decoder, value) {
+  void decoder;
+  return value;
+}
+function normalizeTimestampString(value, withTimezone) {
+  if (value instanceof Date) {
+    const iso = value.toISOString().replace("T", " ");
+    return withTimezone ? iso.replace("Z", "+00") : iso.replace("Z", "");
+  }
+  if (typeof value === "string") {
+    const normalized = value.replace("T", " ");
+    if (withTimezone) {
+      return normalized.includes("+") ? normalized : `${normalized}+00`;
+    }
+    return normalized.replace(/\+00$/, "");
+  }
+  return value;
+}
+function normalizeTimestamp(value, withTimezone) {
+  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 /* @__PURE__ */ new Date(`${value.slice(0, 10)}T00:00:00Z`);
+  }
+  return value;
+}
+function normalizeTime(value) {
+  if (typeof value === "bigint") {
+    const totalMillis = Number(value) / 1e3;
+    const date = new Date(totalMillis);
+    return date.toISOString().split("T")[1].replace("Z", "");
+  }
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[1].replace("Z", "");
+  }
+  return value;
+}
+function mapDriverValue(decoder, rawValue) {
+  if (is2(decoder, PgTimestampString2)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(
+        decoder,
+        normalizeTimestampString(rawValue, decoder.withTimezone)
+      )
+    );
+  }
+  if (is2(decoder, PgTimestamp2)) {
+    const normalized = normalizeTimestamp(rawValue, decoder.withTimezone);
+    if (normalized instanceof Date) {
+      return normalized;
+    }
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
+  }
+  if (is2(decoder, PgDateString2)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeDateString(rawValue))
+    );
+  }
+  if (is2(decoder, PgDate2)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeDateValue(rawValue))
+    );
+  }
+  if (is2(decoder, PgTime2)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeTime(rawValue))
+    );
+  }
+  return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
+}
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce(
+    (acc, { path, field }, columnIndex) => {
+      let decoder;
+      if (is2(field, Column)) {
+        decoder = field;
+      } else if (is2(field, SQL)) {
+        decoder = field.decoder;
+      } else {
+        const col = field.sql.queryChunks.find((chunk) => is2(chunk, Column));
+        if (is2(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 && is2(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 && is2(field, SQL.Aliased) && path.length === 2) {
+          const col = field.sql.queryChunks.find((chunk) => is2(chunk, Column));
+          const tableName = col?.table && getTableName(col?.table);
+          if (!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 DatabendPreparedQuery = class extends PgPreparedQuery {
+  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 [entityKind2] = "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 DatabendSession = class _DatabendSession extends PgSession {
+  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 [entityKind2] = "DatabendSession";
+  dialect;
+  logger;
+  rollbackOnly = false;
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    void name;
+    return new DatabendPreparedQuery(
+      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 DatabendTransaction(
+      this.dialect,
+      session,
+      this.schema
+    );
+    try {
+      await tx.execute(sql2`BEGIN`);
+      if (config) {
+        await tx.setTransaction(config);
+      }
+      try {
+        const result = await transaction(tx);
+        if (session.isRollbackOnly()) {
+          await tx.execute(sql2`ROLLBACK`);
+          throw new TransactionRollbackError();
+        }
+        await tx.execute(sql2`COMMIT`);
+        return result;
+      } catch (error) {
+        await tx.execute(sql2`ROLLBACK`);
+        throw error;
+      }
+    } finally {
+      if (pinnedConnection && pool) {
+        await pool.release(pinnedConnection);
       }
-      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;
+  }
+  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 DatabendTransaction = class _DatabendTransaction extends PgTransaction {
+  static [entityKind2] = "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(", ")}.`
+      );
     }
-    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;
+    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(", ")}.`
+      );
     }
-    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 chunks = [];
+    if (config.isolationLevel) {
+      chunks.push(`isolation level ${config.isolationLevel}`);
     }
-    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));
+    if (config.accessMode) {
+      chunks.push(config.accessMode);
     }
-  };
-  return {
-    acquire,
-    release,
-    close,
-    size
-  };
-}
+    return sql2.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(
+      sql2`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
-class DatabendDriver {
-  client;
-  dialect;
-  options;
-  static [entityKind3] = "DatabendDriver";
+var DatabendDriver = class {
   constructor(client, dialect, options = {}) {
     this.client = client;
     this.dialect = dialect;
     this.options = options;
   }
+  static [entityKind3] = "DatabendDriver";
   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;
+  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;
+  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);
+    const tablesConfig = extractTablesRelationalConfig(
+      config.schema,
+      createTableRelationsHelpers
+    );
     schema = {
       fullSchema: config.schema,
       schema: tablesConfig.tables,
@@ -683,7 +895,13 @@ function createFromClient(client, config = {}, databendClient) {
   }
   const driver = new DatabendDriver(client, dialect, { logger });
   const session = driver.createSession(schema);
-  const db = new DatabendDatabase(dialect, session, schema, client, databendClient);
+  const db = new DatabendDatabase(
+    dialect,
+    session,
+    schema,
+    client,
+    databendClient
+  );
   return db;
 }
 async function createFromDsn(dsn, config = {}) {
@@ -705,24 +923,26 @@ function drizzle(clientOrConfigOrDsn, config) {
     if ("connection" in configObj) {
       const connConfig = configObj;
       const { connection, ...restConfig } = connConfig;
-      return createFromDsn(connection, restConfig);
+      return createFromDsn(
+        connection,
+        restConfig
+      );
     }
     if ("client" in configObj) {
       const clientConfig = configObj;
       const { client: clientValue, ...restConfig } = clientConfig;
-      return createFromClient(clientValue, restConfig);
+      return createFromClient(
+        clientValue,
+        restConfig
+      );
     }
-    throw new Error("Invalid drizzle config: either connection or client must be provided");
+    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;
+var DatabendDatabase = class extends PgDatabase {
   constructor(dialect, session, schema, client, databendClient) {
     super(dialect, session, schema);
     this.dialect = dialect;
@@ -730,6 +950,11 @@ class DatabendDatabase extends PgDatabase {
     this.$client = client;
     this.$databendClient = databendClient;
   }
+  static [entityKind3] = "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();
@@ -741,147 +966,38 @@ class DatabendDatabase extends PgDatabase {
   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);
+  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,
+  DatabendDatabase,
   DatabendDriver,
-  DatabendDatabase
+  DatabendPreparedQuery,
+  DatabendSession,
+  DatabendTransaction,
+  closeClientConnection,
+  createDatabendConnectionPool,
+  databendArray,
+  databendDate,
+  databendMap,
+  databendTimestamp,
+  databendTuple,
+  databendVariant,
+  drizzle,
+  execOnClient,
+  executeArraysOnClient,
+  executeOnClient,
+  isPool,
+  migrate,
+  prepareParams
 };