drizzle-databend 0.1.11 → 0.1.13

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

@@ -0,0 +1,44 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendDecimalBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendDecimalBuilder';
+
+  constructor(name: string, precision?: number, scale?: number) {
+    super(name, 'string', 'DatabendDecimal');
+    (this.config as any).precision = precision;
+    (this.config as any).scale = scale;
+  }
+
+  /** @internal */
+  build(table: any): DatabendDecimal {
+    return new DatabendDecimal(table, this.config);
+  }
+}
+
+export class DatabendDecimal extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendDecimal';
+
+  precision: number | undefined;
+  scale: number | undefined;
+
+  constructor(table: any, config: any) {
+    super(table, config);
+    this.precision = config.precision;
+    this.scale = config.scale;
+  }
+
+  getSQLType(): string {
+    if (this.precision !== undefined && this.scale !== undefined) {
+      return `decimal(${this.precision}, ${this.scale})`;
+    }
+    if (this.precision !== undefined) {
+      return `decimal(${this.precision})`;
+    }
+    return 'decimal';
+  }
+}
+
+export function decimal(name?: string, config?: { precision?: number; scale?: number }) {
+  return new DatabendDecimalBuilder(name ?? '', config?.precision, config?.scale);
+}

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

@@ -0,0 +1,34 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendDoublePrecisionBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendDoublePrecisionBuilder';
+
+  constructor(name: string) {
+    super(name, 'number', 'DatabendDoublePrecision');
+  }
+
+  /** @internal */
+  build(table: any): DatabendDoublePrecision {
+    return new DatabendDoublePrecision(table, this.config);
+  }
+}
+
+export class DatabendDoublePrecision extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendDoublePrecision';
+
+  getSQLType(): string {
+    return 'double';
+  }
+
+  mapFromDriverValue(value: any): number {
+    if (typeof value === 'string') {
+      return Number.parseFloat(value);
+    }
+    return value;
+  }
+}
+
+export function doublePrecision(name?: string) {
+  return new DatabendDoublePrecisionBuilder(name ?? '');
+}

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

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

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

@@ -0,0 +1,21 @@
+export * from './all.ts';
+export * from './array.ts';
+export * from './bigint.ts';
+export * from './binary.ts';
+export * from './bitmap.ts';
+export * from './boolean.ts';
+export * from './common.ts';
+export * from './custom.ts';
+export * from './date.ts';
+export * from './decimal.ts';
+export * from './double.ts';
+export * from './float.ts';
+export * from './integer.ts';
+export * from './map.ts';
+export * from './smallint.ts';
+export * from './text.ts';
+export * from './timestamp.ts';
+export * from './tinyint.ts';
+export * from './tuple.ts';
+export * from './varchar.ts';
+export * from './variant.ts';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+
+export class DatabendVarcharBuilder extends DatabendColumnBuilder {
+  static readonly [entityKind]: string = 'DatabendVarcharBuilder';
+
+  constructor(name: string, length?: number) {
+    super(name, 'string', 'DatabendVarchar');
+    (this.config as any).length = length;
+  }
+
+  /** @internal */
+  build(table: any): DatabendVarchar {
+    return new DatabendVarchar(table, this.config);
+  }
+}
+
+export class DatabendVarchar extends DatabendColumn {
+  static readonly [entityKind]: string = 'DatabendVarchar';
+
+  length: number | undefined;
+
+  constructor(table: any, config: any) {
+    super(table, config);
+    this.length = config.length;
+  }
+
+  getSQLType(): string {
+    return this.length ? `varchar(${this.length})` : 'varchar';
+  }
+}
+
+export function varchar(name?: string, config?: { length?: number }) {
+  return new DatabendVarcharBuilder(name ?? '', config?.length);
+}

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

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

package/src/databend-core/db.ts

