drizzle-databend 0.1.9 → 0.1.11

package/dist/session.d.ts

@@ -2,13 +2,13 @@ import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
 import { PgTransaction } from 'drizzle-orm/pg-core';
 import type { SelectedFieldsOrdered } from 'drizzle-orm/pg-core/query-builders/select.types';
-import type { PgTransactionConfig, PreparedQueryConfig, PgQueryResultHKT } from 'drizzle-orm/pg-core/session';
+import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from 'drizzle-orm/pg-core/session';
 import { PgPreparedQuery, PgSession } from 'drizzle-orm/pg-core/session';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from 'drizzle-orm/relations';
-import { type Query, SQL } from 'drizzle-orm/sql/sql';
+import { type Query, type QueryTypingsValue, type SQL } from 'drizzle-orm/sql/sql';
 import type { Assume } from 'drizzle-orm/utils';
-import type { DatabendDialect } from './dialect.ts';
 import type { DatabendClientLike, RowData } from './client.ts';
+import type { DatabendDialect } from './dialect.ts';
 export type { DatabendClientLike, RowData } from './client.ts';
 export declare class DatabendPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
     private client;
@@ -18,8 +18,9 @@ export declare class DatabendPreparedQuery<T extends PreparedQueryConfig> extend
     private fields;
     private _isResponseInArrayMode;
     private customResultMapper;
+    private typings?;
     static readonly [entityKind]: string;
-    constructor(client: DatabendClientLike, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined);
+    constructor(client: DatabendClientLike, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined, typings?: QueryTypingsValue[] | undefined);
     execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
     all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
     isResponseInArrayMode(): boolean;

package/package.json

@@ -3,13 +3,18 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "A drizzle ORM driver for use with Databend. Based on drizzle's Postgres driver surface.",
   "type": "module",
   "scripts": {
-    "build": "bun build --target=node ./src/index.ts --outfile=./dist/index.mjs --packages=external && bun run build:declarations",
+    "build": "esbuild src/index.ts --bundle --format=esm --platform=node --packages=external --outfile=dist/index.mjs && npm run build:declarations",
     "build:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
-    "test": "vitest"
+    "test": "vitest run",
+    "db:start": "docker start databend 2>/dev/null || docker run -d --name databend -p 8000:8000 datafuselabs/databend",
+    "db:stop": "docker stop databend",
+    "db:restart": "docker restart databend",
+    "lint": "biome check src/ test/",
+    "typecheck": "tsc --noEmit"
   },
   "peerDependencies": {
     "databend-driver": ">=0.33.0",
@@ -21,9 +26,11 @@
     }
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.7",
+    "@types/node": "^25.5.0",
     "databend-driver": "^0.33.6",
-    "@types/bun": "^1.2.5",
     "drizzle-orm": "0.40.0",
+    "esbuild": "^0.25.0",
     "typescript": "^5.8.2",
     "vitest": "^1.6.0"
   },
@@ -39,7 +46,6 @@
   "engines": {
     "node": ">=18.17"
   },
