semanticdb-v2 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/physical/clickhouse-provider.d.ts

@@ -1,4 +1,4 @@
-import type { CoreComputeProvider, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
 interface ClickHouseResultLike {
     json<T>(): Promise<T>;
 }
@@ -9,18 +9,37 @@ export interface ClickHouseClientLike {
         query_params: Readonly<Record<string, unknown>>;
         abort_signal?: AbortSignal;
     }): Promise<ClickHouseResultLike>;
+    /** Native SDK exec does not append a FORMAT clause to commands. */
+    exec?(options: {
+        query: string;
+        query_params: Readonly<Record<string, unknown>>;
+        clickhouse_settings: {
+            readonly default_format: 'JSONEachRow';
+        };
+        abort_signal?: AbortSignal;
+    }): Promise<{
+        readonly stream: AsyncIterable<string | Buffer>;
+    }>;
     close(): Promise<void>;
 }
 export interface ClickHouseProviderOptions {
+    /** Full HTTP endpoint. Takes precedence over host and port. */
     readonly url?: string;
+    /** Host-style connection fields accepted by the shared datasource contract. */
+    readonly host?: string;
+    readonly port?: number;
     readonly username?: string;
+    /** Alias used by the shared datasource contract. username takes precedence. */
+    readonly user?: string;
     readonly password?: string;
     readonly database?: string;
     readonly client?: ClickHouseClientLike;
 }
 export declare class ClickHouseProvider implements CoreComputeProvider {
+    #private;
     readonly kind: "clickhouse";
-    private readonly client;
+    readonly supportsRecursiveCte = true;
+    readonly recursiveCteUnion: "UNION ALL";
     constructor(options?: ClickHouseProviderOptions);
     quoteIdentifier(identifier: string): string;
     tableAlias(expression: string, alias: string): string;
@@ -28,10 +47,15 @@ export declare class ClickHouseProvider implements CoreComputeProvider {
     parameter(index: number, value: unknown): string;
     displayQuery(sql: string, parameters: readonly unknown[]): string;
     dateBucket(expression: string, level: string): string;
+    datePart(expression: string, part: DatePart): string;
     dateShift(expression: string, granularity: string, offset: number): string;
+    castValue(expression: string, type: string): string;
+    scalarExtremum(operator: 'least' | 'greatest', expressions: readonly string[]): string;
     aggregateFunction(name: string, expression?: string): string;
+    stringify(expression: string): string;
     concat(expressions: readonly string[]): string;
     substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
     regex(expression: string, pattern: string, options?: string): string;
     arrayContains(arrayExpression: string, valueExpression: string): string;
     expandArray(arrayExpression: string, alias: string, column: string): {
@@ -39,6 +63,9 @@ export declare class ClickHouseProvider implements CoreComputeProvider {
         valueExpression: string;
     };
     execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    getTableList(request: TableListRequest): Promise<DatabaseTable[]>;
+    describeTable(request: DescribeTableRequest): Promise<TableDescription>;
+    runSQL(request: ProviderExecutionRequest): Promise<SQLResult>;
     close(): Promise<void>;
 }
 export {};

package/dist/physical/connection-registry.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseConnection, ProviderRegistry } from './connection';
+import type { CoreComputeProvider } from './provider';
+type ProviderFactory = (connection: DatabaseConnection) => CoreComputeProvider;
+export declare class ConnectionRegistry {
+    #private;
+    private readonly create;
+    constructor(create?: ProviderFactory);
+    get(connection: DatabaseConnection): CoreComputeProvider;
+    close(): Promise<void>;
+}
+export declare const getConnectionProvider: (connection: DatabaseConnection, providers?: ProviderRegistry) => CoreComputeProvider;
+export declare const closeConnections: () => Promise<void>;
+export {};

package/dist/physical/connection.d.ts

@@ -1,32 +1,74 @@
 import type { CoreComputeProvider } from './provider';
 import type { ClickHouseProviderOptions } from './clickhouse-provider';
-import type { DorisProviderOptions } from './doris-provider';
-import type { MySQLProviderOptions } from './mysql-provider';
-import type { OracleProviderOptions } from './oracle-provider';
-import type { PostgreSQLProviderOptions } from './postgresql-provider';
-import type { SnowflakeProviderOptions } from './snowflake-provider';
-import type { StarRocksProviderOptions } from './starrocks-provider';
-/** Connection information supplied by an application. Provider instances stay internal. */
-export type DatabaseConnection = ({
+import type { DatabricksConnectionOptions } from './databricks-provider';
+import type { DamengConnectionOptions } from './dameng-provider';
+import type { DorisConnectionOptions } from './doris-provider';
+import type { GBaseConnectionOptions } from './gbase-provider';
+import type { MaxComputeConnectionOptions } from './maxcompute-provider';
+import type { MySQLConnectionOptions } from './mysql-provider';
+import type { OracleConnectionOptions } from './oracle-provider';
+import type { PostgreSQLConnectionOptions } from './postgresql-provider';
+import type { SnowflakeConnectionOptions } from './snowflake-provider';
+import type { SQLServerConnectionOptions } from './sqlserver-provider';
+import type { StarRocksConnectionOptions } from './starrocks-provider';
+export interface DatabaseConnectionBase {
+    readonly id: string;
+    readonly kind: string;
+}
+/** Module-augmentation seam for application-owned connection kinds. */
+export interface DatabaseConnectionExtensions {
+}
+export type BuiltinDatabaseConnection = ({
     readonly id: string;
     readonly kind: 'mysql';
-} & NonNullable<MySQLProviderOptions['connection']>) | ({
+} & MySQLConnectionOptions) | ({
     readonly id: string;
     readonly kind: 'doris';
-} & NonNullable<DorisProviderOptions['connection']>) | ({
+} & DorisConnectionOptions) | ({
+    readonly id: string;
+    readonly kind: 'gbase';
+} & GBaseConnectionOptions) | ({
     readonly id: string;
     readonly kind: 'starrocks';
-} & NonNullable<StarRocksProviderOptions['connection']>) | ({
+} & StarRocksConnectionOptions) | ({
+    readonly id: string;
+    readonly kind: 'maxcompute';
+} & MaxComputeConnectionOptions) | ({
     readonly id: string;
     readonly kind: 'postgresql';
-} & NonNullable<PostgreSQLProviderOptions['connection']>) | ({
+} & PostgreSQLConnectionOptions) | ({
     readonly id: string;
     readonly kind: 'clickhouse';
 } & Omit<ClickHouseProviderOptions, 'client'>) | ({
+    readonly id: string;
+    readonly kind: 'databricks';
+} & DatabricksConnectionOptions) | ({
+    readonly id: string;
+    readonly kind: 'dameng';
+} & DamengConnectionOptions) | ({
     readonly id: string;
     readonly kind: 'snowflake';
-} & NonNullable<SnowflakeProviderOptions['connection']>) | ({
+} & SnowflakeConnectionOptions) | ({
+    readonly id: string;
+    readonly kind: 'sqlserver';
+} & SQLServerConnectionOptions) | ({
     readonly id: string;
     readonly kind: 'oracle';
-} & NonNullable<OracleProviderOptions['connection']>);
-export declare const createProvider: (connection: DatabaseConnection) => CoreComputeProvider;
+} & OracleConnectionOptions);
+type ExtendedDatabaseConnection = DatabaseConnectionExtensions[keyof DatabaseConnectionExtensions];
+export type DatabaseConnection = BuiltinDatabaseConnection | ExtendedDatabaseConnection;
+export interface ProviderDefinition<Connection extends DatabaseConnectionBase = DatabaseConnectionBase> {
+    readonly kind: Connection['kind'];
+    readonly create: (connection: Connection) => CoreComputeProvider;
+}
+export declare const builtinProviderDefinitions: readonly ProviderDefinition[];
+export declare class ProviderRegistry {
+    #private;
+    constructor(definitions?: readonly ProviderDefinition[]);
+    register<Connection extends DatabaseConnectionBase>(definition: ProviderDefinition<Connection>): this;
+    create(connection: DatabaseConnectionBase): CoreComputeProvider;
+    has(kind: string): boolean;
+}
+export declare const defaultProviderRegistry: ProviderRegistry;
+export declare const createProvider: (connection: DatabaseConnection, providers?: ProviderRegistry) => CoreComputeProvider;
+export {};

package/dist/physical/dameng-provider.d.ts

@@ -0,0 +1,66 @@
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
+type DamengBind = string | number | Date | Buffer | null;
+export interface DamengConnectionOptions {
+    readonly connectString?: string;
+    readonly host?: string;
+    readonly port?: number;
+    readonly user?: string;
+    readonly password?: string;
+    readonly schema?: string;
+    readonly poolMin?: number;
+    readonly poolMax?: number;
+    readonly poolTimeout?: number;
+    readonly [option: string]: unknown;
+}
+export interface DamengConnectionLike {
+    execute(sql: string, binds: DamengBind[], options: {
+        readonly outFormat: number;
+        readonly autoCommit?: boolean;
+    }): Promise<{
+        readonly rows?: unknown[];
+        readonly rowsAffected?: number;
+    }>;
+    close(): Promise<void>;
+}
+export interface DamengPoolLike {
+    getConnection(): Promise<DamengConnectionLike>;
+    close(drainTime?: number): Promise<void>;
+}
+export interface DamengDriverLike {
+    createPool(options: DamengPoolOptions): Promise<DamengPoolLike>;
+}
+export interface DamengPoolOptions extends Omit<DamengConnectionOptions, 'host' | 'port'> {
+    readonly connectString: string;
+}
+export interface DamengProviderOptions {
+    readonly connection?: DamengConnectionOptions;
+    readonly pool?: DamengPoolLike;
+    readonly driver?: DamengDriverLike;
+}
+export declare const damengPoolOptions: (options: DamengConnectionOptions) => DamengPoolOptions;
+export declare class DamengProvider implements CoreComputeProvider {
+    #private;
+    readonly kind: "dameng";
+    readonly supportsHavingAlias = false;
+    constructor(options?: DamengProviderOptions);
+    quoteIdentifier(identifier: string): string;
+    tableAlias(expression: string, alias: string): string;
+    paginate(sql: string, pageSize: number, offset: number): string;
+    parameter(index: number, value: unknown): string;
+    displayQuery(sql: string, parameters: readonly unknown[]): string;
+    dateBucket(expression: string, level: string): string;
+    datePart(expression: string, part: DatePart): string;
+    dateShift(expression: string, granularity: string, offset: number): string;
+    aggregateFunction(name: string, expression?: string): string;
+    stringify(expression: string): string;
+    concat(expressions: readonly string[]): string;
+    substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
+    regex(expression: string, pattern: string, options?: string): string;
+    execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    runSQL(request: ProviderExecutionRequest): Promise<SQLResult>;
+    getTableList(request: TableListRequest): Promise<DatabaseTable[]>;
+    describeTable(request: DescribeTableRequest): Promise<TableDescription>;
+    close(): Promise<void>;
+}
+export {};

package/dist/physical/databricks-provider.d.ts

@@ -0,0 +1,88 @@
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
+type DatabricksBind = string | number | boolean | bigint | Date | null;
+export interface DatabricksConnectionBase {
+    readonly host: string;
+    readonly path: string;
+    readonly catalog?: string;
+    readonly schema?: string;
+    /** Legacy datasource field for the default schema. */
+    readonly database?: string;
+}
+export interface DatabricksAccessTokenAuth {
+    readonly authType: 'access-token';
+    readonly token: string;
+    readonly oauthClientId?: never;
+    readonly oauthClientSecret?: never;
+    readonly azureTenantId?: never;
+    readonly useDatabricksOAuthInAzure?: never;
+    readonly oauthScopes?: never;
+}
+export interface DatabricksOAuthAuth {
+    readonly authType: 'databricks-oauth';
+    readonly oauthClientId: string;
+    readonly oauthClientSecret: string;
+    readonly token?: never;
+    readonly azureTenantId?: string;
+    readonly useDatabricksOAuthInAzure?: boolean;
+    readonly oauthScopes?: readonly string[];
+}
+export type DatabricksConnectionOptions = DatabricksConnectionBase & (DatabricksAccessTokenAuth | DatabricksOAuthAuth);
+export interface DatabricksOperationLike {
+    fetchAll(): Promise<unknown>;
+    /** The native SDK can finish commands that have no result set to fetch. */
+    finished?(): Promise<void>;
+    cancel(): Promise<unknown>;
+    close(): Promise<unknown>;
+}
+export interface DatabricksSessionLike {
+    executeStatement(sql: string, options: {
+        readonly ordinalParameters: DatabricksBind[];
+    }): Promise<DatabricksOperationLike>;
+    close(): Promise<unknown>;
+}
+export interface DatabricksClientLike {
+    connect(options: object): Promise<unknown>;
+    openSession(options: {
+        readonly initialCatalog?: string;
+        readonly initialSchema?: string;
+    }): Promise<DatabricksSessionLike>;
+    close(): Promise<void>;
+}
+export interface DatabricksProviderOptions {
+    readonly connection?: DatabricksConnectionOptions;
+    readonly client?: DatabricksClientLike;
+}
+export declare const databricksConnectOptions: (input: unknown) => object;
+export declare class DatabricksProvider implements CoreComputeProvider {
+    #private;
+    readonly kind: "databricks";
+    readonly supportsHavingAlias = false;
+    readonly supportsRecursiveCte = true;
+    constructor(options?: DatabricksProviderOptions);
+    quoteIdentifier(identifier: string): string;
+    tableAlias(expression: string, alias: string): string;
+    paginate(sql: string, pageSize: number, offset: number): string;
+    parameter(index: number, value: unknown): string;
+    displayQuery(sql: string, parameters: readonly unknown[]): string;
+    dateBucket(expression: string, level: string): string;
+    datePart(expression: string, part: DatePart): string;
+    dateShift(expression: string, granularity: string, offset: number): string;
+    castValue(expression: string, type: string): string;
+    aggregateFunction(name: string, expression?: string): string;
+    stringify(expression: string): string;
+    concat(expressions: readonly string[]): string;
+    substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
+    regex(expression: string, pattern: string, options?: string): string;
+    arrayContains(arrayExpression: string, valueExpression: string): string;
+    expandArray(arrayExpression: string, alias: string, column: string): {
+        joinSql: string;
+        valueExpression: string;
+    };
+    execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    runSQL(request: ProviderExecutionRequest): Promise<SQLResult>;
+    describeTable(request: DescribeTableRequest): Promise<TableDescription>;
+    getTableList(request: TableListRequest): Promise<DatabaseTable[]>;
+    close(): Promise<void>;
+}
+export {};

package/dist/physical/db-connector.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseConnection, ProviderRegistry } from './connection';
+import type { DatabaseTable, SQLResult, SqlParameters, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
+export interface DBConnectorOptions {
+    /** Exactly the same connection object accepted by Logicform.execute.connections. */
+    readonly connection: DatabaseConnection;
+    readonly providerRegistry?: ProviderRegistry;
+    readonly signal?: AbortSignal;
+}
+export interface RunSQLOptions extends DBConnectorOptions {
+    readonly sql: string;
+    readonly parameters?: SqlParameters;
+}
+export interface GetTableListOptions extends DBConnectorOptions, TableListRequest {
+}
+export interface DescribeTableOptions extends DBConnectorOptions, DescribeTableRequest {
+}
+/** Trusted physical operations; no LogicForm permissions, rewriting, or caching. */
+export declare const DBConnector: Readonly<{
+    runSQL: (options: RunSQLOptions) => Promise<SQLResult>;
+    getTableList: (options: GetTableListOptions) => Promise<DatabaseTable[]>;
+    describeTable: (options: DescribeTableOptions) => Promise<TableDescription>;
+    close: () => Promise<void>;
+}>;

package/dist/physical/display-query.d.ts

@@ -1,4 +1,7 @@
 export declare const displayClickHouseQuery: (sql: string, parameters: readonly unknown[]) => string;
 export declare const displayOracleQuery: (sql: string, parameters: readonly unknown[]) => string;
 export declare const displayPostgreSQLQuery: (sql: string, parameters: readonly unknown[]) => string;
+export declare const displayMySQLQuery: (sql: string, parameters: readonly unknown[]) => string;
 export declare const displayQuestionMarkQuery: (sql: string, parameters: readonly unknown[]) => string;
+export declare const displayDamengQuery: (sql: string, parameters: readonly unknown[]) => string;
+export declare const displaySQLServerQuery: (sql: string, parameters: readonly unknown[]) => string;

package/dist/physical/doris-provider.d.ts

@@ -1,9 +1,15 @@
 import { MySQLProtocolProvider } from './mysql-protocol-provider';
-import type { MySQLProtocolPoolLike, MySQLProtocolProviderOptions } from './mysql-protocol-provider';
+import type { MySQLProtocolPoolLike, MySQLProtocolConnectionOptions, MySQLProtocolProviderOptions } from './mysql-protocol-provider';
 export type DorisPoolLike = MySQLProtocolPoolLike;
+export type DorisConnectionOptions = MySQLProtocolConnectionOptions;
 export type DorisProviderOptions = MySQLProtocolProviderOptions;
 /** Doris adapter using its MySQL-compatible protocol and SQL surface. */
 export declare class DorisProvider extends MySQLProtocolProvider {
     readonly kind: "doris";
     constructor(options?: DorisProviderOptions);
+    arrayContains(arrayExpression: string, valueExpression: string): string;
+    expandArray(arrayExpression: string, alias: string, column: string): {
+        readonly joinSql: string;
+        readonly valueExpression: string;
+    };
 }

package/dist/physical/duckdb-coordinator-provider.d.ts

@@ -0,0 +1,37 @@
+import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest } from './provider';
+export type DuckDBCoordinatorColumnKind = 'boolean' | 'date' | 'number' | 'string';
+export interface DuckDBCoordinatorColumn {
+    readonly name: string;
+    readonly kind: DuckDBCoordinatorColumnKind;
+}
+/** In-process SQL engine used only to combine results from separate physical connections. */
+export declare class DuckDBCoordinatorProvider implements CoreComputeProvider {
+    private readonly instance;
+    private readonly connection;
+    readonly kind: "duckdb";
+    readonly supportsHavingAlias = true;
+    readonly supportsRecursiveCte = true;
+    static create(): Promise<DuckDBCoordinatorProvider>;
+    private constructor();
+    quoteIdentifier(identifier: string): string;
+    tableAlias(expression: string, alias: string): string;
+    paginate(sql: string, pageSize: number, offset: number): string;
+    parameter(index: number, value: unknown): string;
+    displayQuery(sql: string, parameters: readonly unknown[]): string;
+    dateBucket(expression: string, level: string): string;
+    datePart(expression: string, part: DatePart): string;
+    dateShift(expression: string, granularity: string, offset: number): string;
+    datePeriodBoundary(expression: string, granularity: string, boundary: 'start' | 'end'): string;
+    castValue(expression: string, type: string): string;
+    scalarExtremum(operator: 'least' | 'greatest', expressions: readonly string[]): string;
+    aggregateFunction(name: string, expression?: string): string;
+    stringify(expression: string): string;
+    concat(expressions: readonly string[]): string;
+    substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
+    regex(expression: string, pattern: string, options?: string): string;
+    arrayContains(arrayExpression: string, valueExpression: string): string;
+    materialize(tableName: string, inputColumns: readonly DuckDBCoordinatorColumn[], rows: readonly DataRow[]): Promise<void>;
+    execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    close(): Promise<void>;
+}

