drizzle-databend 0.1.10 → 0.1.12

package/dist/databend-core/primary-keys.d.ts

@@ -0,0 +1,20 @@
+import { entityKind } from 'drizzle-orm/entity';
+export declare function primaryKey(...config: any[]): PrimaryKeyBuilder;
+export declare class PrimaryKeyBuilder {
+    static readonly [entityKind]: string;
+    /** @internal */
+    columns: any[];
+    /** @internal */
+    name?: string;
+    constructor(columns: any[], name?: string);
+    /** @internal */
+    build(table: any): PrimaryKey;
+}
+export declare class PrimaryKey {
+    table: any;
+    static readonly [entityKind]: string;
+    columns: any[];
+    name?: string;
+    constructor(table: any, columns: any[], name?: string);
+    getName(): string;
+}

package/dist/databend-core/query-builders/count.d.ts

@@ -0,0 +1,18 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { SQL } from 'drizzle-orm/sql/sql';
+export declare class DatabendCountBuilder extends SQL {
+    static readonly [entityKind]: string;
+    readonly [Symbol.toStringTag] = "DatabendCountBuilder";
+    private sql;
+    private session;
+    constructor(params: {
+        source: any;
+        filters?: any;
+        session: any;
+    });
+    private static buildEmbeddedCount;
+    private static buildCount;
+    then(onfulfilled?: any, onrejected?: any): Promise<any>;
+    catch(onRejected?: any): Promise<any>;
+    finally(onFinally?: any): Promise<any>;
+}

package/dist/databend-core/query-builders/delete.d.ts

@@ -0,0 +1,18 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+export declare class DatabendDeleteBase extends QueryPromise<any> {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    config: any;
+    constructor(table: any, session: any, dialect: any, withList?: any[]);
+    where(where: any): this;
+    /** @internal */
+    getSQL(): any;
+    toSQL(): any;
+    /** @internal */
+    _prepare(name?: string): any;
+    prepare(name: string): any;
+    execute: (placeholderValues?: any) => any;
+    $dynamic(): this;
+}

package/dist/databend-core/query-builders/index.d.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/dist/databend-core/query-builders/insert.d.ts

@@ -0,0 +1,27 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+export declare class DatabendInsertBuilder {
+    private table;
+    private session;
+    private dialect;
+    private withList?;
+    static readonly [entityKind]: string;
+    constructor(table: any, session: any, dialect: any, withList?: any[] | undefined);
+    values(values: any): DatabendInsertBase;
+    select(selectQuery: any): DatabendInsertBase;
+}
+export declare class DatabendInsertBase extends QueryPromise<any> {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    config: any;
+    constructor(table: any, values: any, session: any, dialect: any, withList?: any[], select?: boolean);
+    /** @internal */
+    getSQL(): any;
+    toSQL(): any;
+    /** @internal */
+    _prepare(name?: string): any;
+    prepare(name: string): any;
+    execute: (placeholderValues?: any) => any;
+    $dynamic(): this;
+}

package/dist/databend-core/query-builders/query-builder.d.ts

@@ -0,0 +1,19 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { WithSubquery } from 'drizzle-orm/subquery';
+import { DatabendSelectBuilder } from './select.ts';
+export declare class QueryBuilder {
+    static readonly [entityKind]: string;
+    dialect: any;
+    dialectConfig: any;
+    constructor(dialect?: any);
+    $with(alias: string): {
+        as(qb: any): WithSubquery<string, Record<string, unknown>>;
+    };
+    with(...queries: any[]): {
+        select: (fields?: any) => DatabendSelectBuilder;
+        selectDistinct: (fields?: any) => DatabendSelectBuilder;
+    };
+    select(fields?: any): DatabendSelectBuilder;
+    selectDistinct(fields?: any): DatabendSelectBuilder;
+    private getDialect;
+}

package/dist/databend-core/query-builders/query.d.ts

