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

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

@@ -1,10 +1,14 @@
-import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest, SqlParameters } from './provider';
+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 {
@@ -33,5 +37,8 @@ export declare class MaxComputeProvider implements CoreComputeProvider {
     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,4 +1,4 @@
-import type { CoreComputeProvider, DatePart, 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>;
@@ -47,5 +47,8 @@ export declare abstract class MySQLProtocolProvider implements CoreComputeProvid
         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/oracle-provider.d.ts

@@ -1,10 +1,12 @@
-import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
 type OracleBind = string | number | boolean | Date | Buffer | null;
 export interface OracleConnectionLike {
     execute(sql: string, binds: OracleBind[], options: {
         readonly outFormat: number;
+        readonly autoCommit?: boolean;
     }): Promise<{
         readonly rows?: unknown[] | undefined;
+        readonly rowsAffected?: number | undefined;
     }>;
     break(): Promise<void>;
     close(): Promise<void>;
@@ -60,6 +62,9 @@ export declare class OracleProvider implements CoreComputeProvider {
         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>;
 }
 export {};

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

@@ -1,7 +1,9 @@
-import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
 export interface PostgreSQLPoolLike {
     query(sql: string, values: unknown[]): Promise<{
         readonly rows: unknown;
+        readonly rowCount?: number | null;
+        readonly command?: string;
     }>;
     end(): Promise<void>;
 }
@@ -48,5 +50,8 @@ export declare class PostgreSQLProvider 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>;
 }

package/dist/physical/provider.d.ts

@@ -10,6 +10,46 @@ export interface ProviderExecutionRequest {
     readonly parameters: SqlParameters;
     readonly signal?: AbortSignal;
 }
+/** Native SQL results, without semantic hydration or generated row identities. */
+export interface SQLResult {
+    readonly rows: DataRow[];
+    /** Omitted when the driver does not report an affected-row count. */
+    readonly affectedRows?: number;
+}
+export interface DatabaseTable {
+    readonly name: string;
+    readonly database?: string;
+    readonly schema?: string;
+    readonly type: 'table' | 'view';
+}
+export interface TableListRequest {
+    /** Database/catalog override; unsupported scopes are rejected, not ignored. */
+    readonly database?: string;
+    readonly schema?: string;
+    readonly signal?: AbortSignal;
+}
+export interface DescribeTableRequest extends TableListRequest {
+    /** Literal, unqualified physical table name; use database/schema for its namespace. */
+    readonly table: string;
+    /** Read one example row by default. Disable to inspect metadata only. */
+    readonly includeSample?: boolean;
+}
+export interface DatabaseColumn {
+    readonly name: string;
+    /** Native database type, including size/precision where available. */
+    readonly type: string;
+    readonly comment: string;
+    /** Omitted if the database/adapter cannot report primary-key membership. */
+    readonly primaryKey?: boolean;
+    /** Omitted for empty tables, disabled sampling, or a failed sample query. */
+    readonly exampleValue?: unknown;
+}
+export interface TableDescription {
+    readonly columns: DatabaseColumn[];
+    readonly tableInfo: DatabaseTable & {
+        readonly comment: string;
+    };
+}
 export interface SqlRenderCapabilities {
     /** Whether HAVING may reference an alias declared in the same SELECT list. */
     readonly supportsHavingAlias?: boolean;
@@ -53,5 +93,10 @@ export interface CoreComputeProvider extends SqlRenderCapabilities {
     /** Render bound parameters for diagnostics only; this SQL is never executed by SemanticDB. */
     displayQuery(sql: string, parameters: SqlParameters): string;
     execute(request: ProviderExecutionRequest): Promise<DataRow[]>;
+    /** Optional native-SQL capability; execute retains its row-query contract. */
+    runSQL?(request: ProviderExecutionRequest): Promise<SQLResult>;
+    /** Optional physical metadata capability, independent of semantic Schemas. */
+    getTableList?(request: TableListRequest): Promise<DatabaseTable[]>;
+    describeTable?(request: DescribeTableRequest): Promise<TableDescription>;
     close(): Promise<void>;
 }

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

@@ -1,7 +1,8 @@
-import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DatePart, DataRow, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } from './provider';
 type SnowflakeBind = string | number | boolean | null;
 export interface SnowflakeStatementLike {
     cancel(callback?: (error?: Error) => void): void;
+    getNumUpdatedRows?(): number | undefined;
 }
 export interface SnowflakeConnectionLike {
     connect(callback: (error?: Error) => void): unknown;
@@ -53,6 +54,9 @@ export declare class SnowflakeProvider implements CoreComputeProvider {
         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>;
 }
 export {};

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

@@ -1,9 +1,10 @@
-import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest } from './provider';
+import type { CoreComputeProvider, DataRow, DatePart, ProviderExecutionRequest, SQLResult, DatabaseTable, TableListRequest, DescribeTableRequest, TableDescription } 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;
+        readonly rowsAffected?: readonly number[];
     }>;
     cancel(): void;
 }
@@ -60,6 +61,9 @@ export declare class SQLServerProvider implements CoreComputeProvider {
         readonly valueExpression: string;
     };
     execute(execution: ProviderExecutionRequest): Promise<DataRow[]>;
+    runSQL(execution: ProviderExecutionRequest): Promise<SQLResult>;
+    getTableList(request: TableListRequest): Promise<DatabaseTable[]>;
+    describeTable(request: DescribeTableRequest): Promise<TableDescription>;
     close(): Promise<void>;
 }
 export {};