package/dist/physical/gbase-provider.d.ts

@@ -0,0 +1,11 @@
+import { MySQLProtocolProvider } from './mysql-protocol-provider';
+import type { MySQLProtocolConnectionOptions, MySQLProtocolPoolLike, MySQLProtocolProviderOptions } from './mysql-protocol-provider';
+export type GBasePoolLike = MySQLProtocolPoolLike;
+export type GBaseConnectionOptions = MySQLProtocolConnectionOptions;
+export type GBaseProviderOptions = MySQLProtocolProviderOptions;
+/** GBase 8a adapter using its MySQL-compatible protocol and SQL surface. */
+export declare class GBaseProvider extends MySQLProtocolProvider {
+    readonly kind: "gbase";
+    readonly supportsRecursiveCte = false;
+    constructor(options?: GBaseProviderOptions);
+}

package/dist/physical/index.d.ts

@@ -1,18 +1,33 @@
 /** Internal physical adapters selected from the public database connection configuration. */
-export type { CoreComputeProvider, DataRow, ProviderExecutionRequest, SqlRenderCapabilities, SqlParameters, } from './provider';
-export { createProvider } from './connection';
-export type { DatabaseConnection } from './connection';
+export type { CoreComputeProvider, DatePart, DataRow, DatabaseTable, SQLResult, TableListRequest, DescribeTableRequest, DatabaseColumn, TableDescription, ProviderExecutionRequest, ProviderKind, ProviderKindExtensions, SqlRenderCapabilities, SqlParameters, } from './provider';
+export { ConnectionRegistry, getConnectionProvider, closeConnections } from './connection-registry';
+export { DBConnector } from './db-connector';
+export type { DBConnectorOptions, RunSQLOptions, GetTableListOptions, DescribeTableOptions } from './db-connector';
+export { builtinProviderDefinitions, createProvider, defaultProviderRegistry, ProviderRegistry, } from './connection';
+export type { BuiltinDatabaseConnection, DatabaseConnection, DatabaseConnectionBase, DatabaseConnectionExtensions, ProviderDefinition, } from './connection';
+export { DuckDBCoordinatorProvider } from './duckdb-coordinator-provider';
+export type { DuckDBCoordinatorColumn, DuckDBCoordinatorColumnKind, } from './duckdb-coordinator-provider';
 export { ClickHouseProvider, } from './clickhouse-provider';
 export type { ClickHouseClientLike, ClickHouseProviderOptions, } from './clickhouse-provider';