@@ -0,0 +1,37 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+export declare class RelationalQueryBuilder {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    static readonly [entityKind]: string;
+    constructor(fullSchema: any, schema: any, tableNamesMap: any, table: any, tableConfig: any, dialect: any, session: any);
+    findMany(config?: any): DatabendRelationalQuery;
+    findFirst(config?: any): DatabendRelationalQuery;
+}
+export declare class DatabendRelationalQuery extends QueryPromise<any> {
+    private fullSchema;
+    private schema;
+    private tableNamesMap;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    private config;
+    private mode;
+    static readonly [entityKind]: string;
+    constructor(fullSchema: any, schema: any, tableNamesMap: any, table: any, tableConfig: any, dialect: any, session: any, config: any, mode: 'many' | 'first');
+    /** @internal */
+    _prepare(name?: string): any;
+    prepare(name: string): any;
+    private _getQuery;
+    /** @internal */
+    getSQL(): any;
+    private _toSQL;
+    toSQL(): any;
+    execute(): any;
+}

package/dist/databend-core/query-builders/raw.d.ts

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

package/dist/databend-core/query-builders/select.d.ts

@@ -0,0 +1,65 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { TypedQueryBuilder } from 'drizzle-orm/query-builders/query-builder';
+import { Subquery } from 'drizzle-orm/subquery';
+export declare class DatabendSelectBuilder {
+    static readonly [entityKind]: string;
+    fields: any;
+    session: any;
+    dialect: any;
+    withList: any[];
+    distinct: any;
+    constructor(config: any);
+    from(source: any): any;
+}
+declare class DatabendSelectQueryBuilderBase extends TypedQueryBuilder<any, any> {
+    static readonly [entityKind]: string;
+    _: any;
+    config: any;
+    joinsNotNullableMap: any;
+    tableName: any;
+    isPartialSelect: any;
+    session: any;
+    dialect: any;
+    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct }: any);
+    private createJoin;
+    leftJoin: (table: any, on: any) => this;
+    rightJoin: (table: any, on: any) => this;
+    innerJoin: (table: any, on: any) => this;
+    fullJoin: (table: any, on: any) => this;
+    private createSetOperator;
+    union: (rightSelection: any) => this;
+    unionAll: (rightSelection: any) => this;
+    intersect: (rightSelection: any) => this;
+    intersectAll: (rightSelection: any) => this;
+    except: (rightSelection: any) => this;
+    exceptAll: (rightSelection: any) => this;
+    /** @internal */
+    addSetOperators(setOperators: any[]): this;
+    where(where: any): this;
+    having(having: any): this;
+    groupBy(...columns: any[]): this;
+    orderBy(...columns: any[]): this;
+    limit(limit: any): this;
+    offset(offset: any): this;
+    /** @internal */
+    getSQL(): any;
+    toSQL(): any;
+    as(alias: string): Subquery<string, Record<string, unknown>>;
+    /** @internal */
+    getSelectedFields(): any;
+    $dynamic(): this;
+}
+export declare class DatabendSelectBase extends DatabendSelectQueryBuilderBase {
+    static readonly [entityKind]: string;
+    /** @internal */
+    _prepare(name?: string): any;
+    prepare(name: string): any;
+    execute: (placeholderValues?: any) => any;
+}
+export declare const union: (leftSelect: any, rightSelect: any, ...restSelects: any[]) => any;
+export declare const unionAll: (leftSelect: any, rightSelect: any, ...restSelects: any[]) => any;
+export declare const intersect: (leftSelect: any, rightSelect: any, ...restSelects: any[]) => any;
+export declare const intersectAll: (leftSelect: any, rightSelect: any, ...restSelects: any[]) => any;
+export declare const except: (leftSelect: any, rightSelect: any, ...restSelects: any[]) => any;
+export declare const exceptAll: (leftSelect: any, rightSelect: any, ...restSelects: any[]) => any;
+export {};

package/dist/databend-core/query-builders/update.d.ts

@@ -0,0 +1,27 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { QueryPromise } from 'drizzle-orm/query-promise';
+export declare class DatabendUpdateBuilder {
+    private table;
+    private session;
+    private dialect;
+    private withList?;
+    static readonly [entityKind]: string;
+    constructor(table: any, session: any, dialect: any, withList?: any[] | undefined);
+    set(values: any): DatabendUpdateBase;
+}
+export declare class DatabendUpdateBase extends QueryPromise<any> {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    config: any;
+    constructor(table: any, set: any, session: any, dialect: any, withList?: any[]);
+    where(where: any): this;
+    /** @internal */
+    getSQL(): any;
+    toSQL(): any;
+    /** @internal */
+    _prepare(name?: string): any;
+    prepare(name: string): any;
+    execute: (placeholderValues?: any) => any;
+    $dynamic(): this;
+}

