drizzle-databend 0.1.0

package/dist/migrator.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationConfig } from 'drizzle-orm/migrator';
+import type { DatabendDatabase } from './driver.ts';
+export type DatabendMigrationConfig = MigrationConfig | string;
+export declare function migrate<TSchema extends Record<string, unknown>>(db: DatabendDatabase<TSchema>, config: DatabendMigrationConfig): Promise<void>;

package/dist/pool.d.ts

@@ -0,0 +1,21 @@
+import type { Client } from 'databend-driver';
+import { type DatabendConnectionPool } from './client.ts';
+export interface DatabendPoolConfig {
+    /** Maximum concurrent connections. Defaults to 4. */
+    size?: number;
+}
+export interface DatabendConnectionPoolOptions {
+    /** Maximum concurrent connections. Defaults to 4. */
+    size?: number;
+    /** Timeout in milliseconds to wait for a connection. Defaults to 30000 (30s). */
+    acquireTimeout?: number;
+    /** Maximum number of requests waiting for a connection. Defaults to 100. */
+    maxWaitingRequests?: number;
+    /** Max time (ms) a connection may live before being recycled. */
+    maxLifetimeMs?: number;
+    /** Max idle time (ms) before an idle connection is discarded. */
+    idleTimeoutMs?: number;
+}
+export declare function createDatabendConnectionPool(client: Client, options?: DatabendConnectionPoolOptions): DatabendConnectionPool & {
+    size: number;
+};

package/dist/session.d.ts