+export { DatabricksProvider } from './databricks-provider';
+export type { DatabricksClientLike, DatabricksConnectionBase, DatabricksConnectionOptions, DatabricksAccessTokenAuth, DatabricksOAuthAuth, DatabricksProviderOptions, DatabricksSessionLike, DatabricksOperationLike, } from './databricks-provider';
+export { DamengProvider } from './dameng-provider';
+export type { DamengConnectionLike, DamengConnectionOptions, DamengDriverLike, DamengPoolLike, DamengPoolOptions, DamengProviderOptions, } from './dameng-provider';
 export { DorisProvider } from './doris-provider';
-export type { DorisPoolLike, DorisProviderOptions } from './doris-provider';
+export type { DorisConnectionOptions, DorisPoolLike, DorisProviderOptions } from './doris-provider';
+export { GBaseProvider } from './gbase-provider';
+export type { GBaseConnectionOptions, GBasePoolLike, GBaseProviderOptions } from './gbase-provider';
+export { MaxComputeProvider } from './maxcompute-provider';
+export type { MaxComputeClientLike, MaxComputeConnectionOptions, MaxComputeProviderOptions, } from './maxcompute-provider';
 export { MySQLProvider } from './mysql-provider';
-export type { MySQLPoolLike, MySQLProviderOptions } from './mysql-provider';
+export type { MySQLConnectionOptions, MySQLPoolLike, MySQLProviderOptions } from './mysql-provider';
 export { OracleProvider } from './oracle-provider';
