drizzle-databend 0.1.11 → 0.1.13

package/dist/session.d.ts

@@ -1,16 +1,17 @@
 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 { 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, type QueryTypingsValue, type SQL } from 'drizzle-orm/sql/sql';
 import type { Assume } from 'drizzle-orm/utils';
 import type { DatabendClientLike, RowData } from './client.ts';
-import type { DatabendDialect } from './dialect.ts';
+import type { DatabendDialect } from './databend-core/dialect.ts';
+import { DatabendPreparedQuery as DatabendPreparedQueryBase, DatabendSession as DatabendSessionBase, DatabendTransaction as DatabendTransactionBase } from './databend-core/session.ts';
 export type { DatabendClientLike, RowData } from './client.ts';
-export declare class DatabendPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
+export interface DatabendQueryResultHKT {
+    readonly row: RowData;
+    type: GenericTableData<Assume<this['row'], RowData>>;
+}
+export declare class DatabendPreparedQuery extends DatabendPreparedQueryBase {
     private client;
     private queryString;
     private params;
@@ -20,37 +21,39 @@ export declare class DatabendPreparedQuery<T extends PreparedQueryConfig> extend
     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, typings?: QueryTypingsValue[] | undefined);
-    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
-    all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
+    constructor(client: DatabendClientLike, queryString: string, params: unknown[], logger: Logger, fields: any[] | undefined, _isResponseInArrayMode: boolean, customResultMapper: ((rows: unknown[][]) => any) | undefined, typings?: QueryTypingsValue[] | undefined);
+    execute(placeholderValues?: Record<string, unknown> | undefined): Promise<any>;
+    all(placeholderValues?: Record<string, unknown> | undefined): Promise<any>;
     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> {
+export declare class DatabendSession<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = Record<string, never>> extends DatabendSessionBase {
     private client;
     private schema;
     private options;
     static readonly [entityKind]: string;
-    protected dialect: DatabendDialect;
+    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>;
+    prepareQuery(query: Query, fields: any[] | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][]) => any): DatabendPreparedQuery;
+    transaction<T>(transaction: (tx: DatabendTransaction<TFullSchema, TSchema>) => Promise<T>, config?: DatabendTransactionConfig): Promise<T>;
     markRollbackOnly(): void;
     isRollbackOnly(): boolean;
 }