package/dist/physical/table-description.d.ts

@@ -0,0 +1,5 @@
+import type { CoreComputeProvider, DataRow, DescribeTableRequest, TableDescription } from './provider';
+export declare const validateDescribeTable: (request: DescribeTableRequest) => void;
+/** INFORMATION_SCHEMA/Oracle expose size separately; PostgreSQL/MySQL already format native types. */
+export declare const columnType: (row: DataRow) => string;
+export declare const describePhysicalTable: (provider: CoreComputeProvider, request: DescribeTableRequest) => Promise<TableDescription>;

package/dist/physical/table-discovery.d.ts

@@ -0,0 +1,10 @@
+import type { CoreComputeProvider, DatabaseTable, DataRow, TableListRequest } from './provider';
+export declare const validateTableScope: (request: TableListRequest) => void;
+export declare const rejectTableScope: (provider: CoreComputeProvider, field: "database" | "schema") => never;
+/** Drivers differ in alias casing; never silently discard malformed metadata rows. */
+export declare const metadataValue: (row: DataRow, field: string) => unknown;
+export declare const metadataString: (row: DataRow, field: string) => string;
+export declare const normalizeTableRow: (row: DataRow) => DatabaseTable;
+export declare const normalizeTableMetadata: (rows: DataRow[]) => DatabaseTable[];
+/** Physical metadata SQL only; no semantic Schema resolution belongs here. */
+export declare const discoverTables: (provider: CoreComputeProvider, request: TableListRequest) => Promise<DatabaseTable[]>;

package/dist/planner/semantics/registry.d.ts

@@ -1,13 +1,14 @@
 import type { PredItemType } from '../../logicform-types';
 import type { LogicformType, QueryType } from '../../logicform-types';
 import type { ResolvedSemanticProperty, ResolvedSemanticSchema } from '../../semantic-types/index';
-import type { OperatorDefinition, ResultProperty } from '../../operators/index';
+import type { OperatorDefinition, OperatorExecutionContext, ResultProperty } from '../../operators/index';
 export interface PlannerSemanticRuleContext {
     readonly pred: PredItemType;
     readonly schema: ResolvedSemanticSchema;
     readonly sourceProperty?: ResolvedSemanticProperty;
     readonly outputProperty: ResultProperty;
     readonly operator?: OperatorDefinition;
+    readonly executionContext?: OperatorExecutionContext;
 }
 export interface PlannerSemanticQueryContext {
     readonly logicform: LogicformType;

package/dist/plugins/observation/operator-policy.d.ts

@@ -1,10 +1,10 @@
 import type { PredItemType } from '../../logicform-types';
-import type { OperatorDefinition } from '../../operators/index';
+import type { OperatorDefinition, OperatorExecutionContext } from '../../operators/index';
 declare const periodBoundaryOperator = "$periodValue";
 export interface ObservationOperatorPolicy {
     readonly operator: typeof periodBoundaryOperator;
     readonly boundary: 'start' | 'end';
     readonly implicit: boolean;
 }
-export declare const resolveObservationOperatorPolicy: (pred: Pick<PredItemType, "operator" | "args">, operator?: OperatorDefinition) => ObservationOperatorPolicy;
+export declare const resolveObservationOperatorPolicy: (pred: Pick<PredItemType, "operator" | "args">, operator?: OperatorDefinition, executionContext?: OperatorExecutionContext) => ObservationOperatorPolicy;
 export {};

package/dist/semantic-types/types.d.ts

@@ -50,11 +50,14 @@ export interface ResolvedSemanticProperty extends Omit<SemanticPropertyDraft, 'i
 export interface SemanticSchemaDraft extends Omit<SchemaTypeDraft, '_id' | 'id' | 'sid' | 'properties' | 'db' | 'from' | 'fromSQL' | 'projections' | keyof SemanticSchemaMetadata | keyof LegacySemanticSchemaMetadata>, SemanticSchemaMetadata {
     readonly [key: string]: unknown;
     readonly id: string;
+    /** Marks the single Schema whose complete rows are loaded as calendar execution context. */
+    readonly is_calendar?: boolean;
     readonly properties: readonly SemanticPropertyDraft[];
 }
 export interface ResolvedSemanticSchema extends Omit<SchemaTypeDraft, '_id' | 'id' | 'sid' | 'properties' | 'db' | 'from' | 'fromSQL' | 'projections' | keyof SemanticSchemaMetadata | keyof LegacySemanticSchemaMetadata>, ResolvedSemanticSchemaMetadata {
     readonly [key: string]: unknown;
     readonly id: string;
+    readonly is_calendar?: boolean;
     readonly properties: readonly ResolvedSemanticProperty[];
 }
 export interface SemanticTypeNormalizeContext {