-export type { OracleConnectionLike, OracleDriverLike, OraclePoolLike, OracleProviderOptions, } from './oracle-provider';
+export type { OracleConnectionLike, OracleConnectionOptions, OracleDriverLike, OraclePoolLike, OracleProviderOptions, } from './oracle-provider';
 export { PostgreSQLProvider } from './postgresql-provider';
-export type { PostgreSQLPoolLike, PostgreSQLProviderOptions, } from './postgresql-provider';
+export type { PostgreSQLPoolLike, PostgreSQLConnectionOptions, PostgreSQLProviderOptions, } from './postgresql-provider';
 export { SnowflakeProvider } from './snowflake-provider';
-export type { SnowflakeConnectionLike, SnowflakeProviderOptions, SnowflakeStatementLike, } from './snowflake-provider';
+export type { SnowflakeConnectionLike, SnowflakeConnectionOptions, SnowflakeProviderOptions, SnowflakeStatementLike, } from './snowflake-provider';
+export { SQLServerProvider, sqlServerPoolOptions } from './sqlserver-provider';
+export type { SQLServerConnectionOptions, SQLServerDriverLike, SQLServerPoolLike, SQLServerProviderOptions, SQLServerRequestLike, } from './sqlserver-provider';
 export { StarRocksProvider } from './starrocks-provider';
