drizzle-databend 0.1.11 → 0.1.13

package/src/databend-core/index.ts

@@ -0,0 +1,18 @@
+export * from './alias.ts';
+export * from './columns/index.ts';
+export * from './db.ts';
+export * from './dialect.ts';
+export * from './indexes.ts';
+export * from './primary-keys.ts';
+export * from './query-builders/count.ts';
+export * from './query-builders/index.ts';
+export * from './query-builders/query.ts';
+export * from './query-builders/raw.ts';
+export * from './schema.ts';
+export * from './session.ts';
+export * from './subquery.ts';
+export * from './table.ts';
+export * from './utils.ts';
+export * from './view.ts';
+export * from './view-base.ts';
+export * from './view-common.ts';

package/src/databend-core/indexes.ts

@@ -0,0 +1,67 @@
+import { entityKind, is } from 'drizzle-orm/entity';
+import { SQL } from 'drizzle-orm/sql/sql';
+import { IndexedColumn } from './columns/common.ts';
+
+export class IndexBuilderOn {
+  static readonly [entityKind]: string = 'DatabendIndexBuilderOn';
+
+  constructor(private unique: boolean, private name?: string) {}
+
+  on(...columns: any[]) {
+    return new IndexBuilder(
+      columns.map((it: any) => {
+        if (is(it, SQL)) {
+          return it;
+        }
+        const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+        it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+        return clonedIndexedColumn;
+      }),
+      this.unique,
+      this.name
+    );
+  }
+}
+
+export class IndexBuilder {
+  static readonly [entityKind]: string = 'DatabendIndexBuilder';
+
+  /** @internal */
+  config: any;
+
+  constructor(columns: any[], unique: boolean, name?: string) {
+    this.config = {
+      name,
+      columns,
+      unique,
+    };
+  }
+
+  where(condition: any) {
+    this.config.where = condition;
+    return this;
+  }
+
+  /** @internal */
+  build(table: any) {
+    return new Index(this.config, table);
+  }
+}
+
+export class Index {
+  static readonly [entityKind]: string = 'DatabendIndex';
+
+  config: any;
+
+  constructor(config: any, table: any) {
+    this.config = { ...config, table };
+  }
+}
+
+export function index(name?: string) {
+  return new IndexBuilderOn(false, name);
+}
+
+export function uniqueIndex(name?: string) {
+  return new IndexBuilderOn(true, name);
+}

package/src/databend-core/primary-keys.ts

@@ -0,0 +1,48 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendTable } from './table.ts';
+
+export function primaryKey(...config: any[]): PrimaryKeyBuilder {
+  if (config[0].columns) {
+    return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+  }
+  return new PrimaryKeyBuilder(config);
+}
+
+export class PrimaryKeyBuilder {
+  static readonly [entityKind]: string = 'DatabendPrimaryKeyBuilder';
+
+  /** @internal */
+  columns: any[];
+  /** @internal */
+  name?: string;
+
+  constructor(columns: any[], name?: string) {
+    this.columns = columns;
+    this.name = name;
+  }
+
+  /** @internal */
+  build(table: any) {
+    return new PrimaryKey(table, this.columns, this.name);
+  }
+}
+
+export class PrimaryKey {
+  static readonly [entityKind]: string = 'DatabendPrimaryKey';
+
+  columns: any[];
+  name?: string;
+
+  constructor(
+    public table: any,
+    columns: any[],
+    name?: string
+  ) {
+    this.columns = columns;
+    this.name = name;
+  }
+
+  getName() {
+    return this.name ?? `${this.table[DatabendTable.Symbol.Name]}_${this.columns.map((column: any) => column.name).join('_')}_pk`;
+  }
+}

package/src/databend-core/query-builders/count.ts