@@ -0,0 +1,55 @@
+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 { 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 { Assume } from 'drizzle-orm/utils';
+import type { DatabendDialect } from './dialect.ts';
+import type { DatabendClientLike, RowData } from './client.ts';
+export type { DatabendClientLike, RowData } from './client.ts';
+export declare class DatabendPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
+    private client;
+    private queryString;
+    private params;
+    private logger;
+    private fields;
+    private _isResponseInArrayMode;
+    private customResultMapper;
+    static readonly [entityKind]: string;
+    constructor(client: DatabendClientLike, queryString: string, params: unknown[], logger: Logger, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => T['execute']) | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+    isResponseInArrayMode(): boolean;
+}
+export interface DatabendSessionOptions {
+    logger?: Logger;
+}
+export declare class DatabendSession<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends PgSession<DatabendQueryResultHKT, TFullSchema, TSchema> {
+    private client;
+    private schema;
+    private options;
+    static readonly [entityKind]: string;
+    protected dialect: DatabendDialect;
+    private logger;
+    private rollbackOnly;
+    constructor(client: DatabendClientLike, dialect: DatabendDialect, schema: RelationalSchemaConfig<TSchema> | undefined, options?: DatabendSessionOptions);
+    prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][]) => T['execute']): PgPreparedQuery<T>;
+    transaction<T>(transaction: (tx: DatabendTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
+    markRollbackOnly(): void;
+    isRollbackOnly(): boolean;
+}
+export declare class DatabendTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<DatabendQueryResultHKT, TFullSchema, TSchema> {
+    static readonly [entityKind]: string;
+    rollback(): never;
+    getTransactionConfigSQL(config: PgTransactionConfig): SQL;
+    setTransaction(config: PgTransactionConfig): Promise<void>;
+    transaction<T>(transaction: (tx: DatabendTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
+}
+export type GenericRowData<T extends RowData = RowData> = T;
+export type GenericTableData<T = RowData> = T[];
+export interface DatabendQueryResultHKT extends PgQueryResultHKT {
+    type: GenericTableData<Assume<this['row'], RowData>>;
+}

package/dist/sql/result-mapper.d.ts

@@ -0,0 +1,7 @@
+import { type AnyColumn, type SelectedFieldsOrdered } from 'drizzle-orm';
+export declare function normalizeTimestampString(value: unknown, withTimezone: boolean): string | unknown;
+export declare function normalizeTimestamp(value: unknown, withTimezone: boolean): Date | unknown;
+export declare function normalizeDateString(value: unknown): string | unknown;
+export declare function normalizeDateValue(value: unknown): Date | unknown;
+export declare function normalizeTime(value: unknown): string | unknown;
+export declare function mapResultRow<TResult>(columns: SelectedFieldsOrdered<AnyColumn>, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): TResult;

package/dist/sql/selection.d.ts

@@ -0,0 +1,2 @@
+import type { SelectedFields } from 'drizzle-orm/pg-core';
+export declare function aliasFields(fields: SelectedFields, fullJoin?: boolean): SelectedFields;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "drizzle-databend",
+  "module": "./dist/index.mjs",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "version": "0.1.0",
+  "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"
+  },
+  "peerDependencies": {
+    "databend-driver": ">=0.33.0",
+    "drizzle-orm": "^0.40.0"
+  },
+  "peerDependenciesMeta": {
+    "databend-driver": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "databend-driver": "^0.33.6",
+    "@types/bun": "^1.2.5",
+    "drizzle-orm": "0.40.0",
+    "typescript": "^5.8.2",
+    "vitest": "^1.6.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.17"
+  },
+  "packageManager": "bun@1.3.6",
+  "keywords": [
+    "drizzle",
+    "databend"
+  ],
+  "license": "MIT",
+  "files": [
+    "src/**/*.ts",
+    "dist/*.mjs",
+    "dist/**/*.d.ts"
+  ]
+}

package/src/client.ts

@@ -0,0 +1,140 @@
+import type { Connection } from 'databend-driver';
+
+export interface DatabendConnectionPool {
+  acquire(): Promise<Connection>;
+  release(connection: Connection): void | Promise<void>;
+  close?(): Promise<void> | void;
+}
+
+export type DatabendClientLike = Connection | DatabendConnectionPool;
+export type RowData = Record<string, unknown>;
+
+export type ExecuteArraysResult = { columns: string[]; rows: unknown[][] };
+
+export function isPool(
+  client: DatabendClientLike
+): client is DatabendConnectionPool {
+  return typeof (client as DatabendConnectionPool).acquire === 'function';
+}
+
+/**
+ * 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.
+ */
+export function prepareParams(params: unknown[]): unknown[] {
+  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: string[]): string[] {
+  const counts = new Map<string, number>();
+  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}`;
+  });
+}
+
+export async function executeOnClient(
+  client: DatabendClientLike,
+  query: string,
+  params: unknown[]
+): Promise<RowData[]> {
+  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());
+}
+
+export async function executeArraysOnClient(
+  client: DatabendClientLike,
+  query: string,
+  params: unknown[]
+): Promise<ExecuteArraysResult> {
+  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: unknown[][] = [];
+  while (true) {
+    const row = await iter.next();
+    if (row === null) break;
+    if (row instanceof Error) throw row;
+    rows.push(row.values());
+  }
+
+  return { columns, rows };
+}
+
+export async function execOnClient(
+  client: DatabendClientLike,
+  query: string,
+  params: unknown[]
+): Promise<number> {
+  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);
+}
+
+export async function closeClientConnection(
+  connection: Connection
+): Promise<void> {
+  if ('close' in connection && typeof connection.close === 'function') {
+    await connection.close();
+  }
+}

package/src/columns.ts

@@ -0,0 +1,164 @@
+import { customType } from 'drizzle-orm/pg-core';
+import type { SQL } from 'drizzle-orm';
+
+/**
+ * Databend VARIANT column type.
+ * Stores semi-structured JSON-like data. Maps to `unknown` in TypeScript.
+ */
+export const databendVariant = <TData = unknown>(name: string) =>
+  customType<{ data: TData; driverData: string | TData }>({
+    dataType() {
+      return 'VARIANT';
+    },
+    toDriver(value: TData): string {
+      if (typeof value === 'string') {
+        return value;
+      }
+      return JSON.stringify(value);
+    },
+    fromDriver(value: string | TData): TData {
+      if (typeof value === 'string') {
+        try {
+          return JSON.parse(value) as TData;
+        } catch {
+          return value as unknown as TData;
+        }
+      }
+      return value as TData;
+    },
+  })(name);
+
+/**
+ * Databend ARRAY column type.
+ * Stores typed arrays. Maps to `T[]` in TypeScript.
+ */
+export const databendArray = <TData = unknown>(
+  name: string,
+  elementType: string
+) =>
+  customType<{ data: TData[]; driverData: TData[] | string }>({
+    dataType() {
+      return `ARRAY(${elementType})`;
+    },
+    toDriver(value: TData[]): TData[] {
+      return value;
+    },
+    fromDriver(value: TData[] | string): TData[] {
+      if (typeof value === 'string') {
+        try {
+          return JSON.parse(value) as TData[];
+        } catch {
+          return [] as TData[];
+        }
+      }
+      return value;
+    },
+  })(name);
+
+/**
+ * Databend TUPLE column type.
+ * Stores positional tuples. Maps to typed tuple in TypeScript.
+ */
+export const databendTuple = <TData extends unknown[]>(
+  name: string,
+  types: string[]
+) =>
+  customType<{ data: TData; driverData: TData | string }>({
+    dataType() {
+      return `TUPLE(${types.join(', ')})`;
+    },
+    toDriver(value: TData): TData {
+      return value;
+    },
+    fromDriver(value: TData | string): TData {
+      if (typeof value === 'string') {
+        try {
+          return JSON.parse(value) as TData;
+        } catch {
+          return value as unknown as TData;
+        }
+      }
+      return value;
+    },
+  })(name);
+
+/**
+ * Databend MAP column type.
+ * Stores key-value maps. Maps to `Record<K, V>` in TypeScript.
+ */
+export const databendMap = <TData extends Record<string, any>>(
+  name: string,
+  keyType: string,
+  valueType: string
+) =>
+  customType<{ data: TData; driverData: TData | string }>({
+    dataType() {
+      return `MAP(${keyType}, ${valueType})`;
+    },
+    toDriver(value: TData): TData {
+      return value;
+    },
+    fromDriver(value: TData | string): TData {
+      if (typeof value === 'string') {
+        try {
+          return JSON.parse(value) as TData;
+        } catch {
+          return value as unknown as TData;
+        }
+      }
+      return value;
+    },
+  })(name);
+
+/**
+ * Databend TIMESTAMP column type.
+ */
+export const databendTimestamp = (name: string) =>
+  customType<{
+    data: Date | string;
+    driverData: string | Date;
+  }>({
+    dataType() {
+      return 'TIMESTAMP';
+    },
+    toDriver(value: Date | string): string {
+      if (value instanceof Date) {
+        return value.toISOString();
+      }
+      return value;
+    },
+    fromDriver(value: string | Date): Date {
+      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);
+
+/**
+ * Databend DATE column type.
+ */
+export const databendDate = (name: string) =>
+  customType<{ data: string | Date; driverData: string | Date }>({
+    dataType() {
+      return 'DATE';
+    },
+    toDriver(value: string | Date): string {
+      if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+      }
+      return value;
+    },
+    fromDriver(value: string | Date): string {
+      if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+      }
+      return value.slice(0, 10);
+    },
+  })(name);

package/src/dialect.ts

@@ -0,0 +1,109 @@
+import { entityKind, is } from 'drizzle-orm/entity';
+import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
+import {
+  PgDate,
+  PgDateString,
+  PgDialect,
+  PgNumeric,
+  PgSession,
+  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';
+
+  // Databend does not support savepoints
+  areSavepointsUnsupported(): boolean {
+    return true;
+  }
+
+  override async migrate(
+    migrations: MigrationMeta[],
+    session: PgSession,
+    config: MigrationConfig | string
+  ): Promise<void> {
+    const migrationConfig: MigrationConfig =
+      typeof config === 'string' ? { migrationsFolder: config } : config;
+
+    const migrationsSchema = migrationConfig.migrationsSchema ?? 'default';
+    const migrationsTable =
+      migrationConfig.migrationsTable ?? '__drizzle_migrations';
+
+    // Databend has no sequences. Use explicit ID via COALESCE(MAX(id), 0) + 1.
+    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<{
+      id: number;
+      hash: string;
+      created_at: string;
+    }>(
+      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(sql.raw(stmt));
+          }
+
+          await tx.execute(
+            sql`INSERT INTO ${sql.identifier(
+              migrationsSchema
+            )}.${sql.identifier(migrationsTable)} (id, hash, created_at)
+              VALUES (
+                (SELECT COALESCE(MAX(id), 0) + 1 FROM ${sql.identifier(
+                  migrationsSchema
+                )}.${sql.identifier(migrationsTable)}),
+                ${migration.hash},
+                ${migration.folderMillis}
+              )`
+          );
+        }
+      }
+    });
+  }
+
+  override prepareTyping(
+    encoder: DriverValueEncoder<unknown, unknown>
+  ): QueryTypingsValue {
+    if (is(encoder, PgNumeric)) {
+      return 'decimal';
+    } else if (is(encoder, PgTime)) {
+      return 'time';
+    } else if (is(encoder, PgTimestamp) || is(encoder, PgTimestampString)) {
+      return 'timestamp';
+    } else if (is(encoder, PgDate) || is(encoder, PgDateString)) {
+      return 'date';
+    } else if (is(encoder, PgUUID)) {
+      return 'uuid';
+    } else {
+      return 'none';
+    }
+  }
+}