@@ -0,0 +1,153 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { SelectionProxyHandler } from 'drizzle-orm/selection-proxy';
+import { sql } from 'drizzle-orm/sql/sql';
+import { WithSubquery } from 'drizzle-orm/subquery';
+import { DatabendCountBuilder } from './query-builders/count.ts';
+import {
+  DatabendDeleteBase,
+  DatabendInsertBuilder,
+  DatabendSelectBuilder,
+  DatabendUpdateBuilder,
+  QueryBuilder,
+} from './query-builders/index.ts';
+import { RelationalQueryBuilder } from './query-builders/query.ts';
+import { DatabendRaw } from './query-builders/raw.ts';
+
+export class DatabendDatabase {
+  static readonly [entityKind]: string = 'DatabendDatabase';
+
+  _: any;
+  query: any;
+
+  constructor(
+    public dialect: any,
+    public session: any,
+    schema?: any
+  ) {
+    this._ = schema
+      ? {
+          schema: schema.schema,
+          fullSchema: schema.fullSchema,
+          tableNamesMap: schema.tableNamesMap,
+          session,
+        }
+      : {
+          schema: undefined,
+          fullSchema: {},
+          tableNamesMap: {},
+          session,
+        };
+
+    this.query = {};
+    if (this._.schema) {
+      for (const [tableName, columns] of Object.entries(this._.schema)) {
+        (this.query as any)[tableName] = new RelationalQueryBuilder(
+          schema.fullSchema,
+          this._.schema,
+          this._.tableNamesMap,
+          schema.fullSchema[tableName],
+          columns,
+          dialect,
+          session
+        );
+      }
+    }
+  }
+
+  $with(alias: string) {
+    const self = this;
+    return {
+      as(qb: any) {
+        if (typeof qb === 'function') {
+          qb = qb(new QueryBuilder(self.dialect));
+        }
+        const sqlObj = typeof qb.getSQL === 'function' ? qb.getSQL() : qb;
+        const fields = typeof qb.getSelectedFields === 'function' ? qb.getSelectedFields() : {};
+        return new Proxy(
+          new WithSubquery(sqlObj, fields, alias, true),
+          new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' })
+        );
+      },
+    };
+  }
+
+  $count(source: any, filters?: any) {
+    return new DatabendCountBuilder({ source, filters, session: this.session });
+  }
+
+  with(...queries: any[]) {
+    const self = this;
+    function select(fields?: any) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+      });
+    }
+    function selectDistinct(fields?: any) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? undefined,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true,
+      });
+    }
+    function update(table: any) {
+      return new DatabendUpdateBuilder(table, self.session, self.dialect, queries);
+    }
+    function insert(table: any) {
+      return new DatabendInsertBuilder(table, self.session, self.dialect, queries);
+    }
+    function delete_(table: any) {
+      return new DatabendDeleteBase(table, self.session, self.dialect, queries);
+    }
+    return { select, selectDistinct, update, insert, delete: delete_ };
+  }
+
+  select(fields?: any) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? undefined,
+      session: this.session,
+      dialect: this.dialect,
+    });
+  }
+
+  selectDistinct(fields?: any) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? undefined,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true,
+    });
+  }
+
+  update(table: any) {
+    return new DatabendUpdateBuilder(table, this.session, this.dialect);
+  }
+
+  insert(table: any) {
+    return new DatabendInsertBuilder(table, this.session, this.dialect);
+  }
+
+  delete(table: any) {
+    return new DatabendDeleteBase(table, this.session, this.dialect);
+  }
+
+  execute(query: any) {
+    const sequel = typeof query === 'string' ? sql.raw(query) : query.getSQL();
+    const builtQuery = this.dialect.sqlToQuery(sequel);
+    const prepared = this.session.prepareQuery(builtQuery, undefined, undefined, false);
+    return new DatabendRaw(
+      () => prepared.execute(undefined),
+      sequel,
+      builtQuery,
+      (result: any) => prepared.mapResult(result, true)
+    );
+  }
+
+  transaction(transaction: any) {
+    return this.session.transaction(transaction);
+  }
+}