@@ -0,0 +1,47 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { SQL, sql } from 'drizzle-orm/sql/sql';
+
+export class DatabendCountBuilder extends SQL {
+  static override readonly [entityKind]: string = 'DatabendCountBuilder';
+  readonly [Symbol.toStringTag] = 'DatabendCountBuilder';
+
+  private sql: SQL;
+  private session: any;
+
+  constructor(params: { source: any; filters?: any; session: any }) {
+    super(DatabendCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
+    this.mapWith(Number);
+    this.session = params.session;
+    this.sql = DatabendCountBuilder.buildCount(params.source, params.filters);
+  }
+
+  private static buildEmbeddedCount(source: any, filters?: any) {
+    return sql`(select count(*) from ${source}${sql.raw(' where ').if(filters)}${filters})`;
+  }
+
+  private static buildCount(source: any, filters?: any) {
+    return sql`select count(*) as count from ${source}${sql.raw(' where ').if(filters)}${filters};`;
+  }
+
+  // biome-ignore lint/suspicious/noThenProperty: Promise-like interface required for await support
+  then(onfulfilled?: any, onrejected?: any) {
+    return Promise.resolve(this.session.count(this.sql)).then(onfulfilled, onrejected);
+  }
+
+  catch(onRejected?: any) {
+    return this.then(undefined, onRejected);
+  }
+
+  finally(onFinally?: any) {
+    return this.then(
+      (value: any) => {
+        onFinally?.();
+        return value;
+      },
+      (reason: any) => {
+        onFinally?.();
+        throw reason;
+      }
+    );
+  }
+}

package/src/databend-core/query-builders/delete.ts

@@ -0,0 +1,56 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+// @ts-expect-error - tracer is exported at runtime but not in .d.ts
+import { tracer } from 'drizzle-orm/tracing';
+
+export class DatabendDeleteBase extends QueryPromise<any> {
+  static readonly [entityKind]: string = 'DatabendDelete';
+
+  config: any;
+
+  constructor(
+    table: any,
+    private session: any,
+    private dialect: any,
+    withList?: any[]
+  ) {
+    super();
+    this.config = { table, withList };
+  }
+
+  where(where: any) {
+    this.config.where = where;
+    return this;
+  }
+
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildDeleteQuery(this.config);
+  }
+
+  toSQL() {
+    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+    return rest;
+  }
+
+  /** @internal */
+  _prepare(name?: string) {
+    return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+      return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), undefined, name, true);
+    });
+  }
+
+  prepare(name: string) {
+    return this._prepare(name);
+  }
+
+  execute = (placeholderValues?: any) => {
+    return tracer.startActiveSpan('drizzle.operation', () => {
+      return this._prepare().execute(placeholderValues);
+    });
+  };
+
+  $dynamic() {
+    return this;
+  }
+}

package/src/databend-core/query-builders/index.ts

@@ -0,0 +1,5 @@
+export * from './delete.ts';
+export * from './insert.ts';
+export * from './query-builder.ts';
+export * from './select.ts';
+export * from './update.ts';

package/src/databend-core/query-builders/insert.ts

