semanticdb-v2 2.0.0-alpha.4 → 2.0.0-alpha.6

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

@@ -0,0 +1,83 @@
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } 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>;
+    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[]>;
+    close(): Promise<void>;
+}
+export {};

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,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 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 {

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,30 @@
 /** 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, ProviderExecutionRequest, ProviderKind, ProviderKindExtensions, SqlRenderCapabilities, SqlParameters, } from './provider';
+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,37 @@
+import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest, SqlParameters } 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[]>;
+    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[]>;
+    close(): Promise<void>;
+}

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 } 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,12 +32,14 @@ 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): {

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";

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

@@ -1,5 +1,4 @@
-import type { PoolAttributes } from 'oracledb';
-import type { CoreComputeProvider, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } from './provider';
 type OracleBind = string | number | boolean | Date | Buffer | null;
 export interface OracleConnectionLike {
     execute(sql: string, binds: OracleBind[], options: {
@@ -14,12 +13,22 @@ export interface OraclePoolLike {
     getConnection(): Promise<OracleConnectionLike>;
     close(drainTime?: number): Promise<void>;
 }
+export interface OracleConnectionOptions {
+    readonly user?: string;
+    readonly password?: string;
+    readonly connectString?: string;
+    readonly poolMin?: number;
+    readonly poolMax?: number;
+    readonly poolIncrement?: number;
+    readonly poolTimeout?: number;
+    readonly [option: string]: unknown;
+}
 export interface OracleDriverLike {
-    createPool(options: PoolAttributes): Promise<OraclePoolLike>;
+    createPool(options: OracleConnectionOptions): Promise<OraclePoolLike>;
 }
 export interface OracleProviderOptions {
     /** Passed to oracledb.createPool(). Thin mode is used unless the caller initialized Thick mode. */
-    readonly connection?: PoolAttributes;
+    readonly connection?: object;
     /** Injectable pool for applications that own pool creation or for tests. */
     readonly pool?: OraclePoolLike;
     /** Injectable driver factory used to test lazy pool creation. */
@@ -37,11 +46,13 @@ export declare class OracleProvider 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;
     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): {

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

@@ -1,20 +1,32 @@
-import type { PoolConfig } from 'pg';
-import type { CoreComputeProvider, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } from './provider';
 export interface PostgreSQLPoolLike {
     query(sql: string, values: unknown[]): Promise<{
         readonly rows: unknown;
     }>;
     end(): Promise<void>;
 }
+export interface PostgreSQLConnectionOptions {
+    readonly connectionString?: string;
+    readonly host?: string;
+    readonly port?: number;
+    readonly user?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly ssl?: unknown;
+    readonly max?: number;
+    readonly idleTimeoutMillis?: number;
+    readonly connectionTimeoutMillis?: number;
+    readonly [option: string]: unknown;
+}
 export interface PostgreSQLProviderOptions {
-    readonly connection?: PoolConfig;
+    readonly connection?: object;
     readonly pool?: PostgreSQLPoolLike;
 }
 export declare class PostgreSQLProvider implements CoreComputeProvider {
+    #private;
     readonly kind: "postgresql";
     readonly supportsHavingAlias = false;
     readonly supportsRecursiveCte = true;
-    private readonly pool;
     constructor(options?: PostgreSQLProviderOptions);
     quoteIdentifier(identifier: string): string;
     tableAlias(expression: string, alias: string): string;
@@ -22,11 +34,13 @@ export declare class PostgreSQLProvider 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;
     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): {

package/dist/physical/provider.d.ts

@@ -1,5 +1,10 @@
 export type DataRow = Record<string, unknown>;
 export type SqlParameters = readonly unknown[];
+export type DatePart = 'second' | 'minute' | 'hour' | 'weekday' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+/** Module-augmentation seam for application-owned Provider kinds. */
+export interface ProviderKindExtensions {
+}
+export type ProviderKind = 'clickhouse' | 'databricks' | 'dameng' | 'doris' | 'duckdb' | 'gbase' | 'maxcompute' | 'mysql' | 'oracle' | 'postgresql' | 'snowflake' | 'sqlserver' | 'starrocks' | Extract<keyof ProviderKindExtensions, string>;
 export interface ProviderExecutionRequest {
     readonly sql: string;
     readonly parameters: SqlParameters;
@@ -12,15 +17,25 @@ export interface SqlRenderCapabilities {
     tableAlias(expression: string, alias: string): string;
     paginate(sql: string, pageSize: number, offset: number): string;
     dateBucket(expression: string, level: string): string;
+    /** Extract a numeric date component. weekday uses Monday=1 through Sunday=7. */
+    datePart(expression: string, part: DatePart): string;
     dateShift(expression: string, granularity: string, offset: number): string;
     datePeriodBoundary?(expression: string, granularity: string, boundary: 'start' | 'end'): string;
+    /** Cast a bound literal to the semantic type required by the SQL expression. */
+    castValue?(expression: string, type: string): string;
+    /** Render a NULL-ignoring scalar extremum without a correlated subquery. */
+    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;
+    /** Return the number of characters in a string expression. */
+    stringLength(expression: string): string;
     regex(expression: string, pattern: string, options?: string): string;
     /** Whether the dialect supports a WITH RECURSIVE subquery. */
     readonly supportsRecursiveCte?: boolean;
+    /** Recursive-term set operator. Defaults to UNION when omitted. */
+    readonly recursiveCteUnion?: 'UNION' | 'UNION ALL';
     arrayContains?(arrayExpression: string, valueExpression: string): string;
     expandArray?(arrayExpression: string, alias: string, column: string): {
         readonly joinSql: string;
@@ -31,7 +46,7 @@ export interface SqlRenderCapabilities {
  * Internal physical database contract used by the compiler and executor.
  */
 export interface CoreComputeProvider extends SqlRenderCapabilities {
-    readonly kind: 'clickhouse' | 'doris' | 'mysql' | 'oracle' | 'postgresql' | 'snowflake' | 'starrocks';
+    readonly kind: ProviderKind;
     /** Maximum items accepted by one SQL IN expression, when the dialect has a limit. */
     readonly maxInListItems?: number;
     parameter(index: number, value: unknown): string;

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

@@ -1,5 +1,4 @@
-import type { ConnectionOptions } from 'snowflake-sdk';
-import type { CoreComputeProvider, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } from './provider';
 type SnowflakeBind = string | number | boolean | null;
 export interface SnowflakeStatementLike {
     cancel(callback?: (error?: Error) => void): void;
@@ -13,9 +12,20 @@ export interface SnowflakeConnectionLike {
     }): SnowflakeStatementLike;
     destroy(callback: (error?: Error) => void): unknown;
 }
+export interface SnowflakeConnectionOptions {
+    readonly account?: string;
+    readonly username?: string;
+    readonly password?: string;
+    readonly warehouse?: string;
+    readonly database?: string;
+    readonly schema?: string;
+    readonly role?: string;
+    readonly authenticator?: string;
+    readonly [option: string]: unknown;
+}
 export interface SnowflakeProviderOptions {
     /** Options passed to snowflake-sdk's createConnection(). */
-    readonly connection?: ConnectionOptions;
+    readonly connection?: object;
     /** Injectable SDK connection used by tests or caller-managed connection factories. */
     readonly client?: SnowflakeConnectionLike;
 }
@@ -29,11 +39,13 @@ export declare class SnowflakeProvider 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;
     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): {

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

@@ -0,0 +1,65 @@
+import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest } from './provider';
+type SQLServerBind = string | number | boolean | Date | Buffer | null;
+export interface SQLServerRequestLike {
+    input(name: string, value: SQLServerBind): this;
+    query(sql: string): Promise<{
+        readonly recordset?: unknown;
+    }>;
+    cancel(): void;
+}
+export interface SQLServerPoolLike {
+    connect(): Promise<unknown>;
+    request(): SQLServerRequestLike;
+    close(): Promise<void>;
+}
+export interface SQLServerDriverLike {
+    readonly ConnectionPool: new (options: object) => SQLServerPoolLike;
+}
+export interface SQLServerConnectionOptions {
+    readonly host?: string;
+    readonly server?: string;
+    readonly port?: number;
+    readonly user?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly options?: Readonly<Record<string, unknown>>;
+    readonly pool?: Readonly<Record<string, unknown>>;
+    readonly requestTimeout?: number;
+    readonly connectionTimeout?: number;
+    readonly [option: string]: unknown;
+}
+export interface SQLServerProviderOptions {
+    readonly connection?: SQLServerConnectionOptions;
+    readonly pool?: SQLServerPoolLike;
+    readonly driver?: SQLServerDriverLike;
+}
+export declare const sqlServerPoolOptions: (connection: SQLServerConnectionOptions) => object;
+export declare class SQLServerProvider implements CoreComputeProvider {
+    #private;
+    readonly kind: "sqlserver";
+    readonly supportsHavingAlias = false;
+    constructor(options?: SQLServerProviderOptions);
+    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): {
+        readonly joinSql: string;
+        readonly valueExpression: string;
+    };
+    execute(execution: ProviderExecutionRequest): Promise<DataRow[]>;
+    close(): Promise<void>;
+}
+export {};

package/dist/physical/starrocks-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 StarRocksPoolLike = MySQLProtocolPoolLike;
+export type StarRocksConnectionOptions = MySQLProtocolConnectionOptions;
 export type StarRocksProviderOptions = MySQLProtocolProviderOptions;
 /** StarRocks adapter using its MySQL-compatible protocol and SQL surface. */
 export declare class StarRocksProvider extends MySQLProtocolProvider {

package/dist/planner/build-lineage.d.ts

@@ -2,4 +2,4 @@ import type { OperatorRegistry } from '../operators/index';
 import type { CoreComputeProvider } from '../physical/index';
 import type { ResolvedSemanticSchema } from '../semantic-types/index';
 import type { LogicalPlan, QueryLineage } from './types';
-export declare const buildLineage: (plan: LogicalPlan, schema: ResolvedSemanticSchema, provider: CoreComputeProvider, operators?: OperatorRegistry) => QueryLineage;
+export declare const buildLineage: (plan: LogicalPlan, schema: ResolvedSemanticSchema, provider: CoreComputeProvider, operators?: OperatorRegistry, providerForConnection?: (connectionId: string) => CoreComputeProvider) => QueryLineage;

package/dist/planner/create-logical-plan.d.ts

@@ -1,6 +1,8 @@
 import type { LogicformType } from '../logicform-types';
 import type { OperatorRegistry } from '../operators/index';
 import { SchemaMappingRegistry } from '../schema-mappings/index';
+import type { SchemaMappingSelection } from '../schema-mappings/index';
+import type { SemanticDBPlugin } from '../plugins/index';
 import type { ResolvedSemanticSchema } from '../semantic-types/index';
 import type { ResolvedSemanticProperty } from '../semantic-types/index';
 import { type PlannerSemanticRegistry } from './semantics/index';
@@ -8,8 +10,13 @@ import type { LogicalPlan } from './types';
 export declare const createResultSchema: (plan: LogicalPlan, sourceSchema: ResolvedSemanticSchema) => ResolvedSemanticSchema;
 export declare const createDerivedSourceSchema: (sourcePlan: LogicalPlan, outerSchema: ResolvedSemanticSchema) => ResolvedSemanticSchema;
 export interface CreateLogicalPlanOptions {
+    readonly plugins?: readonly SemanticDBPlugin[];
     readonly resolveSchema?: (schemaId: string) => ResolvedSemanticSchema;
+    /** Prefer physical mappings colocated with the execution's main connection. */
+    readonly preferredConnectionId?: string;
     readonly canUsePropertyRowIdentity?: (schema: ResolvedSemanticSchema, property: ResolvedSemanticProperty) => boolean;
     readonly semanticRegistry?: PlannerSemanticRegistry;
+    /** Observe each physical Schema mapping decision made during planning. */
+    readonly onSchemaMappingSelection?: (selection: SchemaMappingSelection) => void;
 }
 export declare const createLogicalPlan: (logicform: LogicformType, schema: ResolvedSemanticSchema, operators?: OperatorRegistry, schemaMappings?: SchemaMappingRegistry, options?: CreateLogicalPlanOptions) => LogicalPlan;

package/dist/planner/index.d.ts

@@ -1,7 +1,9 @@
 export { buildLineage } from './build-lineage';
 export { createDerivedSourceSchema, createLogicalPlan, createResultSchema } from './create-logical-plan';
 export type { CreateLogicalPlanOptions } from './create-logical-plan';
-export type { Expression, ArrayExpansionPlan, FieldReferencePlan, GroupLimitPlan, JoinPlan, LogicalQuerySubquery, LogicalRecursiveQuery, LogicalOrdinalQuery, LineageColumnSource, LineageOutput, LogicalPlan, OrderPlan, PaginationPlan, ProjectionPlan, QueryLineage, RowIdentityPlan, } from './types';
-export { isLogicalQuerySubquery, isLogicalRecursiveQuery } from './types';
+export type { Expression, ArrayExpansionPlan, EnrichmentJoinPlan, FieldReferencePlan, GroupLimitPlan, JoinPlan, LogicalQuerySubquery, LogicalQueryOperator, LogicalOrdinalQuery, LogicalExpressionQuery, LineageColumnSource, LineageOutput, LogicalPlan, OrderPlan, PaginationPlan, ProjectionPlan, QueryLineage, RowIdentityPlan, PeriodSourcePlan, TemporalJoinConditionPlan, } from './types';
+export { isLogicalQuerySubquery, isLogicalQueryOperator } from './types';
 export { isLogicalOrdinalQuery } from './types';
+export { isLogicalExpressionQuery } from './types';
 export * from './semantics/index';
+export { createPlannerSemanticRegistry } from './semantics/registry-defaults';

package/dist/planner/mapping-granularity.d.ts

@@ -0,0 +1,7 @@
+import type { LogicformType } from '../logicform-types';
+import type { SemanticDBPlugin } from '../plugins/index';
+import { type OperatorRegistry } from '../operators/index';
+import { type SchemaMappingDefinition } from '../schema-mappings/index';
+import type { ResolvedSemanticSchema } from '../semantic-types/index';
+/** Checks grouped-source Property coverage and delegates plugin-owned physical grains. */
+export declare const mappingGranularityReason: (logicform: LogicformType, schema: ResolvedSemanticSchema, mapping: SchemaMappingDefinition, resolveSchema?: (schemaId: string) => ResolvedSemanticSchema, plugins?: readonly SemanticDBPlugin[], operators?: OperatorRegistry) => string | undefined;

package/dist/planner/rewrite-nested-components.d.ts

@@ -0,0 +1,8 @@
+import type { LogicformType } from '../logicform-types';
+import type { OperatorRegistry } from '../operators/index';
+/**
+ * Lift component inputs into a derived LogicForm so ordinary expression operators can consume
+ * their result columns. The inner LogicForm owns source-grain work; the outer LogicForm owns
+ * result operations and the expression path above every component.
+ */
+export declare const rewriteNestedComponents: (logicform: LogicformType, operators: OperatorRegistry) => LogicformType | undefined;