-export declare class DatabendTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<DatabendQueryResultHKT, TFullSchema, TSchema> {
+export interface DatabendTransactionConfig {
+    isolationLevel?: string;
+    accessMode?: string;
+}
+export declare class DatabendTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends DatabendTransactionBase {
     static readonly [entityKind]: string;
+    schema: any;
     rollback(): never;
-    getTransactionConfigSQL(config: PgTransactionConfig): SQL;
-    setTransaction(config: PgTransactionConfig): Promise<void>;
+    getTransactionConfigSQL(config: DatabendTransactionConfig): SQL;
+    setTransaction(config: DatabendTransactionConfig): 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

@@ -1,7 +1,6 @@
 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 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

@@ -1,2 +1,3 @@
-import type { SelectedFields } from 'drizzle-orm/pg-core';
+type SelectedFields = Record<string, any>;
 export declare function aliasFields(fields: SelectedFields, fullJoin?: boolean): SelectedFields;
+export {};

package/package.json

@@ -3,16 +3,16 @@
   "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "A drizzle ORM driver for use with Databend. Based on drizzle's Postgres driver surface.",
   "type": "module",
   "scripts": {
     "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 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",
+    "db:up": "docker-compose up -d --wait",
+    "db:down": "docker-compose down",
+    "db:destroy": "docker-compose down -v",
     "lint": "biome check src/ test/",
     "typecheck": "tsc --noEmit"
   },

package/src/columns.ts

@@ -1,12 +1,11 @@
-
-import { customType } from 'drizzle-orm/pg-core';
+import { customType } from './databend-core/columns/custom.ts';
 
 /**
  * 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 }>({
+  customType<{ data: TData; driverData: string | TData; notNull: boolean; default: boolean }>({
     dataType() {
       return 'VARIANT';
     },
@@ -36,7 +35,7 @@ export const databendArray = <TData = unknown>(
   name: string,
   elementType: string
 ) =>
-  customType<{ data: TData[]; driverData: TData[] | string }>({
+  customType<{ data: TData[]; driverData: TData[] | string; notNull: boolean; default: boolean }>({
     dataType() {
       return `ARRAY(${elementType})`;
     },
@@ -63,7 +62,7 @@ export const databendTuple = <TData extends unknown[]>(
   name: string,
   types: string[]
 ) =>
-  customType<{ data: TData; driverData: TData | string }>({
+  customType<{ data: TData; driverData: TData | string; notNull: boolean; default: boolean }>({
     dataType() {
       return `TUPLE(${types.join(', ')})`;
     },
@@ -91,7 +90,7 @@ export const databendMap = <TData extends Record<string, any>>(
   keyType: string,
   valueType: string
 ) =>
-  customType<{ data: TData; driverData: TData | string }>({
+  customType<{ data: TData; driverData: TData | string; notNull: boolean; default: boolean }>({
     dataType() {
       return `MAP(${keyType}, ${valueType})`;
     },
@@ -117,6 +116,8 @@ export const databendTimestamp = (name: string) =>
   customType<{
     data: Date | string;
     driverData: string | Date;
+    notNull: boolean;
+    default: boolean;
   }>({
     dataType() {
       return 'TIMESTAMP';
@@ -145,7 +146,7 @@ export const databendTimestamp = (name: string) =>
  * Databend DATE column type.
  */
 export const databendDate = (name: string) =>
-  customType<{ data: string | Date; driverData: string | Date }>({
+  customType<{ data: string | Date; driverData: string | Date; notNull: boolean; default: boolean }>({
     dataType() {
       return 'DATE';
     },

package/src/databend-core/alias.ts

@@ -0,0 +1,5 @@
+import { TableAliasProxyHandler } from 'drizzle-orm/alias';
+
+export function alias(table: any, alias: string): any {
+  return new Proxy(table, new TableAliasProxyHandler(alias, false));
+}

package/src/databend-core/columns/all.ts

@@ -0,0 +1,38 @@
+import { bigint } from './bigint.ts';
+import { binary } from './binary.ts';
+import { bitmap } from './bitmap.ts';
+import { boolean } from './boolean.ts';
+import { customType } from './custom.ts';
+import { date } from './date.ts';
+import { decimal } from './decimal.ts';
+import { doublePrecision } from './double.ts';
+import { float, real } from './float.ts';
+import { integer } from './integer.ts';
+import { smallint } from './smallint.ts';
+import { text } from './text.ts';
+import { timestamp } from './timestamp.ts';
+import { tinyint } from './tinyint.ts';
+import { varchar } from './varchar.ts';
+import { variant } from './variant.ts';
+
+export function getDatabendColumnBuilders() {
+  return {
+    bigint,
+    binary,
+    bitmap,
+    boolean,
+    customType,
+    date,
+    decimal,
+    doublePrecision,
+    float,
+    integer,
+    real,
+    smallint,
+    text,
+    timestamp,
+    tinyint,
+    varchar,
+    variant,
+  };
+}

package/src/databend-core/columns/array.ts

@@ -0,0 +1,46 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendArrayBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendArrayBuilder';
+
+  constructor(name: string, elementType: string) {
+    super(name, 'json', 'DatabendArray');
+    (this.config as any).elementType = elementType;
+  }
+
+  /** @internal */
+  build(table: any): DatabendArray {
+    return new DatabendArray(table, this.config);
+  }
+}
+
+export class DatabendArray extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendArray';
+
+  elementType: string;
+
+  constructor(table: any, config: any) {
+    super(table, config);
+    this.elementType = config.elementType;
+  }
+
+  getSQLType(): string {
+    return `array(${this.elementType})`;
+  }
+
+  override mapFromDriverValue(value: any): unknown[] {
+    if (typeof value === 'string') {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return [];
+      }
+    }
+    return value ?? [];
+  }
+}
+
+export function array(name: string, elementType: string) {
+  return new DatabendArrayBuilder(name, elementType);
+}

package/src/databend-core/columns/bigint.ts

@@ -0,0 +1,52 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendBigInt53Builder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendBigInt53Builder';
+
+  constructor(name: string) {
+    super(name, 'number', 'DatabendBigInt53');
+  }
+
+  /** @internal */
+  build(table: any): DatabendBigInt53 {
+    return new DatabendBigInt53(table, this.config);
+  }
+}
+
+export class DatabendBigInt53 extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendBigInt53';
+
+  getSQLType(): string {
+    return 'bigint';
+  }
+}
+
+export class DatabendBigInt64Builder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendBigInt64Builder';
+
+  constructor(name: string) {
+    super(name, 'bigint', 'DatabendBigInt64');
+  }
+
+  /** @internal */
+  build(table: any): DatabendBigInt64 {
+    return new DatabendBigInt64(table, this.config);
+  }
+}
+
+export class DatabendBigInt64 extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendBigInt64';
+
+  getSQLType(): string {
+    return 'bigint';
+  }
+
+  mapFromDriverValue(value: any): bigint {
+    return BigInt(value);
+  }
+}
+
+export function bigint(name?: string) {
+  return new DatabendBigInt53Builder(name ?? '');
+}