@@ -0,0 +1,105 @@
+import { entityKind, is } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+import { Param, SQL } from 'drizzle-orm/sql/sql';
+import { Table } from 'drizzle-orm/table';
+// @ts-expect-error - tracer is exported at runtime but not in .d.ts
+import { tracer } from 'drizzle-orm/tracing';
+import { haveSameKeys } from 'drizzle-orm/utils';
+import { QueryBuilder } from './query-builder.ts';
+
+export class DatabendInsertBuilder {
+  static readonly [entityKind]: string = 'DatabendInsertBuilder';
+
+  constructor(
+    private table: any,
+    private session: any,
+    private dialect: any,
+    private withList?: any[]
+  ) {}
+
+  values(values: any) {
+    values = Array.isArray(values) ? values : [values];
+    if (values.length === 0) {
+      throw new Error('values() must be called with at least one value');
+    }
+    const mappedValues = values.map((entry: any) => {
+      const result: any = {};
+      const cols = this.table[(Table as any).Symbol.Columns];
+      for (const colKey of Object.keys(entry)) {
+        const colValue = entry[colKey];
+        result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+      }
+      return result;
+    });
+
+    return new DatabendInsertBase(
+      this.table,
+      mappedValues,
+      this.session,
+      this.dialect,
+      this.withList,
+      false
+    );
+  }
+
+  select(selectQuery: any) {
+    const select = typeof selectQuery === 'function' ? selectQuery(new QueryBuilder()) : selectQuery;
+
+    if (!is(select, SQL) && !haveSameKeys(this.table[(Table as any).Symbol.Columns], select._.selectedFields)) {
+      throw new Error(
+        'Insert select error: selected fields are not the same or are in a different order compared to the table definition'
+      );
+    }
+
+    return new DatabendInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+  }
+}
+
+export class DatabendInsertBase extends QueryPromise<any> {
+  static readonly [entityKind]: string = 'DatabendInsert';
+
+  config: any;
+
+  constructor(
+    table: any,
+    values: any,
+    private session: any,
+    private dialect: any,
+    withList?: any[],
+    select?: boolean
+  ) {
+    super();
+    this.config = { table, values, withList, select };
+  }
+
+  /** @internal */
+  getSQL() {
+    return this.dialect.buildInsertQuery(this.config);
+  }
+
+  toSQL() {
+    const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+    return rest;
+  }
+
+  /** @internal */
+  _prepare(name?: string) {
+    return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+      return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), undefined, name, true);
+    });
+  }
+
+  prepare(name: string) {
+    return this._prepare(name);
+  }
+
+  execute = (placeholderValues?: any) => {
+    return tracer.startActiveSpan('drizzle.operation', () => {
+      return this._prepare().execute(placeholderValues);
+    });
+  };
+
+  $dynamic() {
+    return this;
+  }
+}

package/src/databend-core/query-builders/query-builder.ts

@@ -0,0 +1,77 @@
+import { entityKind, is } from 'drizzle-orm/entity';
+import { SelectionProxyHandler } from 'drizzle-orm/selection-proxy';
+import { WithSubquery } from 'drizzle-orm/subquery';
+import { DatabendDialect } from '../dialect.ts';
+import { DatabendSelectBuilder } from './select.ts';
+
+export class QueryBuilder {
+  static readonly [entityKind]: string = 'DatabendQueryBuilder';
+
+  dialect: any;
+  dialectConfig: any;
+
+  constructor(dialect?: any) {
+    this.dialect = is(dialect, DatabendDialect) ? dialect : undefined;
+    this.dialectConfig = is(dialect, DatabendDialect) ? undefined : dialect;
+  }
+
+  $with(alias: string) {
+    const queryBuilder = this;
+    return {
+      as(qb: any) {
+        if (typeof qb === 'function') {
+          qb = qb(queryBuilder);
+        }
+        return new Proxy(
+          new WithSubquery(qb.getSQL(), qb.getSelectedFields(), alias, true),
+          new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' })
+        );
+      },
+    };
+  }
+
+  with(...queries: any[]) {
+    const self = this;
+    function select(fields?: any) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? undefined,
+        session: undefined,
+        dialect: self.getDialect(),
+        withList: queries,
+      });
+    }
+    function selectDistinct(fields?: any) {
+      return new DatabendSelectBuilder({
+        fields: fields ?? undefined,
+        session: undefined,
+        dialect: self.getDialect(),
+        distinct: true,
+      });
+    }
+    return { select, selectDistinct };
+  }
+
+  select(fields?: any) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? undefined,
+      session: undefined,
+      dialect: this.getDialect(),
+    });
+  }
+
+  selectDistinct(fields?: any) {
+    return new DatabendSelectBuilder({
+      fields: fields ?? undefined,
+      session: undefined,
+      dialect: this.getDialect(),
+      distinct: true,
+    });
+  }
+
+  private getDialect() {
+    if (!this.dialect) {
+      this.dialect = new DatabendDialect(this.dialectConfig);
+    }
+    return this.dialect;
+  }
+}