-  "packageManager": "bun@1.3.6",
   "keywords": [
     "drizzle",
     "databend"

package/src/client.ts

@@ -1,4 +1,5 @@
 import type { Connection } from 'databend-driver';
+import type { QueryTypingsValue } from 'drizzle-orm';
 
 export interface DatabendConnectionPool {
   acquire(): Promise<Connection>;
@@ -20,16 +21,50 @@ export function isPool(
 /**
  * Convert Drizzle param array to a JSON value accepted by databend-driver's Params.
  * Databend's Params is serde_json::Value, so we pass an array of JSON-serializable values.
+ *
+ * The databend-driver does client-side parameter substitution with no string escaping,
+ * so we must pre-escape single quotes here (SQL standard '' escaping).
  */
-export function prepareParams(params: unknown[]): unknown[] {
-  return params.map((param) => {
+export function prepareParams(params: unknown[], typings?: QueryTypingsValue[]): unknown[] {
+  return params.map((param, i) => {
     if (param === undefined) return null;
-    if (param instanceof Date) return param.toISOString();
+    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: unknown): boolean {
+  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<T>(fn: () => Promise<T>, maxRetries = 2): Promise<T> {
+  let lastError: unknown;
+  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: string[]): string[] {
   const counts = new Map<string, number>();
   let hasDuplicates = false;
@@ -58,18 +93,21 @@ function deduplicateColumns(columns: string[]): string[] {
 export async function executeOnClient(
   client: DatabendClientLike,
   query: string,
-  params: unknown[]
+  params: unknown[],
+  typings?: QueryTypingsValue[]
 ): Promise<RowData[]> {
   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 prepared = prepareParams(params, typings);
   const paramValue = prepared.length > 0 ? prepared : undefined;
   const rows = await client.queryAll(query, paramValue);
 
@@ -83,18 +121,21 @@ export async function executeOnClient(
 export async function executeArraysOnClient(
   client: DatabendClientLike,
   query: string,
-  params: unknown[]
+  params: unknown[],
+  typings?: QueryTypingsValue[]
 ): Promise<ExecuteArraysResult> {
   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 prepared = prepareParams(params, typings);
   const paramValue = prepared.length > 0 ? prepared : undefined;
   const iter = await client.queryIter(query, paramValue);
   const schema = iter.schema();
@@ -115,18 +156,21 @@ export async function executeArraysOnClient(
 export async function execOnClient(
   client: DatabendClientLike,
   query: string,
-  params: unknown[]
+  params: unknown[],
+  typings?: QueryTypingsValue[]
 ): Promise<number> {
   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 prepared = prepareParams(params, typings);
   const paramValue = prepared.length > 0 ? prepared : undefined;
   return await client.exec(query, paramValue);
 }

package/src/columns.ts

@@ -1,5 +1,5 @@
+
 import { customType } from 'drizzle-orm/pg-core';
-import type { SQL } from 'drizzle-orm';
 
 /**
  * Databend VARIANT column type.

package/src/dialect.ts

@@ -1,21 +1,27 @@
+import {
+  type DriverValueEncoder,
+  type QueryTypingsValue,
+  sql,
+} from 'drizzle-orm';
 import { entityKind, is } from 'drizzle-orm/entity';
 import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
 import {
+  PgBigInt53,
+  PgBigInt64,
   PgDate,
   PgDateString,
   PgDialect,
+  PgDoublePrecision,
+  PgInteger,
   PgNumeric,
-  PgSession,
+  PgReal,
+  type PgSession,
+  PgSmallInt,
   PgTime,
   PgTimestamp,
   PgTimestampString,
   PgUUID,
 } from 'drizzle-orm/pg-core';
-import {
-  sql,
-  type DriverValueEncoder,
-  type QueryTypingsValue,
-} from 'drizzle-orm';
 
 export class DatabendDialect extends PgDialect {
   static readonly [entityKind]: string = 'DatabendPgDialect';
@@ -92,7 +98,11 @@ export class DatabendDialect extends PgDialect {
   override prepareTyping(
     encoder: DriverValueEncoder<unknown, unknown>
   ): QueryTypingsValue {
-    if (is(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 (is(encoder, PgTime)) {
       return 'time';

package/src/driver.ts

@@ -1,3 +1,4 @@
+import type { Connection } from 'databend-driver';
 import { Client } from 'databend-driver';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
@@ -5,25 +6,24 @@ import { DefaultLogger } from 'drizzle-orm/logger';
 import { PgDatabase } from 'drizzle-orm/pg-core/db';
 import {
   createTableRelationsHelpers,
-  extractTablesRelationalConfig,
   type ExtractTablesWithRelations,
+  extractTablesRelationalConfig,
   type RelationalSchemaConfig,
   type TablesRelationalConfig,
 } from 'drizzle-orm/relations';
-import { type DrizzleConfig } from 'drizzle-orm/utils';
+import type { DrizzleConfig } from 'drizzle-orm/utils';
+import { closeClientConnection, isPool } from './client.ts';
+import { DatabendDialect } from './dialect.ts';
+import {
+  createDatabendConnectionPool,
+  type DatabendPoolConfig,
+} from './pool.ts';
 import type {
   DatabendClientLike,
   DatabendQueryResultHKT,
   DatabendTransaction,
 } from './session.ts';
 import { DatabendSession } from './session.ts';
-import { DatabendDialect } from './dialect.ts';
-import { isPool, closeClientConnection } from './client.ts';
-import {
-  createDatabendConnectionPool,
-  type DatabendPoolConfig,
-} from './pool.ts';
-import type { Connection } from 'databend-driver';
 
 export interface DatabendDriverOptions {
   logger?: Logger;

package/src/index.ts

@@ -1,6 +1,6 @@
-export * from './driver.ts';
-export * from './session.ts';
+export * from './client.ts';
 export * from './columns.ts';
+export * from './driver.ts';
 export * from './migrator.ts';
-export * from './client.ts';
 export * from './pool.ts';
+export * from './session.ts';

package/src/migrator.ts

@@ -1,7 +1,7 @@
 import type { MigrationConfig } from 'drizzle-orm/migrator';
 import { readMigrationFiles } from 'drizzle-orm/migrator';
-import type { DatabendDatabase } from './driver.ts';
 import type { PgSession } from 'drizzle-orm/pg-core/session';
+import type { DatabendDatabase } from './driver.ts';
 
 export type DatabendMigrationConfig = MigrationConfig | string;
 

package/src/pool.ts

@@ -215,7 +215,9 @@ export function createDatabendConnectionPool(
       toClose.map((item) => closeClientConnection(item.connection))
     );
     total = Math.max(0, total - toClose.length);
-    toClose.forEach((item) => metadata.delete(item.connection));
+    for (const item of toClose) {
+      metadata.delete(item.connection);
+    }
 
     const maxWait = 5000;
     const start = Date.now();

package/src/session.ts

@@ -1,23 +1,22 @@
+import type { Connection } from 'databend-driver';
 import { entityKind } from 'drizzle-orm/entity';
+import { TransactionRollbackError } from 'drizzle-orm/errors';
 import type { Logger } from 'drizzle-orm/logger';
 import { NoopLogger } from 'drizzle-orm/logger';
 import { PgTransaction } from 'drizzle-orm/pg-core';
 import type { SelectedFieldsOrdered } from 'drizzle-orm/pg-core/query-builders/select.types';
 import type {
+  PgQueryResultHKT,
   PgTransactionConfig,
   PreparedQueryConfig,
-  PgQueryResultHKT,
 } from 'drizzle-orm/pg-core/session';
 import { PgPreparedQuery, PgSession } from 'drizzle-orm/pg-core/session';
 import type {
   RelationalSchemaConfig,
   TablesRelationalConfig,
 } from 'drizzle-orm/relations';
-import { fillPlaceholders, type Query, SQL, sql } from 'drizzle-orm/sql/sql';
+import { fillPlaceholders, type Query, type QueryTypingsValue, type SQL, sql } from 'drizzle-orm/sql/sql';
 import type { Assume } from 'drizzle-orm/utils';
-import { mapResultRow } from './sql/result-mapper.ts';
-import { TransactionRollbackError } from 'drizzle-orm/errors';
-import type { DatabendDialect } from './dialect.ts';
 import type {
   DatabendClientLike,
   DatabendConnectionPool,
@@ -26,10 +25,10 @@ import type {
 import {
   executeArraysOnClient,
   executeOnClient,
-  prepareParams,
   isPool,
 } from './client.ts';
-import type { Connection } from 'databend-driver';
+import type { DatabendDialect } from './dialect.ts';
+import { mapResultRow } from './sql/result-mapper.ts';
 
 export type { DatabendClientLike, RowData } from './client.ts';
 
@@ -47,7 +46,8 @@ export class DatabendPreparedQuery<
     private _isResponseInArrayMode: boolean,
     private customResultMapper:
       | ((rows: unknown[][]) => T['execute'])
-      | undefined
+      | undefined,
+    private typings?: QueryTypingsValue[]
   ) {
     super({ sql: queryString, params });
   }
@@ -55,19 +55,18 @@ export class DatabendPreparedQuery<
   async execute(
     placeholderValues: Record<string, unknown> | undefined = {}
   ): Promise<T['execute']> {
-    const params = prepareParams(
-      fillPlaceholders(this.params, placeholderValues)
-    );
+    const params = fillPlaceholders(this.params, placeholderValues);
     this.logger.logQuery(this.queryString, params);
 
-    const { fields, joinsNotNullableMap, customResultMapper } =
+    const { fields, joinsNotNullableMap, customResultMapper, typings } =
       this as typeof this & { joinsNotNullableMap?: Record<string, boolean> };
 
     if (fields) {
       const { rows } = await executeArraysOnClient(
         this.client,
         this.queryString,
-        params
+        params,
+        typings
       );
 
       if (rows.length === 0) {
@@ -81,7 +80,7 @@ export class DatabendPreparedQuery<
           );
     }
 
-    const rows = await executeOnClient(this.client, this.queryString, params);
+    const rows = await executeOnClient(this.client, this.queryString, params, typings);
 
     return rows as T['execute'];
   }
@@ -137,7 +136,8 @@ export class DatabendSession<
       this.logger,
       fields,
       isResponseInArrayMode,
-      customResultMapper
+      customResultMapper,
+      (query as any).typings
     );
   }
 

package/src/sql/result-mapper.ts

@@ -1,11 +1,11 @@
 import {
+  type AnyColumn,
   Column,
-  SQL,
+  type DriverValueDecoder,
   getTableName,
   is,
-  type AnyColumn,
-  type DriverValueDecoder,
   type SelectedFieldsOrdered,
+  SQL,
 } from 'drizzle-orm';
 import {
   PgCustomColumn,
@@ -214,7 +214,6 @@ export function mapResultRow<TResult>(
           if (nullifyMap[objectName] && nullifyMap[objectName] !== tableName) {
             nullifyMap[objectName] = false;
           }
-          continue;
         }
       }
       return acc;

package/src/sql/selection.ts

@@ -1,4 +1,4 @@
-import { Column, SQL, getTableName, is, sql } from 'drizzle-orm';
+import { Column, getTableName, is, SQL, sql } from 'drizzle-orm';
 import type { SelectedFields } from 'drizzle-orm/pg-core';
 
 function mapEntries(