package/src/databend-core/columns/binary.ts

@@ -0,0 +1,27 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendBinaryBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendBinaryBuilder';
+
+  constructor(name: string) {
+    super(name, 'string', 'DatabendBinary');
+  }
+
+  /** @internal */
+  build(table: any): DatabendBinary {
+    return new DatabendBinary(table, this.config);
+  }
+}
+
+export class DatabendBinary extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendBinary';
+
+  getSQLType(): string {
+    return 'binary';
+  }
+}
+
+export function binary(name?: string) {
+  return new DatabendBinaryBuilder(name ?? '');
+}

package/src/databend-core/columns/bitmap.ts

@@ -0,0 +1,27 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendBitmapBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendBitmapBuilder';
+
+  constructor(name: string) {
+    super(name, 'string', 'DatabendBitmap');
+  }
+
+  /** @internal */
+  build(table: any): DatabendBitmap {
+    return new DatabendBitmap(table, this.config);
+  }
+}
+
+export class DatabendBitmap extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendBitmap';
+
+  getSQLType(): string {
+    return 'bitmap';
+  }
+}
+
+export function bitmap(name?: string) {
+  return new DatabendBitmapBuilder(name ?? '');
+}

package/src/databend-core/columns/boolean.ts

@@ -0,0 +1,27 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendBooleanBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendBooleanBuilder';
+
+  constructor(name: string) {
+    super(name, 'boolean', 'DatabendBoolean');
+  }
+
+  /** @internal */
+  build(table: any): DatabendBoolean {
+    return new DatabendBoolean(table, this.config);
+  }
+}
+
+export class DatabendBoolean extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendBoolean';
+
+  getSQLType(): string {
+    return 'boolean';
+  }
+}
+
+export function boolean(name?: string) {
+  return new DatabendBooleanBuilder(name ?? '');
+}

package/src/databend-core/columns/common.ts

@@ -0,0 +1,97 @@
+import { Column } from 'drizzle-orm/column';
+import { ColumnBuilder } from 'drizzle-orm/column-builder';
+import { entityKind } from 'drizzle-orm/entity';
+
+export class DatabendColumnBuilder extends ColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendColumnBuilder';
+
+  generatedAlwaysAs(as: any, _config?: any): any {
+    (this as any).config.generated = { as, type: 'always', mode: 'stored' };
+    return this;
+  }
+
+  unique(name?: string, config?: { nulls?: string }): this {
+    this.config.isUnique = true;
+    this.config.uniqueName = name;
+    this.config.uniqueType = config?.nulls;
+    return this;
+  }
+
+  /** @internal */
+  buildForeignKeys(_column: any, _table: any): any[] {
+    return [];
+  }
+
+  /** @internal */
+  buildExtraConfigColumn(table: any): DatabendExtraConfigColumn {
+    return new DatabendExtraConfigColumn(table, this.config);
+  }
+}
+
+export class DatabendColumn extends Column {
+  static readonly [entityKind]: string = 'DatabendColumn';
+
+  constructor(table: any, config: any) {
+    super(table, config);
+  }
+
+  getSQLType(): string {
+    return '';
+  }
+}
+
+export class DatabendExtraConfigColumn extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendExtraConfigColumn';
+
+  getSQLType(): string {
+    return this.getSQLType();
+  }
+
+  indexConfig = {
+    order: (this as any).config.order ?? 'asc',
+    nulls: (this as any).config.nulls ?? 'last',
+    opClass: (this as any).config.opClass,
+  };
+
+  defaultConfig = {
+    order: 'asc' as const,
+    nulls: 'last' as const,
+    opClass: undefined,
+  };
+
+  asc(): this {
+    this.indexConfig.order = 'asc';
+    return this;
+  }
+
+  desc(): this {
+    this.indexConfig.order = 'desc';
+    return this;
+  }
+
+  nullsFirst(): this {
+    this.indexConfig.nulls = 'first';
+    return this;
+  }
+
+  nullsLast(): this {
+    this.indexConfig.nulls = 'last';
+    return this;
+  }
+}
+
+export class IndexedColumn {
+  static readonly [entityKind]: string = 'IndexedColumn';
+
+  name: string;
+  keyAsName: boolean;
+  type: string;
+  indexConfig: any;
+
+  constructor(name: string, keyAsName: boolean, type: string, indexConfig: any) {
+    this.name = name;
+    this.keyAsName = keyAsName;
+    this.type = type;
+    this.indexConfig = indexConfig;
+  }
+}

