semanticdb-v2 2.0.0-alpha.5 → 2.0.0-alpha.7

package/dist/index.d.ts

@@ -7,17 +7,19 @@ export declare const Logicform: Readonly<{
 export { SemanticDBError } from './errors';
 export { builtinSemanticTypes, createSemanticTypeRegistry, resolveSchema, SemanticTypeRegistry, validateResolvedSchema, } from './semantic-types/index';
 export { builtinOperators, createOperatorRegistry, OperatorRegistry, resolveOperator, } from './operators/index';
-export type { LegacySchemaPluginContext, SchemaMetadataPlugin, SemanticDBPlugin, } from './plugins/index';
+export type { LegacySchemaPluginContext, MappingGranularityContext, MappingGranularityPlugin, OutputHandlerContext, OutputHandlerDefinition, IntervalSemanticProperties, IntervalSemanticsDefinition, PlannerPeriodDefinition, PlannerPeriodEvaluation, RelationSemanticsDefinition, RelationTemporalPlan, TimeWatermarkLogicformContext, PropertyMetadataPlugin, QueryOperatorCompileContext, QueryOperatorAuthorizeContext, QueryOperatorDefinition, QueryOperatorNormalizeContext, QueryOperatorPhysicalSource, QueryOperatorPlanContext, QueryOperatorPlanResult, SchemaMetadataPlugin, SchemaMappingPlugin, SemanticDBPlugin, } from './plugins/index';
 export { SchemaMappingRegistry, fromYiAskSchemaMapping, } from './schema-mappings/index';
-export type { AbsoluteDateValue, CompareOperator, CalendarDateValue, DateTimeValue, DateValue, EntityIdType, ExpressionItemType, LogicformType, PublicLogicformType, PeriodShiftTime, PredItemType, QueryLogicalOperand, RecursiveQueryType, RelationQueryType, QueryType, QueryValueType, QueryValueTypeWithCompareOperator, RelativeDateValue, RepresentationType, } from './logicform-types';
+export type { AbsoluteDateValue, CompareOperator, DatePartQueryComparison, DatePartQueryOperand, CalendarDateValue, DateTimeValue, DateValue, EntityIdType, ExpressionItemType, LogicformType, NumericQueryComparison, NumericQueryOperand, PublicLogicformType, PeriodShiftTime, PredItemType, QueryLogicalOperand, QueryExpressionType, RelationQueryType, QueryType, QueryValueType, QueryValueTypeWithCompareOperator, RelativeDateValue, RepresentationType, } from './logicform-types';
+export type { RecursiveQueryType } from './plugins/index';
 export { CALENDAR_DATES_TABLE, CALENDAR_RELATIONS_TABLE, CALENDAR_SYSTEM_SCHEMA_IDS, calendarSystemSchemas, ProviderCalendarRelationStore, resolveCalendarPeriod, resolveCalendarPeriodFromStore, selectCalendarDates, } from './calendar/index';
 export type { CalendarAlignment, CalendarComparison, CalendarDateRow, CalendarRelation, CalendarRelationRow, ResolvedCalendarPeriod, } from './calendar/index';
 export type { CalendarRelationStore } from './calendar/index';
-export type { PrimalType, PropertyHierarchyDefinition, PropertySqlDefinition, ResolvedSemanticProperty, ResolvedSemanticSchema, SemanticTypeNormalizeContext, SemanticPropertyDraft, SemanticSchemaDraft, SemanticTypeDefinition, SemanticTypeResultContext, SemanticTypeResultProperty, TemporalSemantics, TimeGranularity, TimeWatermarkPolicy, } from './semantic-types/index';
-export type { HierarchyDefinition, HierarchyLevelDefinition, ResolvedHierarchyDefinition, } from './plugins/hierarchy/index';
-export type { DataRow, SqlParameters, DatabaseConnection, } from './physical/index';
-export type { OperatorDefinition, OperatorDefaultNameContext, OperatorComponentContext, OperatorComponentCalculation, OperatorComponentQuery, OperatorExecutionComponent, OperatorPlanInputContext, OperatorPlannedInput, OperatorGroupKeyShift, OperatorJavaScriptCalculation, OperatorQueryComponent, OperatorEvaluateContext, OperatorOutputPropertyContext, OperatorSqlCapabilities, OperatorSqlContext, ResultProperty, ResultPropertyTemporalMetadata, } from './operators/index';
-export type { SchemaMappingDefinition, SchemaMappingItem, SchemaMappingPredDefinition, SchemaMappingPredMatch, SourceFreshnessPolicy, YiAskSchemaMappingItem, YiAskSchemaMappingRecord, } from './schema-mappings/index';
+export type { PrimalType, PropertyHierarchyDefinition, PropertySqlDefinition, ResolvedSemanticProperty, ResolvedSemanticSchema, SemanticTypeNormalizeContext, SemanticPropertyDraft, SemanticSchemaDraft, SemanticTypeDefinition, SemanticTypeResultContext, SemanticTypeResultProperty, TimeGranularity, TimeWatermarkPolicy, } from './semantic-types/index';
+export type { DataRow, SqlParameters, BuiltinDatabaseConnection, DatabaseConnection, DatabaseConnectionBase, DatabaseConnectionExtensions, ProviderDefinition, ProviderKind, ProviderKindExtensions, } from './physical/index';
+export { DBConnector, ProviderRegistry } from './physical/index';
+export type { DBConnectorOptions, RunSQLOptions, GetTableListOptions, DescribeTableOptions, DescribeTableRequest, DatabaseColumn, TableDescription, DatabaseTable, SQLResult, TableListRequest, } from './physical/index';
+export type { OperatorDefinition, OperatorDefaultNameContext, OperatorComponentContext, OperatorComponentCalculation, OperatorComponentQuery, OperatorExecutionComponent, OperatorPlanInputContext, OperatorPlannedInput, OperatorGroupKeyShift, OperatorJavaScriptCalculation, OperatorQueryComponent, OperatorEvaluateContext, OperatorOutputPropertyContext, OperatorSqlCapabilities, OperatorSqlContext, ResultProperty, ResultPropertyTemporalMetadata, ResultPropertyTemporalMetadataExtensions, } from './operators/index';
+export type { SchemaMappingDefinition, SchemaMappingEnrichmentDefinition, SchemaMappingEnrichmentKey, SchemaMappingItem, SchemaMappingGranularity, SchemaMappingGranularityExtensions, SchemaMappingPointTemporalDefinition, SchemaMappingPredDefinition, SchemaMappingPredMatch, SchemaMappingSelection, RejectedSchemaMapping, SourceFreshnessPolicy, YiAskSchemaMappingItem, YiAskSchemaMappingRecord, } from './schema-mappings/index';
 export type { QueryCache, QueryCacheExecutionOptions, QueryCacheIdentity, QueryCacheWriteOptions, } from './cache/index';
 export type { ExecuteOptions, ExecuteFailureResult, ExecuteProgressEvent, ExecuteResult, ExecuteSuccessResult, ExecutedSql, ExecutedSqlType, PartialExecuteResult, ProgressCallback, } from './executor/index';
 export type { ColumnPermissions, Permissions, SchemaPermissions, } from './permissions/index';

package/dist/logicform-types.d.ts

@@ -36,14 +36,9 @@ export type PeriodShiftTime = RelativeDateValue | AbsoluteDateValue;
 export type DateValue = string | RelativeDateValue | AbsoluteDateValue | CalendarDateValue;
 /** Stable entity identity. Numeric IDs must be safe integers. */
 export type EntityIdType = string | number;
-export type CompareOperator = '$eq' | '$gt' | '$gte' | '$lt' | '$lte' | '$ne' | '$in' | '$nin' | '$exists' | '$regex' | '$contains' | '$recursive' | '$and' | '$or';
-export interface RecursiveQueryType {
-    readonly schema?: string;
-    readonly root?: QueryValueType;
-    readonly roots?: QueryValueType[];
-    readonly includeSelf?: boolean;
-    readonly idProperty?: string;
-    readonly parentProperty?: string;
+export type CompareOperator = '$eq' | '$gt' | '$gte' | '$lt' | '$lte' | '$ne' | '$in' | '$nin' | '$exists' | '$regex' | '$contains' | '$startsWith' | '$length' | '$and' | '$or' | '$second' | '$minute' | '$hour' | '$weekday' | '$day' | '$week' | '$month' | '$quarter' | '$year' | Extract<keyof QueryOperatorExtensions, string>;
+/** Module-augmentation seam for plugin-owned field Query Operators. */
+export interface QueryOperatorExtensions {
 }
 export type QueryValueType = null | string | number | boolean | DateValue | RelationQueryType | LogicformType | string[] | number[] | boolean[] | DateValue[] | RelationQueryType[] | LogicformType[];
 /** A query scoped through an object relation. Version is inherited from the parent LogicForm. */
@@ -55,6 +50,26 @@ export interface RelationQueryType {
     readonly entity_id?: EntityIdType;
 }
 export type QueryLogicalOperand = QueryValueType | QueryValueTypeWithCompareOperator;
+/** Apply a scalar pred expression, then test its result against a condition. */
+export interface QueryExpressionType {
+    readonly pred: PredItemType;
+    readonly condition: QueryLogicalOperand;
+}
+export type NumericQueryOperand = number | number[] | NumericQueryComparison;
+export type NumericQueryComparison = Partial<{
+    $eq: number;
+    $gt: number;
+    $gte: number;
+    $lt: number;
+    $lte: number;
+    $ne: number;
+    $in: number[];
+    $nin: number[];
+    $and: NumericQueryOperand[];
+    $or: NumericQueryOperand[];
+}>;
+export type DatePartQueryOperand = NumericQueryOperand;
+export type DatePartQueryComparison = NumericQueryComparison;
 export type QueryValueTypeWithCompareOperator = Partial<{
     $eq: QueryValueType;
     $gt: QueryValueType;
@@ -67,18 +82,32 @@ export type QueryValueTypeWithCompareOperator = Partial<{
     $exists: QueryValueType;
     $regex: QueryValueType;
     $contains: QueryValueType;
+    $startsWith: string;
+    $length: NumericQueryOperand;
+    $second: DatePartQueryOperand;
+    $minute: DatePartQueryOperand;
+    $hour: DatePartQueryOperand;
+    /** ISO weekday: Monday=1 through Sunday=7. */
+    $weekday: DatePartQueryOperand;
+    /** Day of month. */
+    $day: DatePartQueryOperand;
+    /** ISO week of year. */
+    $week: DatePartQueryOperand;
+    $month: DatePartQueryOperand;
+    $quarter: DatePartQueryOperand;
+    $year: DatePartQueryOperand;
     args?: {
         readonly options?: string;
     };
-    $recursive: QueryValueType | RecursiveQueryType;
     $and: QueryLogicalOperand[];
     $or: QueryLogicalOperand[];
-}> & {
+}> & Partial<QueryOperatorExtensions> & {
     readonly schema?: never;
 };
-export type QueryType = Record<string, QueryValueType | QueryValueTypeWithCompareOperator | QueryType[] | undefined> & {
+export type QueryType = Record<string, QueryValueType | QueryValueTypeWithCompareOperator | QueryExpressionType | QueryType[] | undefined> & {
     readonly $and?: QueryType[];
     readonly $or?: QueryType[];
+    readonly $expr?: QueryExpressionType;
 };
 export interface ExpressionItemType {
     operator?: string;
@@ -92,7 +121,10 @@ export interface PredItemType extends ExpressionItemType {
     pred?: string | PredItemType | (string | PredItemType)[];
     query?: QueryType;
 }
-export type LogicformOutputTypeValue = 'url' | 'data' | 'export' | 'sql' | 'sqlComponents';
+/** Module-augmentation seam for plugin-owned output types. */
+export interface LogicformOutputExtensions {
+}
+export type LogicformOutputTypeValue = 'url' | 'data' | 'export' | 'sql' | 'sqlComponents' | Extract<keyof LogicformOutputExtensions, string>;
 export interface LogicformOutputType {
     type: LogicformOutputTypeValue;
     filename?: string;

package/dist/normalizer/core.d.ts

@@ -16,6 +16,15 @@ export interface NormalizeLogicformOptions {
     readonly now?: Date;
     readonly resolveSchema?: (schemaId: string) => ResolvedSemanticSchema;
     readonly requestTimeWatermark?: (schema: ResolvedSemanticSchema, property: ResolvedSemanticProperty, requestedUpperBound: Date) => Promise<Date | undefined>;
+    readonly requestAutoCaseBounds?: (schema: ResolvedSemanticSchema, reference: string, query: LogicformType['query']) => Promise<{
+        readonly min: number;
+        readonly max: number;
+        readonly count: number;
+    } | {
+        readonly empty: true;
+    }>;
+    /** Internal root query used to resolve automatic `$case` boundaries. */
+    readonly autoCaseQuery?: LogicformType['query'];
     readonly resolveFromSchema?: (normalizedFrom: LogicformType, outerSchema: ResolvedSemanticSchema) => ResolvedSemanticSchema;
     readonly canProjectProperty?: (schema: ResolvedSemanticSchema, property: ResolvedSemanticProperty) => boolean;
     /** Internal recursion hook installed by normalizeLogicform. */

package/dist/normalizer/pred-expression.d.ts

@@ -0,0 +1,6 @@
+import type { LogicformType, PredItemType } from '../logicform-types';
+import type { ResolvedSemanticSchema } from '../semantic-types/index';
+import type { NormalizeLogicformOptions } from './core';
+type NormalizePredQuery = (query: LogicformType['query'], schema: ResolvedSemanticSchema, options: NormalizeLogicformOptions) => Promise<LogicformType['query']>;
+export declare const normalizePredExpression: (pred: PredItemType, schema: ResolvedSemanticSchema, options: NormalizeLogicformOptions, normalizePredQuery: NormalizePredQuery) => Promise<PredItemType>;
+export {};

package/dist/operators/builtins/query-expression.d.ts

@@ -0,0 +1,3 @@
+import type { OperatorDefinition } from '../types';
+export declare const lengthOperator: OperatorDefinition;
+export declare const datePartOperators: readonly OperatorDefinition[];

package/dist/operators/index.d.ts

@@ -3,6 +3,6 @@ import { OperatorRegistry } from './registry';
 export { OperatorRegistry } from './registry';
 export { resolveOperator } from './resolve';
 export { bindTrustedSqlExpression } from './sql-expression';
-export type { OperatorDefinition, OperatorDefaultNameContext, OperatorComponentContext, OperatorComponentCalculation, OperatorComponentQuery, OperatorExecutionComponent, OperatorGroupKeyShift, OperatorJavaScriptCalculation, OperatorQueryComponent, OperatorEvaluateContext, OperatorOutputPropertyContext, OperatorObservationPolicy, OperatorObservationPolicyContext, OperatorNormalizePredContext, OperatorPlanExpressionContext, OperatorPeriodEvaluationContext, OperatorPlanInputContext, OperatorPlannedInput, OperatorRewriteLogicformContext, OperatorValidatePlanContext, OperatorSqlCapabilities, OperatorSqlContext, ResultProperty, ResultPropertyTemporalMetadata, } from './types';
+export type { OperatorDefinition, OperatorDefaultNameContext, OperatorComponentContext, OperatorComponentCalculation, OperatorComponentQuery, OperatorExecutionComponent, OperatorGroupKeyShift, OperatorJavaScriptCalculation, OperatorQueryComponent, OperatorEvaluateContext, OperatorOutputPropertyContext, OperatorPeriodBoundaryPolicy, OperatorPeriodBoundaryPolicyContext, OperatorNormalizePredContext, OperatorPlanExpressionContext, OperatorPeriodEvaluationContext, OperatorPlanInputContext, OperatorPlannedInput, OperatorRewriteLogicformContext, OperatorValidatePlanContext, OperatorSqlCapabilities, OperatorSqlContext, ResultProperty, ResultPropertyTemporalMetadata, ResultPropertyTemporalMetadataExtensions, } from './types';
 export declare const builtinOperators: readonly import("./types").OperatorDefinition[];
 export declare const createOperatorRegistry: (plugins?: readonly SemanticDBPlugin[]) => OperatorRegistry;

package/dist/operators/types.d.ts

@@ -1,7 +1,7 @@
 import type { PrimalType, ResolvedSemanticProperty, ResolvedSemanticSchema, TimeGranularity, ComparableCategoryDefinition } from '../semantic-types/index';
 import type { LogicformType, PredItemType } from '../logicform-types';
 import type { DataRow } from '../physical/index';
-import type { Expression } from '../planner/index';
+import type { Expression, LogicalPlan } from '../planner/index';
 import type { LocaleTranslate } from '../i18n/index';
 export interface OperatorSqlCapabilities {
     /** Produce a dialect-specific aggregate function around an expression. */
@@ -10,6 +10,8 @@ export interface OperatorSqlCapabilities {
     quoteIdentifier(identifier: string): string;
     concat(expressions: readonly string[]): string;
     substring(expression: string, start: number, length: number): string;
+    stringLength(expression: string): string;
+    datePart(expression: string, part: 'second' | 'minute' | 'hour' | 'weekday' | 'day' | 'week' | 'month' | 'quarter' | 'year'): string;
     dateBucket(expression: string, granularity: TimeGranularity): string;
     dateShift(expression: string, granularity: TimeGranularity, offset: number): string;
     /** Render a period boundary directly when the dialect has a concise native form. */
@@ -46,6 +48,8 @@ export interface ResultProperty {
     readonly type: string;
     readonly primal_type: PrimalType;
     readonly isArray: boolean;
+    /** Description inherited from the source Property or supplied by the operator. */
+    readonly description?: string;
     /** Referenced Schema for object-valued result columns. */
     readonly ref?: string;
     readonly granularity?: TimeGranularity;
@@ -53,8 +57,11 @@ export interface ResultProperty {
     /** Runtime temporal semantics for this output column, when applicable. */
     readonly temporal?: ResultPropertyTemporalMetadata;
 }
-export interface ResultPropertyTemporalMetadata {
-    readonly kind: 'period-boundary' | 'period-shift' | 'date-bucket' | 'validity' | 'lifecycle';
+/** Plugin-owned result temporal metadata extends this interface by key. */
+export interface ResultPropertyTemporalMetadataExtensions {
+}
+export type ResultPropertyTemporalMetadata = {
+    readonly kind: 'period-boundary' | 'period-shift' | 'date-bucket';
     readonly boundary?: 'start' | 'end';
     readonly sourceProperty?: string;
     readonly requestedRange?: {
@@ -74,7 +81,7 @@ export interface ResultPropertyTemporalMetadata {
         readonly group: Readonly<Record<string, unknown>>;
         readonly date: string;
     }[];
-}
+} | ResultPropertyTemporalMetadataExtensions[keyof ResultPropertyTemporalMetadataExtensions];
 export interface OperatorOutputPropertyContext {
     /** Final alias assigned to this operator's single output column. */
     readonly name: string;
@@ -135,10 +142,10 @@ export interface OperatorPlanExpressionContext {
     readonly getOperator: (name: string) => OperatorDefinition;
     readonly planQuery: (query: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
 }
-export interface OperatorObservationPolicyContext {
+export interface OperatorPeriodBoundaryPolicyContext {
     readonly pred: PredItemType;
 }
-export interface OperatorObservationPolicy {
+export interface OperatorPeriodBoundaryPolicy {
     readonly boundary: 'start' | 'end';
     readonly implicit: boolean;
 }
@@ -148,6 +155,9 @@ export interface OperatorValidatePlanContext {
     readonly resolveGroupName: (reference: string) => string | undefined;
     readonly getOperator: (name: string) => OperatorDefinition;
 }
+export interface OperatorValidateGroupbyContext {
+    readonly pred: PredItemType;
+}
 export interface OperatorRewriteLogicformContext {
     readonly logicform: LogicformType;
     readonly schema: ResolvedSemanticSchema;
@@ -222,8 +232,23 @@ export type OperatorExecutionComponent = OperatorQueryComponent | OperatorCompon
 interface OperatorDefinitionBase {
     /** Public registry key. Built-in operators commonly use a `$` prefix, but it is not required. */
     readonly name: string;
+    /** Description of the computed metric, exposed on its result Property. */
+    readonly description?: string;
     /** Produce the normalized output name when the PredItem does not declare one. */
     readonly defaultName: (context: OperatorDefaultNameContext) => string;
+    /** Translation key for the generated name. Defaults to `operator.${name}`. */
+    readonly defaultNameKey?: string | ((context: OperatorDefaultNameContext) => string);
+    /** defaultName already used the translator and must not be translated a second time. */
+    readonly defaultNameIsLocalized?: boolean;
+    /** A grouped physical source may safely apply this operator again to stored partial results. */
+    readonly supportsGroupedSourceRollup?: boolean;
+    /** This computed operator preserves a grouped physical source's dimension semantics. */
+    readonly supportsGroupedSourceGroupby?: boolean;
+    /** Requested time grain of a grouped dimension, when this is a time grouping operator. */
+    readonly groupedSourceTimeGranularity?: (context: {
+        readonly pred: PredItemType;
+        readonly property: ResolvedSemanticProperty;
+    }) => TimeGranularity | undefined;
     /** Logical property names read in addition to the direct input property. */
     readonly dependencies?: readonly string[];
     /** Set to false for operators such as `$count` that do not require a property. */
@@ -236,10 +261,16 @@ interface OperatorDefinitionBase {
     readonly normalizePred?: (context: OperatorNormalizePredContext) => PredItemType;
     /** Build a provider-independent expression for operators with custom planning semantics. */
     readonly planExpression?: (context: OperatorPlanExpressionContext) => Expression | undefined;
-    /** Resolve observation temporal semantics for this operator, when applicable. */
-    readonly observationPolicy?: (context: OperatorObservationPolicyContext) => OperatorObservationPolicy | undefined;
+    /** Describe how this operator selects a value at a generated period boundary. */
+    readonly periodBoundaryPolicy?: (context: OperatorPeriodBoundaryPolicyContext) => OperatorPeriodBoundaryPolicy | undefined;
     /** Validate this operator against the completed group key set. */
     readonly validatePlan?: (context: OperatorValidatePlanContext) => void;
+    /** Validate semantics that apply only when this Operator is used as a group key. */
+    readonly validateGroupby?: (context: OperatorValidateGroupbyContext) => void;
+    /** The logical planner may fully lower a component, so no executor child query is needed. */
+    readonly skipComponentExecution?: (context: {
+        readonly plan: LogicalPlan;
+    }) => boolean;
     /** Expand high-level operator semantics into ordinary nested LogicForm objects before planning. */
     readonly rewriteLogicform?: (context: OperatorRewriteLogicformContext) => LogicformType | undefined;
     /** Whether this operator requires one evaluation per time bucket. */

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,6 +9,17 @@ 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 {
@@ -25,8 +36,10 @@ export interface ClickHouseProviderOptions {
     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;
@@ -34,6 +47,7 @@ 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;
@@ -41,6 +55,7 @@ export declare class ClickHouseProvider implements CoreComputeProvider {
     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): {
@@ -48,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;