package/src/databend-core/query-builders/query.ts

@@ -0,0 +1,124 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+import { mapRelationalRow } from 'drizzle-orm/relations';
+// @ts-expect-error - tracer is exported at runtime but not in .d.ts
+import { tracer } from 'drizzle-orm/tracing';
+
+export class RelationalQueryBuilder {
+  static readonly [entityKind]: string = 'DatabendRelationalQueryBuilder';
+
+  constructor(
+    private fullSchema: any,
+    private schema: any,
+    private tableNamesMap: any,
+    private table: any,
+    private tableConfig: any,
+    private dialect: any,
+    private session: any
+  ) {}
+
+  findMany(config?: any) {
+    return new DatabendRelationalQuery(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      config ? config : {},
+      'many'
+    );
+  }
+
+  findFirst(config?: any) {
+    return new DatabendRelationalQuery(
+      this.fullSchema,
+      this.schema,
+      this.tableNamesMap,
+      this.table,
+      this.tableConfig,
+      this.dialect,
+      this.session,
+      config ? { ...config, limit: 1 } : { limit: 1 },
+      'first'
+    );
+  }
+}
+
+export class DatabendRelationalQuery extends QueryPromise<any> {
+  static readonly [entityKind]: string = 'DatabendRelationalQuery';
+
+  constructor(
+    private fullSchema: any,
+    private schema: any,
+    private tableNamesMap: any,
+    private table: any,
+    private tableConfig: any,
+    private dialect: any,
+    private session: any,
+    private config: any,
+    private mode: 'many' | 'first'
+  ) {
+    super();
+  }
+
+  /** @internal */
+  _prepare(name?: string) {
+    return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+      const { query, builtQuery } = this._toSQL();
+      return this.session.prepareQuery(
+        builtQuery,
+        undefined,
+        name,
+        true,
+        (rawRows: any, mapColumnValue: any) => {
+          const rows = rawRows.map(
+            (row: any) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
+          );
+          if (this.mode === 'first') {
+            return rows[0];
+          }
+          return rows;
+        }
+      );
+    });
+  }
+
+  prepare(name: string) {
+    return this._prepare(name);
+  }
+
+  private _getQuery() {
+    return this.dialect.buildRelationalQueryWithoutPK({
+      fullSchema: this.fullSchema,
+      schema: this.schema,
+      tableNamesMap: this.tableNamesMap,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      tableAlias: this.tableConfig.tsName,
+    });
+  }
+
+  /** @internal */
+  getSQL() {
+    return this._getQuery().sql;
+  }
+
+  private _toSQL() {
+    const query = this._getQuery();
+    const builtQuery = this.dialect.sqlToQuery(query.sql);
+    return { query, builtQuery };
+  }
+
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+
+  execute() {
+    return tracer.startActiveSpan('drizzle.operation', () => {
+      return this._prepare().execute(undefined);
+    });
+  }
+}

package/src/databend-core/query-builders/raw.ts

@@ -0,0 +1,37 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+
+export class DatabendRaw extends QueryPromise<any> {
+  static readonly [entityKind]: string = 'DatabendRaw';
+
+  constructor(
+    public execute: () => Promise<any>,
+    public sql: any,
+    public query: any,
+    public mapBatchResult: (result: any) => any
+  ) {
+    super();
+  }
+
+  /** @internal */
+  getSQL() {
+    return this.sql;
+  }
+
+  getQuery() {
+    return this.query;
+  }
+
+  mapResult(result: any, isFromBatch: boolean) {
+    return isFromBatch ? this.mapBatchResult(result) : result;
+  }
+
+  _prepare() {
+    return this;
+  }
+
+  /** @internal */
+  isResponseInArrayMode() {
+    return false;
+  }
+}