package/src/databend-core/columns/custom.ts

@@ -0,0 +1,86 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export interface CustomTypeValues {
+  data: unknown;
+  driverData?: unknown;
+  notNull: boolean;
+  default: boolean;
+}
+
+export interface CustomTypeParams<T extends CustomTypeValues> {
+  dataType: (config: any) => string;
+  toDriver?: (value: T['data']) => T['driverData'] | undefined;
+  fromDriver?: (value: T['driverData']) => T['data'];
+}
+
+export class DatabendCustomColumnBuilder<T extends CustomTypeValues> extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendCustomColumnBuilder';
+
+  private sqlDataType: string;
+  private mapTo?: (value: T['data']) => T['driverData'];
+  private mapFrom?: (value: T['driverData']) => T['data'];
+
+  constructor(
+    name: string,
+    fieldConfig: any,
+    customTypeParams: CustomTypeParams<T>
+  ) {
+    super(name, 'custom', 'DatabendCustomColumn');
+    this.sqlDataType = customTypeParams.dataType(fieldConfig);
+    this.mapTo = customTypeParams.toDriver;
+    this.mapFrom = customTypeParams.fromDriver;
+  }
+
+  /** @internal */
+  build(table: any): DatabendCustomColumn<T> {
+    return new DatabendCustomColumn<T>(
+      table,
+      this.config,
+      this.sqlDataType,
+      this.mapTo,
+      this.mapFrom
+    );
+  }
+}
+
+export class DatabendCustomColumn<T extends CustomTypeValues> extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendCustomColumn';
+
+  private sqlDataType: string;
+  private mapTo?: (value: T['data']) => T['driverData'];
+  private mapFrom?: (value: T['driverData']) => T['data'];
+
+  constructor(
+    table: any,
+    config: any,
+    sqlDataType: string,
+    mapTo?: (value: T['data']) => T['driverData'],
+    mapFrom?: (value: T['driverData']) => T['data']
+  ) {
+    super(table, config);
+    this.sqlDataType = sqlDataType;
+    this.mapTo = mapTo;
+    this.mapFrom = mapFrom;
+  }
+
+  getSQLType(): string {
+    return this.sqlDataType;
+  }
+
+  override mapFromDriverValue(value: any): T['data'] {
+    return this.mapFrom ? this.mapFrom(value) : value;
+  }
+
+  override mapToDriverValue(value: T['data']): T['driverData'] {
+    return this.mapTo ? this.mapTo(value) : value;
+  }
+}
+
+export function customType<T extends CustomTypeValues>(
+  customTypeParams: CustomTypeParams<T>
+): (dbName: string, fieldConfig?: any) => DatabendCustomColumnBuilder<T> {
+  return (dbName: string, fieldConfig?: any) => {
+    return new DatabendCustomColumnBuilder(dbName, fieldConfig, customTypeParams);
+  };
+}

package/src/databend-core/columns/date.ts

@@ -0,0 +1,49 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { sql } from 'drizzle-orm/sql/sql';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendDateBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendDateBuilder';
+
+  constructor(name: string) {
+    super(name, 'string', 'DatabendDate');
+  }
+
+  defaultNow() {
+    return this.default(sql`now()`);
+  }
+
+  /** @internal */
+  build(table: any): DatabendDate {
+    return new DatabendDate(table, this.config);
+  }
+}
+
+export class DatabendDate extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendDate';
+
+  getSQLType(): string {
+    return 'date';
+  }
+
+  override mapFromDriverValue(value: any): string {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    if (typeof value === 'string') {
+      return value.slice(0, 10);
+    }
+    return value;
+  }
+
+  override mapToDriverValue(value: string | Date): string {
+    if (value instanceof Date) {
+      return value.toISOString().slice(0, 10);
+    }
+    return value;
+  }
+}
+
+export function date(name?: string) {
+  return new DatabendDateBuilder(name ?? '');
+}