package/dist/databend-core/schema.d.ts

@@ -0,0 +1,12 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { SQL } from 'drizzle-orm/sql/sql';
+export declare class DatabendSchema {
+    schemaName: string;
+    static readonly [entityKind]: string;
+    constructor(schemaName: string);
+    table: (name: string, columns: any, extraConfig?: any) => any;
+    getSQL(): SQL;
+    shouldOmitSQLParens(): boolean;
+}
+export declare function isDatabendSchema(obj: unknown): obj is DatabendSchema;
+export declare function databendSchema(name: string): DatabendSchema;

package/dist/databend-core/session.d.ts

@@ -0,0 +1,28 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendDatabase } from './db.ts';
+export declare class DatabendPreparedQuery {
+    query: any;
+    static readonly [entityKind]: string;
+    /** @internal */
+    joinsNotNullableMap: Record<string, boolean> | undefined;
+    constructor(query: any);
+    getQuery(): any;
+    mapResult(response: any, _isFromBatch?: boolean): any;
+}
+export declare class DatabendSession {
+    dialect: any;
+    static readonly [entityKind]: string;
+    constructor(dialect: any);
+    execute(query: any): any;
+    all(query: any): any;
+    count(sql: any): Promise<number>;
+    prepareQuery(_query: any, _fields: any, _name: any, _isResponseInArrayMode: boolean, _customResultMapper?: any): any;
+    transaction(_transaction: any, _config?: any): Promise<any>;
+}
+export declare class DatabendTransaction extends DatabendDatabase {
+    nestedIndex: number;
+    static readonly [entityKind]: string;
+    readonly schema: any;
+    constructor(dialect: any, session: any, schema: any, nestedIndex?: number);
+    rollback(): never;
+}

package/dist/databend-core/subquery.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/databend-core/table.d.ts

@@ -0,0 +1,12 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { Table } from 'drizzle-orm/table';
+export declare class DatabendTable extends Table {
+    static readonly [entityKind]: string;
+    /** @internal */
+    static Symbol: any;
+    constructor(name: string, schema: string | undefined, baseName: string);
+}
+declare function databendTableWithSchema(name: string, columns: any, extraConfig: any, schema: string | undefined, baseName?: string): any;
+export declare const databendTable: (name: string, columns: any, extraConfig?: any) => any;
+export declare function databendTableCreator(customizeTableName: (name: string) => string): (name: string, columns: any, extraConfig?: any) => any;
+export { databendTableWithSchema };

package/dist/databend-core/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function getTableConfig(table: any): {
+    columns: unknown[];
+    indexes: any[];
+    primaryKeys: any[];
+    name: any;
+    schema: any;
+};

package/dist/databend-core/view-base.d.ts

@@ -0,0 +1,5 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { View } from 'drizzle-orm/sql/sql';
+export declare class DatabendViewBase extends View {
+    static readonly [entityKind]: string;
+}

package/dist/databend-core/view-common.d.ts

@@ -0,0 +1 @@
+export declare const DatabendViewConfig: unique symbol;

package/dist/databend-core/view.d.ts

@@ -0,0 +1,30 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendViewBase } from './view-base.ts';
+import { DatabendViewConfig } from './view-common.ts';
+declare class DefaultViewBuilderCore {
+    protected name: string;
+    protected schema?: string | undefined;
+    static readonly [entityKind]: string;
+    config: any;
+    constructor(name: string, schema?: string | undefined);
+    with(config: any): this;
+}
+export declare class ViewBuilder extends DefaultViewBuilderCore {
+    static readonly [entityKind]: string;
+    as(qb: any): Record<string, unknown> | import("drizzle-orm").View<string, boolean, import("drizzle-orm").ColumnsSelection> | import("drizzle-orm").Subquery<string, Record<string, unknown>>;
+}
+export declare class ManualViewBuilder extends DefaultViewBuilderCore {
+    static readonly [entityKind]: string;
+    columns: any;
+    constructor(name: string, columns: any, schema?: string);
+    existing(): DatabendView;
+    as(query: any): DatabendView;
+}
+export declare class DatabendView extends DatabendViewBase {
+    static readonly [entityKind]: string;
+    [DatabendViewConfig]: any;
+    constructor({ databendConfig, config }: any);
+}
+export declare function databendView(name: string, columns?: any): ViewBuilder | ManualViewBuilder;
+export declare function isDatabendView(obj: unknown): obj is DatabendView;
+export {};