-export type { StarRocksPoolLike, StarRocksProviderOptions, } from './starrocks-provider';
+export type { StarRocksPoolLike, StarRocksConnectionOptions, StarRocksProviderOptions, } from './starrocks-provider';

package/dist/physical/load-driver.d.ts

@@ -0,0 +1 @@
+export declare const driverLoadError: (packageName: string, cause: unknown) => Error;

package/dist/physical/maxcompute-provider.d.ts

@@ -0,0 +1,44 @@
+import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest, SqlParameters, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
+/**
+ * Parameterized MaxCompute execution boundary supplied by the application.
+ * Implementations must bind `parameters`; they must not interpolate them into `sql`.
+ */
+export interface MaxComputeClientLike {
+    execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    /** Optional command metadata and project/schema-aware discovery extensions. */
+    runSQL?(request: ProviderExecutionRequest): Promise<SQLResult>;
+    getTableList?(request: TableListRequest): Promise<DatabaseTable[]>;
+    describeTable?(request: DescribeTableRequest): Promise<TableDescription>;
+    close(): Promise<void>;
+}
+export interface MaxComputeConnectionOptions {
+    readonly client: MaxComputeClientLike;
+}
+export type MaxComputeProviderOptions = MaxComputeConnectionOptions;
+/** MaxCompute SQL dialect backed by a caller-owned parameterized execution client. */
+export declare class MaxComputeProvider implements CoreComputeProvider {
+    #private;
+    readonly kind: "maxcompute";
+    readonly supportsRecursiveCte = false;
+    constructor(options: MaxComputeProviderOptions);
+    quoteIdentifier(identifier: string): string;
+    tableAlias(expression: string, alias: string): string;
+    paginate(sql: string, pageSize: number, offset: number): string;
+    parameter(index: number, value: unknown): string;
+    displayQuery(sql: string, parameters: SqlParameters): string;
+    dateBucket(expression: string, level: string): string;
+    datePart(expression: string, part: DatePart): string;
+    dateShift(expression: string, granularity: string, offset: number): string;
+    datePeriodBoundary(expression: string, granularity: string, boundary: 'start' | 'end'): string;
+    aggregateFunction(name: string, expression?: string): string;
+    stringify(expression: string): string;
+    concat(expressions: readonly string[]): string;
+    substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
+    regex(expression: string, pattern: string, options?: string): string;
+    execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    runSQL(request: ProviderExecutionRequest): Promise<SQLResult>;
+    getTableList(request: TableListRequest): Promise<DatabaseTable[]>;
+    close(): Promise<void>;
+    describeTable(request: DescribeTableRequest): Promise<TableDescription>;
+}

