drizzle-databend 0.1.8 → 0.1.10

package/dist/client.d.ts

@@ -1,4 +1,5 @@
 import type { Connection } from 'databend-driver';
+import type { QueryTypingsValue } from 'drizzle-orm';
 export interface DatabendConnectionPool {
     acquire(): Promise<Connection>;
     release(connection: Connection): void | Promise<void>;
@@ -14,9 +15,12 @@ export declare function isPool(client: DatabendClientLike): client is DatabendCo
 /**
  * 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 declare function prepareParams(params: unknown[]): unknown[];
-export declare function executeOnClient(client: DatabendClientLike, query: string, params: unknown[]): Promise<RowData[]>;
-export declare function executeArraysOnClient(client: DatabendClientLike, query: string, params: unknown[]): Promise<ExecuteArraysResult>;
-export declare function execOnClient(client: DatabendClientLike, query: string, params: unknown[]): Promise<number>;
+export declare function prepareParams(params: unknown[], typings?: QueryTypingsValue[]): unknown[];
+export declare function executeOnClient(client: DatabendClientLike, query: string, params: unknown[], typings?: QueryTypingsValue[]): Promise<RowData[]>;
+export declare function executeArraysOnClient(client: DatabendClientLike, query: string, params: unknown[], typings?: QueryTypingsValue[]): Promise<ExecuteArraysResult>;
+export declare function execOnClient(client: DatabendClientLike, query: string, params: unknown[], typings?: QueryTypingsValue[]): Promise<number>;
 export declare function closeClientConnection(connection: Connection): Promise<void>;

package/dist/index.mjs

@@ -182,17 +182,47 @@ import { TransactionRollbackError } from "drizzle-orm/errors";
 function isPool(client) {
   return typeof client.acquire === "function";
 }
-function prepareParams(params) {
-  return params.map((param) => {
+function prepareParams(params, typings) {
+  return params.map((param, i) => {
     if (param === undefined)
       return null;
     if (param instanceof Date)
-      return param.toISOString();
+      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 * Math.pow(2, attempt)));
+    }
+  }
+  throw lastError;
+}
 function deduplicateColumns(columns) {
   const counts = new Map;
   let hasDuplicates = false;
@@ -214,16 +244,18 @@ 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 prepared = prepareParams(params, typings);
   const paramValue = prepared.length > 0 ? prepared : undefined;
   const rows = await client.queryAll(query, paramValue);
   if (!rows || rows.length === 0) {
@@ -231,16 +263,18 @@ async function executeOnClient(client, query, params) {
   }
   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 prepared = prepareParams(params, typings);
   const paramValue = prepared.length > 0 ? prepared : undefined;
   const iter = await client.queryIter(query, paramValue);
   const schema = iter.schema();
@@ -257,16 +291,18 @@ async function executeArraysOnClient(client, query, params) {
   }
   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 prepared = prepareParams(params, typings);
   const paramValue = prepared.length > 0 ? prepared : undefined;
   return await client.exec(query, paramValue);
 }
@@ -285,8 +321,9 @@ class DatabendPreparedQuery extends PgPreparedQuery {
   fields;
   _isResponseInArrayMode;
   customResultMapper;
+  typings;
   static [entityKind] = "DatabendPreparedQuery";
-  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper) {
+  constructor(client, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, typings) {
     super({ sql: queryString, params });
     this.client = client;
     this.queryString = queryString;
@@ -295,19 +332,20 @@ class DatabendPreparedQuery extends PgPreparedQuery {
     this.fields = fields;
     this._isResponseInArrayMode = _isResponseInArrayMode;
     this.customResultMapper = customResultMapper;
+    this.typings = typings;
   }
   async execute(placeholderValues = {}) {
-    const params = prepareParams(fillPlaceholders(this.params, placeholderValues));
+    const params = fillPlaceholders(this.params, placeholderValues);
     this.logger.logQuery(this.queryString, params);
-    const { fields, joinsNotNullableMap, customResultMapper } = this;
+    const { fields, joinsNotNullableMap, customResultMapper, typings } = this;
     if (fields) {
-      const { rows: rows2 } = await executeArraysOnClient(this.client, this.queryString, params);
+      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);
+    const rows = await executeOnClient(this.client, this.queryString, params, typings);
     return rows;
   }
   all(placeholderValues = {}) {
@@ -335,7 +373,7 @@ class DatabendSession extends PgSession {
     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 new DatabendPreparedQuery(this.client, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, query.typings);
   }
   async transaction(transaction, config) {
     let pinnedConnection;
@@ -426,10 +464,16 @@ class DatabendTransaction extends PgTransaction {
 // src/dialect.ts
 import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
 import {
+  PgBigInt53,
+  PgBigInt64,
   PgDate as PgDate2,
   PgDateString as PgDateString2,
   PgDialect,
+  PgDoublePrecision,
+  PgInteger,
   PgNumeric,
+  PgReal,
+  PgSmallInt,
   PgTime as PgTime2,
   PgTimestamp as PgTimestamp2,
   PgTimestampString as PgTimestampString2,
@@ -475,7 +519,7 @@ class DatabendDialect extends PgDialect {
     });
   }
   prepareTyping(encoder) {
-    if (is2(encoder, PgNumeric)) {
+    if (is2(encoder, PgNumeric) || is2(encoder, PgInteger) || is2(encoder, PgSmallInt) || is2(encoder, PgReal) || is2(encoder, PgDoublePrecision) || is2(encoder, PgBigInt53) || is2(encoder, PgBigInt64)) {
       return "decimal";
     } else if (is2(encoder, PgTime2)) {
       return "time";

package/dist/session.d.ts

@@ -5,7 +5,7 @@ import type { SelectedFieldsOrdered } from 'drizzle-orm/pg-core/query-builders/s
 import type { 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 { type Query, SQL } from 'drizzle-orm/sql/sql';
+import { type Query, type QueryTypingsValue, 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';
@@ -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,16 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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:declarations": "tsc --emitDeclarationOnly --project tsconfig.types.json",
-    "test": "vitest"
+    "test": "vitest",
+    "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"
   },
   "peerDependencies": {
     "databend-driver": ">=0.33.0",

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 * Math.pow(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/dialect.ts

@@ -1,11 +1,17 @@
 import { entityKind, is } from 'drizzle-orm/entity';
 import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
 import {
+  PgBigInt53,
+  PgBigInt64,
   PgDate,
   PgDateString,
   PgDialect,
+  PgDoublePrecision,
+  PgInteger,
   PgNumeric,
+  PgReal,
   PgSession,
+  PgSmallInt,
   PgTime,
   PgTimestamp,
   PgTimestampString,
@@ -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/session.ts

@@ -13,7 +13,7 @@ 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, 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';
@@ -26,7 +26,6 @@ import type {
 import {
   executeArraysOnClient,
   executeOnClient,
-  prepareParams,
   isPool,
 } from './client.ts';
 import type { Connection } from 'databend-driver';
@@ -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
     );
   }