package/dist/dialect.d.ts

@@ -1,10 +1 @@
-import { entityKind } from 'drizzle-orm/entity';
-import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
-import { PgDialect, PgSession } from 'drizzle-orm/pg-core';
-import { type DriverValueEncoder, type QueryTypingsValue } from 'drizzle-orm';
-export declare class DatabendDialect extends PgDialect {
-    static readonly [entityKind]: string;
-    areSavepointsUnsupported(): boolean;
-    migrate(migrations: MigrationMeta[], session: PgSession, config: MigrationConfig | string): Promise<void>;
-    prepareTyping(encoder: DriverValueEncoder<unknown, unknown>): QueryTypingsValue;
-}
+export { DatabendDialect } from './databend-core/dialect.ts';

package/dist/driver.d.ts

@@ -1,13 +1,13 @@
 import { Client } from 'databend-driver';
 import { entityKind } from 'drizzle-orm/entity';
 import type { Logger } from 'drizzle-orm/logger';
-import { PgDatabase } from 'drizzle-orm/pg-core/db';
 import { type ExtractTablesWithRelations, type RelationalSchemaConfig, type TablesRelationalConfig } from 'drizzle-orm/relations';
-import { type DrizzleConfig } from 'drizzle-orm/utils';
-import type { DatabendClientLike, DatabendQueryResultHKT, DatabendTransaction } from './session.ts';
-import { DatabendSession } from './session.ts';
-import { DatabendDialect } from './dialect.ts';
+import type { DrizzleConfig } from 'drizzle-orm/utils';
+import { DatabendDatabase as DatabendDatabaseBase } from './databend-core/db.ts';
+import { DatabendDialect } from './databend-core/dialect.ts';
 import { type DatabendPoolConfig } from './pool.ts';
+import type { DatabendClientLike, DatabendTransaction } from './session.ts';
+import { DatabendSession } from './session.ts';
 export interface DatabendDriverOptions {
     logger?: Logger;
 }
@@ -36,7 +36,7 @@ export declare function drizzle<TSchema extends Record<string, unknown> = Record
 export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DatabendDrizzleConfigWithConnection<TSchema>): Promise<DatabendDatabase<TSchema, ExtractTablesWithRelations<TSchema>>>;
 export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(config: DatabendDrizzleConfigWithClient<TSchema>): DatabendDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
 export declare function drizzle<TSchema extends Record<string, unknown> = Record<string, never>>(client: DatabendClientLike, config?: DatabendDrizzleConfig<TSchema>): DatabendDatabase<TSchema, ExtractTablesWithRelations<TSchema>>;
-export declare class DatabendDatabase<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends PgDatabase<DatabendQueryResultHKT, TFullSchema, TSchema> {
+export declare class DatabendDatabase<TFullSchema extends Record<string, unknown> = Record<string, never>, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> extends DatabendDatabaseBase {
     readonly dialect: DatabendDialect;
     readonly session: DatabendSession<TFullSchema, TSchema>;
     static readonly [entityKind]: string;

package/dist/index.d.ts

@@ -1,6 +1,16 @@
-export * from './driver.ts';
-export * from './session.ts';
+export * from './client.ts';
 export * from './columns.ts';
+export { alias } from './databend-core/alias.ts';
+export { DatabendColumn, DatabendColumnBuilder } from './databend-core/columns/common.ts';
+export { bigint, binary, bitmap, boolean, date, decimal, doublePrecision, float, integer, real, smallint, text, timestamp, tinyint, varchar, variant, } from './databend-core/columns/index.ts';
+export { DatabendDialect } from './databend-core/dialect.ts';
+export { index, uniqueIndex } from './databend-core/indexes.ts';
+export { primaryKey } from './databend-core/primary-keys.ts';
+export { databendSchema } from './databend-core/schema.ts';
+export { DatabendTable, databendTable, databendTableCreator } from './databend-core/table.ts';
+export { getTableConfig } from './databend-core/utils.ts';
+export { databendView } from './databend-core/view.ts';
+export * from './driver.ts';
 export * from './migrator.ts';
-export * from './client.ts';
 export * from './pool.ts';
+export * from './session.ts';