package/dist/physical/mysql-protocol-provider.d.ts

@@ -1,17 +1,30 @@
-import type { PoolOptions } from 'mysql2/promise';
-import type { CoreComputeProvider, DataRow, ProviderExecutionRequest, SqlParameters } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SqlParameters, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
 export interface MySQLProtocolPoolLike {
     execute(sql: string, values: readonly unknown[]): Promise<readonly [unknown, unknown]>;
     end(): Promise<void>;
 }
+export interface MySQLProtocolConnectionOptions {
+    readonly host?: string;
+    readonly port?: number;
+    readonly user?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly connectionLimit?: number;
+    readonly maxIdle?: number;
+    readonly idleTimeout?: number;
+    readonly enableKeepAlive?: boolean;
+    readonly keepAliveInitialDelay?: number;
+    readonly decimalNumbers?: boolean;
+    readonly [option: string]: unknown;
+}
 export interface MySQLProtocolProviderOptions {
-    readonly connection?: PoolOptions;
+    readonly connection?: object;
     readonly pool?: MySQLProtocolPoolLike;
 }
 export declare abstract class MySQLProtocolProvider implements CoreComputeProvider {
-    readonly supportsRecursiveCte = true;
-    abstract readonly kind: 'doris' | 'mysql' | 'starrocks';
-    private readonly pool;
+    #private;
+    readonly supportsRecursiveCte: boolean;
+    abstract readonly kind: 'doris' | 'gbase' | 'maxcompute' | 'mysql' | 'starrocks';
     protected constructor(options?: MySQLProtocolProviderOptions);
     quoteIdentifier(identifier: string): string;
     tableAlias(expression: string, alias: string): string;
@@ -19,16 +32,23 @@ export declare abstract class MySQLProtocolProvider implements CoreComputeProvid
     parameter(index: number, value: unknown): string;
     displayQuery(sql: string, parameters: SqlParameters): string;
     dateBucket(expression: string, level: string): string;
+    datePart(expression: string, part: DatePart): string;
     dateShift(expression: string, granularity: string, offset: number): string;
+    datePeriodBoundary(expression: string, granularity: string, boundary: 'start' | 'end'): string;
     aggregateFunction(name: string, expression?: string): string;
+    stringify(expression: string): string;
     concat(expressions: readonly string[]): string;
     substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
     regex(expression: string, pattern: string, options?: string): string;
     arrayContains(arrayExpression: string, valueExpression: string): string;
-    expandArray(arrayExpression: string, alias: string, column: string): {
+    expandArray(arrayExpression: string, alias: string, column: string, elementType?: 'string'): {
         readonly joinSql: string;
         readonly valueExpression: string;
     };
     execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    runSQL(request: ProviderExecutionRequest): Promise<SQLResult>;
+    getTableList(request: TableListRequest): Promise<DatabaseTable[]>;
+    describeTable(request: DescribeTableRequest): Promise<TableDescription>;
     close(): Promise<void>;
 }

package/dist/physical/mysql-provider.d.ts

@@ -1,6 +1,7 @@
 import { MySQLProtocolProvider } from './mysql-protocol-provider';
-import type { MySQLProtocolPoolLike, MySQLProtocolProviderOptions } from './mysql-protocol-provider';
+import type { MySQLProtocolPoolLike, MySQLProtocolConnectionOptions, MySQLProtocolProviderOptions } from './mysql-protocol-provider';
 export type MySQLPoolLike = MySQLProtocolPoolLike;
+export type MySQLConnectionOptions = MySQLProtocolConnectionOptions;
 export type MySQLProviderOptions = MySQLProtocolProviderOptions;
 export declare class MySQLProvider extends MySQLProtocolProvider {
     readonly kind: "mysql";