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

package/dist/executor/execute.d.ts

@@ -1,4 +1,4 @@
-import type { LogicformType } from '../logicform-types';
+import { type LogicformType } from '../logicform-types';
 import type { ExecuteOptions, ExecuteResult, ExecuteSuccessResult, InternalExecuteOptions } from './types';
 export declare const executeWithProvider: (inputLogicform: LogicformType, inputOptions: InternalExecuteOptions) => Promise<ExecuteSuccessResult>;
 export declare const execute: (inputLogicform: LogicformType, inputOptions: ExecuteOptions) => Promise<ExecuteResult>;

package/dist/executor/federated-execution.d.ts

@@ -4,11 +4,12 @@ import type { OperatorRegistry } from '../operators/index';
 import type { CoreComputeProvider, DataRow } from '../physical/index';
 import type { LogicalPlan } from '../planner/index';
 import type { SchemaMappingRegistry } from '../schema-mappings/index';
-import type { SqlExecutionSourceReporter } from './execute-query';
+import type { PhysicalQuerySource, SqlExecutionSourceReporter } from './execute-query';
 import type { InternalExecuteOptions } from './types';
 export declare const coordinatorConnectionId = "__semanticdb_coordinator__";
 export interface FederatedCompiledQuery {
     readonly compiled: CompiledQuery;
+    readonly sources: readonly PhysicalQuerySource[];
     readonly connectionId: string;
     readonly provider: CoreComputeProvider;
     readonly type: 'computation' | 'total';

package/dist/executor/fetch-entities.d.ts

@@ -9,7 +9,7 @@ import type { Permissions } from '../permissions/index';
 import type { ResolvedSemanticSchema, SemanticTypeRegistry } from '../semantic-types/index';
 import type { EntityFetchRequest } from './result-hydrator/index';
 import type { SemanticDBPlugin } from '../plugins/index';
-import type { SqlExecutionSourceReporter } from './execute-query';
+import type { PhysicalQuerySource, SqlExecutionSourceReporter } from './execute-query';
 import type { LocaleRegistry } from '../i18n/index';
 interface FetchEntityOptions {
     readonly version: string;
@@ -26,7 +26,7 @@ interface FetchEntityOptions {
     readonly preferredConnectionId?: string;
     readonly cache?: QueryCacheExecutionOptions;
     readonly signal?: AbortSignal;
-    readonly onCompiled?: (compiled: CompiledQuery, logicform: LogicformType, provider: CoreComputeProvider, connectionId?: string) => SqlExecutionSourceReporter | undefined;
+    readonly onCompiled?: (compiled: CompiledQuery, logicform: LogicformType, provider: CoreComputeProvider, connectionId: string | undefined, sources: readonly PhysicalQuerySource[]) => SqlExecutionSourceReporter | undefined;
 }
 export declare const fetchEntities: (request: EntityFetchRequest, options: FetchEntityOptions) => Promise<DataRow[]>;
 export {};

package/dist/executor/index.d.ts

@@ -1,3 +1,3 @@
 export { execute } from './execute';
 export { closeConnections } from './connection-registry';
-export type { ExecuteOptions, ExecuteFailureResult, ExecuteProgressEvent, ExecuteResult, ExecuteSuccessResult, ExecutedSql, ExecutedSqlType, SqlExecutionSource, PartialExecuteResult, ProgressCallback, } from './types';
+export type { ExecuteOptions, ExecuteFailureResult, ExecuteProgressEvent, ExecuteResult, ExecuteSuccessResult, ExecutedSql, ExecutedSqlSchemaMapping, ExecutedSqlType, SqlExecutionSource, PartialExecuteResult, ProgressCallback, } from './types';

package/dist/executor/partition.d.ts

@@ -0,0 +1,17 @@
+import type { LogicformType, QueryType } from '../logicform-types';
+import type { OperatorRegistry } from '../operators/index';
+import type { CreateLogicalPlanOptions, LogicalPlan } from '../planner/index';
+import type { SchemaMappingRegistry } from '../schema-mappings/index';
+import type { LogicformPartitionShard, ResolvedSemanticSchema } from '../semantic-types/index';
+/** Intersect range filters so the grain checker sees the effective shard boundary. */
+export declare const partitionQuery: (original: QueryType | undefined, additional: QueryType) => QueryType;
+export declare const validatePartitionShards: (schema: ResolvedSemanticSchema, shards: readonly LogicformPartitionShard[], mappings: SchemaMappingRegistry) => void;
+export interface PartitionedPlans {
+    readonly current: LogicalPlan;
+    readonly comparison?: LogicalPlan;
+    readonly mappingIds: readonly string[];
+}
+export declare const createPartitionedPlans: (logicform: LogicformType, schema: ResolvedSemanticSchema, shards: readonly LogicformPartitionShard[], operators: OperatorRegistry, mappings: SchemaMappingRegistry, options: CreateLogicalPlanOptions, comparison?: {
+    readonly logicform: LogicformType;
+    readonly queryForCurrentShard: (query: QueryType) => QueryType;
+}) => PartitionedPlans;

package/dist/executor/types.d.ts

@@ -2,7 +2,7 @@ import type { OperatorDefinition, OperatorExecutionContext, OperatorRegistry } f
 import type { CoreComputeProvider, DataRow, ProviderRegistry, SqlParameters } from '../physical/index';
 import type { DatabaseConnection } from '../physical/index';
 import type { LogicalPlan, QueryLineage } from '../planner/index';
-import type { SchemaMappingDefinition, SchemaMappingRegistry, SchemaMappingSelection } from '../schema-mappings/index';
+import type { SchemaMappingDefinition, SchemaMappingRegistry } from '../schema-mappings/index';
 import type { ResolvedSemanticSchema, SemanticSchemaDraft, SemanticTypeRegistry, TimeWatermarkPolicy } from '../semantic-types/index';
 import type { LogicformType, PublicLogicformType } from '../logicform-types';
 import type { QueryCacheConfiguration, QueryCacheExecutionOptions } from '../cache/index';
@@ -91,6 +91,10 @@ export interface ExecuteOptions extends ExecuteBaseOptions {
 }
 /** Internal execution seam used by executor tests after a provider has been resolved. */
 export interface InternalExecuteOptions extends Omit<ExecuteBaseOptions, 'operators'> {
+    /** Schema hooks already active in an internal execution, for recursion detection. */
+    readonly partitionStack?: readonly string[];
+    /** A pinned internal execution does not repartition this Schema. */
+    readonly partitionDisabledSchemaIds?: readonly string[];
     readonly operators?: OperatorRegistry;
     /** The public execution boundary has already merged built-in, plugin, and explicit Operators. */
     readonly operatorsResolved?: boolean;
@@ -117,14 +121,6 @@ export interface ExecuteSuccessResult {
     readonly normedLogicform: PublicLogicformType;
     readonly sqls: readonly ExecutedSql[];
     readonly lineage: QueryLineage;
-    readonly provider: CoreComputeProvider['kind'];
-    /** Physical connections that contributed rows to this result. */
-    readonly providers: readonly {
-        readonly connectionId: string;
-        readonly provider: CoreComputeProvider['kind'];
-    }[];
-    /** Physical mapping decisions, including why every non-selected candidate lost. */
-    readonly schemaMappingSelections: readonly SchemaMappingSelection[];
     /** Plugin-owned materialization for a custom LogicForm output type. */
     readonly output?: unknown;
 }
@@ -135,12 +131,18 @@ export interface ExecuteFailureResult {
     readonly schema?: ResolvedSemanticSchema;
     readonly normedLogicform: PublicLogicformType;
     readonly sqls: readonly ExecutedSql[];
-    readonly provider?: CoreComputeProvider['kind'];
     readonly lineage?: QueryLineage;
 }
 export type ExecuteResult = ExecuteSuccessResult | ExecuteFailureResult;
 export type ExecutedSqlType = 'computation' | 'semantic-resolution' | 'total';
 export type SqlExecutionSource = 'cache' | 'database';
+export interface ExecutedSqlSchemaMapping {
+    readonly schemaId: string;
+    /** Schema Mapping id, or its source when no explicit id was configured. */
+    readonly mappingId: string;
+    readonly connectionId: string;
+    readonly source: string;
+}
 export interface ExecutedSql {
     /** Why this SQL participates in the LogicForm execution. */
     readonly type: ExecutedSqlType;
@@ -151,6 +153,8 @@ export interface ExecutedSql {
     readonly explain: string;
     /** Normalized LogicForm represented by this SQL statement. */
     readonly logicform: PublicLogicformType;
+    /** Physical Schema Mappings read directly by this SQL; empty for coordinator or materialized-row SQL. */
+    readonly schemaMappings: readonly ExecutedSqlSchemaMapping[];
     /** Parameterized SQL used for provider execution and cache identity. */
     readonly sql: string;
     readonly parameters: SqlParameters;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export { getLogicformPropertyReferences, isDimensionInLogicform } from './logicform/index';
+export type { LogicformPropertyReference } from './logicform/index';
 export { createLocaleRegistry, defaultLocaleRegistry, LocaleRegistry, enUS, zhCN, } from './i18n/index';
 export type { LocaleDefinition, LocaleInput, LocaleTranslate } from './i18n/index';
 export declare const Logicform: Readonly<{
@@ -8,7 +10,7 @@ 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, 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 { SchemaMappingRegistry, fromYiAskSchemaMapping, getSupportedDimensions, } from './schema-mappings/index';
 export type { AbsoluteDateValue, CompareOperator, DatePartQueryComparison, DatePartQueryOperand, 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 type { PrimalType, PropertyHierarchyDefinition, PropertySqlDefinition, ResolvedSemanticProperty, ResolvedSemanticSchema, SemanticTypeNormalizeContext, SemanticPropertyDraft, SemanticSchemaDraft, SemanticTypeDefinition, SemanticTypeResultContext, SemanticTypeResultProperty, TimeGranularity, TimeWatermarkPolicy, } from './semantic-types/index';
@@ -19,7 +21,7 @@ export type { OperatorDefinition, OperatorDefaultNameContext, OperatorExecutionC
 export type { SchemaMappingDefinition, SchemaMappingEnrichmentDefinition, SchemaMappingEnrichmentKey, SchemaMappingItem, SchemaMappingGranularity, SchemaMappingGranularityExtensions, SchemaMappingPointTemporalDefinition, SchemaMappingPredDefinition, SchemaMappingPredMatch, SchemaMappingSelection, RejectedSchemaMapping, SourceFreshnessPolicy, YiAskSchemaMappingItem, YiAskSchemaMappingRecord, } from './schema-mappings/index';
 export { QueryCacheManager } from './cache/index';
 export type { InvalidateQueryCacheSourceOptions, QueryCacheConfiguration, } from './cache/index';
-export type { ExecuteOptions, ExecuteFailureResult, ExecuteProgressEvent, ExecuteResult, ExecuteSuccessResult, ExecutedSql, ExecutedSqlType, SqlExecutionSource, PartialExecuteResult, ProgressCallback, } from './executor/index';
+export type { ExecuteOptions, ExecuteFailureResult, ExecuteProgressEvent, ExecuteResult, ExecuteSuccessResult, ExecutedSql, ExecutedSqlSchemaMapping, ExecutedSqlType, SqlExecutionSource, PartialExecuteResult, ProgressCallback, } from './executor/index';
 export type { ColumnPermissions, Permissions, SchemaPermissions, } from './permissions/index';
 export type { CreateLogicalPlanOptions, LogicalPlan, QueryLineage, } from './planner/index';
 export { PlannerSemanticRegistry, createPlannerSemanticRegistry, } from './planner/index';

package/dist/logicform/dimensions.d.ts

@@ -0,0 +1,16 @@
+import type { LogicformType } from '../logicform-types';
+export interface LogicformPropertyReference {
+    readonly reference: string;
+    readonly use: 'query' | 'pred' | 'groupby';
+}
+/** Property references in this v2 LogicForm node, retaining their use site. */
+export declare const getLogicformPropertyReferences: (logicform: LogicformType) => readonly LogicformPropertyReference[];
+/**
+ * Whether this v2 LogicForm node uses an exact property path in its query,
+ * PredItems, or groupby. A related-property filter such as
+ * `产品: { schema: 'product', query: { 品类: 'PA' } }` uses `产品_品类`,
+ * not the `产品` entity itself. A `from` or full query subquery has its own
+ * field scope and is not traversed. Normalize first when comparing property
+ * names with IDs or aliases.
+ */
+export declare const isDimensionInLogicform: (logicform: LogicformType, dimension: string) => boolean;

package/dist/logicform/index.d.ts

@@ -0,0 +1,2 @@
+export { getLogicformPropertyReferences, isDimensionInLogicform } from './dimensions';
+export type { LogicformPropertyReference } from './dimensions';

package/dist/normalizer/core.d.ts

@@ -25,7 +25,7 @@ export interface NormalizeLogicformOptions {
     }>;
     /** Internal root query used to resolve automatic `$case` boundaries. */
     readonly autoCaseQuery?: LogicformType['query'];
-    readonly resolveFromSchema?: (normalizedFrom: LogicformType, outerSchema: ResolvedSemanticSchema) => ResolvedSemanticSchema;
+    readonly resolveFromSchema?: (normalizedFrom: LogicformType, outerSchema: ResolvedSemanticSchema) => ResolvedSemanticSchema | Promise<ResolvedSemanticSchema>;
     readonly canProjectProperty?: (schema: ResolvedSemanticSchema, property: ResolvedSemanticProperty) => boolean;
     /** Internal recursion hook installed by normalizeLogicform. */
     readonly normalizeNestedLogicform?: (logicform: LogicformType) => Promise<LogicformType>;

package/dist/operators/types.d.ts

@@ -1,5 +1,5 @@
 import type { PrimalType, ResolvedSemanticProperty, ResolvedSemanticSchema, TimeGranularity, ComparableCategoryDefinition } from '../semantic-types/index';
-import type { LogicformType, PredItemType } from '../logicform-types';
+import type { LogicformType, PredItemType, QueryType } from '../logicform-types';
 import type { DataRow } from '../physical/index';
 import type { Expression, LogicalPlan } from '../planner/index';
 import type { LocaleTranslate } from '../i18n/index';
@@ -205,6 +205,10 @@ export interface OperatorQueryComponent {
     readonly mapResult?: (rows: readonly DataRow[]) => DataRow[];
     /** SQL-side transformations that align this component's group keys with the base component. */
     readonly groupKeyShifts?: readonly OperatorGroupKeyShift[];
+    /** Shift an already partitioned current query into this comparison period. */
+    readonly partitionQuery?: (currentShardQuery: QueryType) => QueryType;
+    /** Unshifted metric used to choose the same Mapping for a standalone comparison. */
+    readonly partitionCurrentLogicform?: LogicformType;
 }
 export interface OperatorComponentQuery {
     /** Final result-column name for this child component. */
@@ -213,6 +217,9 @@ export interface OperatorComponentQuery {
     readonly prepare?: boolean;
     readonly mapResult?: (rows: readonly DataRow[]) => DataRow[];
     readonly groupKeyShifts?: readonly OperatorGroupKeyShift[];
+    /** Name of the current-period component whose selected Mapping this query inherits. */
+    readonly comparisonOf?: string;
+    readonly partitionQuery?: (currentShardQuery: QueryType) => QueryType;
     /**
      * Group output names used to join this component back to the first component.
      * When omitted, the compiler joins on the groupby outputs shared by both components.

package/dist/planner/build-mapping-source-plan.d.ts

@@ -0,0 +1,6 @@
+import type { SemanticDBPlugin } from '../plugins/index';
+import type { SchemaMappingDefinition } from '../schema-mappings/index';
+import type { ResolvedSemanticSchema } from '../semantic-types/index';
+import type { LogicalPlan } from './types';
+/** Materialize physical Mapping outputs before evaluating Schema UDFs. */
+export declare const buildMappingSourcePlan: (schema: ResolvedSemanticSchema, mapping: SchemaMappingDefinition, plugins?: readonly SemanticDBPlugin[]) => LogicalPlan;

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

@@ -10,6 +10,10 @@ 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 {
+    /** Normalized nested LogicForms whose asynchronous partition plans were prepared by the executor. */
+    readonly preplannedPartitions?: ReadonlyMap<string, LogicalPlan>;
+    /** Restrict the root physical Schema to one candidate during partition planning. */
+    readonly mappingCandidates?: readonly string[];
     readonly plugins?: readonly SemanticDBPlugin[];
     readonly resolveSchema?: (schemaId: string) => ResolvedSemanticSchema;
     /** Prefer physical mappings colocated with the execution's main connection. */

package/dist/planner/select-schema-mapping.d.ts

@@ -16,10 +16,13 @@ export interface SelectedSchemaMapping {
 export interface MappedPropertySource {
     readonly column: string;
     readonly sourceRef?: string;
+    readonly sql?: string;
 }
+export declare const hasPropertySql: (mapping: SchemaMappingDefinition) => boolean;
 export declare const mappedPropertyColumn: (mapping: SchemaMappingDefinition, schema: ResolvedSemanticSchema, reference: string) => string | undefined;
 export declare const mappedPropertySource: (mapping: SchemaMappingDefinition, schema: ResolvedSemanticSchema, reference: string) => MappedPropertySource | undefined;
 export declare const selectSchemaMapping: (logicform: LogicformType, schema: ResolvedSemanticSchema, mappings: SchemaMappingRegistry, options?: {
+    readonly mappingCandidates?: readonly string[];
     readonly preferredConnectionId?: string;
     readonly resolveSchema?: (schemaId: string) => ResolvedSemanticSchema;
     /** Extra plugins used by this execution; must also be supplied when registering plugin grains. */

package/dist/planner/types.d.ts

@@ -128,6 +128,8 @@ export interface JoinPlan {
     readonly targetConnectionId?: string;
     readonly targetSource: string;
     readonly targetSourceSql?: string;
+    /** Two projection layers for the target Schema Mapping and its UDFs. */
+    readonly targetMappingSourcePlan?: LogicalPlan;
     readonly targetAlias: string;
     readonly targetColumn: string;
     readonly targetSql?: string;
@@ -226,10 +228,20 @@ export interface LogicalPlan {
     readonly connectionId?: string;
     /** Trusted derived-table SQL supplied by the selected physical mapping. */
     readonly sourceSql?: string;
+    /** Two projection layers for the physical Mapping and Schema UDFs. */
+    readonly mappingSourcePlan?: LogicalPlan;
     /** Physical mapping selected by the Planner for this logical Schema. */
     readonly mappingId?: string;
     /** Child relations combined by their compatible group identity. */
     readonly subplans?: readonly LogicalPlan[];
+    /** Vertically combine disjoint aggregate shards by summing matching output groups. */
+    readonly sumPartition?: true;
+    /** Enumerated group values corresponding to subplans, combined vertically. */
+    readonly splitGroup?: {
+        readonly name: string;
+        readonly values: readonly string[];
+        readonly groupNames: readonly string[];
+    };
     /** Optional query plan compiled as the derived-table source of this plan. */
     readonly sourcePlan?: LogicalPlan;
     /** Normalized LogicForm corresponding to sourcePlan when generated rewrites need execution. */

package/dist/schema-mappings/index.d.ts

@@ -1,4 +1,5 @@
 export { SchemaMappingRegistry } from './registry';
+export { getSupportedDimensions } from './supported-dimensions';
 export { parseDailyExpireAt } from './freshness';
 export { isMappingTimeGranularity, isSchemaMappingGranularity, } from './granularity';
 export type { SchemaMappingDefinition, SchemaMappingEnrichmentDefinition, SchemaMappingEnrichmentKey, SchemaMappingItem, SchemaMappingGranularity, SchemaMappingGranularityExtensions, SchemaMappingPointTemporalDefinition, SchemaMappingSelection, RejectedSchemaMapping, SourceFreshnessPolicy, } from './types';

package/dist/schema-mappings/registry.d.ts

@@ -7,6 +7,7 @@ export declare class SchemaMappingRegistry {
     register(definition: SchemaMappingDefinition): this;
     get(schemaId: string, connectionId?: string): SchemaMappingDefinition;
     list(schemaId: string): readonly SchemaMappingDefinition[];
+    findById(schemaId: string, mappingId: string): SchemaMappingDefinition | undefined;
     definitions(): readonly SchemaMappingDefinition[];
     findSource(schemaId: string, source: string, connectionId?: string): SchemaMappingDefinition | undefined;
 }

package/dist/schema-mappings/supported-dimensions.d.ts

@@ -0,0 +1,10 @@
+import type { SchemaTypeDraft } from 'semanticdb-core';
+import type { SemanticSchemaDraft } from '../semantic-types/index';
+import type { SchemaMappingRegistry } from './registry';
+/**
+ * Dimensions declared by at least one physical Mapping for this Schema.
+ * Returns canonical property-name paths. This is a discoverability union:
+ * metric coverage, time grain, and combinations of dimensions still require
+ * planning a concrete LogicForm.
+ */
+export declare const getSupportedDimensions: (schemaId: string, schemas: Readonly<Record<string, SemanticSchemaDraft | SchemaTypeDraft>>, schemaMappings: SchemaMappingRegistry) => readonly string[];

package/dist/schema-mappings/types.d.ts

@@ -18,7 +18,8 @@ export type SourceFreshnessPolicy = {
 export interface SchemaMappingPredMatch {
     /** Defaults to the owning mapping's Schema. */
     readonly schema?: string;
-    readonly operator: string;
+    /** Restricts the match to one operator. Missing matches any aggregate operator. */
+    readonly operator?: string;
     readonly pred: string;
     /** Required conjunctive conditions across the LogicForm and PredItem queries. */
     readonly query?: QueryType;
@@ -30,9 +31,12 @@ export interface SchemaMappingPredDefinition {
 }
 export interface SchemaMappingItem {
     readonly sourceColumn?: string;
+    /** Trusted physical SQL expression, evaluated before the Schema Property's udf.sql. */
+    readonly propertySql?: string;
     /** Enrichment id that owns sourceColumn. Missing means the mapping's base source. */
     readonly sourceRef?: string;
     readonly mappingType?: 'property' | 'predItem' | 'ignored';
+    /** Direct targets for a property item; one property path (ID/name segments) for a predItem. */
     readonly propertyTarget?: readonly string[];
     readonly predItem?: PredItemType;
     /** Finest physical grain of a mapped Property. */
@@ -81,6 +85,8 @@ export interface SchemaMappingDefinition {
 export interface RejectedSchemaMapping {
     readonly mappingId: string;
     readonly reason: string;
+    /** Dimension Properties required by the query but unavailable on this Mapping. */
+    readonly missingDimensions?: readonly string[];
 }
 /** Planner diagnostics for one physical Schema mapping decision. */
 export interface SchemaMappingSelection {

package/dist/schema-mappings/yiask.d.ts

@@ -3,6 +3,7 @@ import type { PredItemType } from '../logicform-types';
 import type { SchemaMappingDefinition, SchemaMappingEnrichmentDefinition, SchemaMappingGranularity } from './types';
 export interface YiAskSchemaMappingItem {
     readonly sourceColumn?: string;
+    readonly propertySql?: string;
     readonly sourceRef?: string;
     readonly mappingType?: 'property' | 'predItem' | 'ignored';
     readonly propertyTarget?: readonly string[];

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

@@ -5,7 +5,7 @@ export { SemanticTypeRegistry } from './registry';
 export { resolveSchema } from './resolve-schema';
 export { validateResolvedSchema } from './validate-resolved-schema';
 export { normalizePrimalQuery } from './primal-types/index';
-export type { ComparableCategoryDefinition, PropertyHierarchyDefinition, PropertySqlDefinition, PrimalType, ResolvedSemanticProperty, ResolvedSemanticSchema, LegacySemanticSchemaMetadata, ResolvedSemanticSchemaMetadata, SemanticSchemaMetadata, SemanticTypeNormalizeContext, SemanticPeriodEvaluationContext, SemanticTypeResultContext, SemanticTypeResultProperty, SemanticPropertyDraft, SemanticSchemaDraft, SemanticTypeDefinition, TimeGranularity, TimeWatermarkPolicy, } from './types';
+export type { ComparableCategoryDefinition, PropertyHierarchyDefinition, PropertySqlDefinition, LogicformPartition, LogicformPartitionContext, LogicformPartitionShard, PrimalType, ResolvedSemanticProperty, ResolvedSemanticSchema, LegacySemanticSchemaMetadata, ResolvedSemanticSchemaMetadata, SemanticSchemaMetadata, SemanticTypeNormalizeContext, SemanticPeriodEvaluationContext, SemanticTypeResultContext, SemanticTypeResultProperty, SemanticPropertyDraft, SemanticSchemaDraft, SemanticTypeDefinition, TimeGranularity, TimeWatermarkPolicy, } from './types';
 export declare const createSemanticTypeRegistry: (plugins?: readonly SemanticDBPlugin[]) => SemanticTypeRegistry;
 /** Copies a caller-owned Registry and appends plugin types without mutating the input. */
 export declare const addPluginSemanticTypes: (registry: SemanticTypeRegistry, plugins: readonly SemanticDBPlugin[]) => SemanticTypeRegistry;

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

@@ -1,5 +1,6 @@
 import type { PropertyTypeDraft, SchemaTypeDraft } from 'semanticdb-core';
-import type { LogicformType, PredItemType } from '../logicform-types';
+import type dayjs from 'dayjs';
+import type { LogicformType, PredItemType, QueryType } from '../logicform-types';
 /** Canonical primitive types use `entity`; `object` remains a legacy input alias. */
 export type PrimalType = 'string' | 'number' | 'boolean' | 'date' | 'entity' | 'object';
 export type TimeGranularity = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
@@ -21,6 +22,31 @@ export interface PropertyHierarchyDefinition {
     readonly up?: string;
     readonly down?: string;
 }
+/** One additive query slice. Candidates are tried in order and must cover the slice. */
+export interface LogicformPartitionShard {
+    readonly query: QueryType;
+    readonly mappingCandidates: readonly string[];
+}
+export interface LogicformPartitionContext {
+    readonly dayjs: typeof dayjs;
+    /** Alias for dayjs; this does not provide the Moment.js API. */
+    readonly moment: typeof dayjs;
+    readonly schemas: Readonly<Record<string, ResolvedSemanticSchema>>;
+    readonly schemaMappings: readonly {
+        readonly id?: string;
+        readonly schemaId: string;
+        readonly priority?: number;
+    }[];
+    /** Runs within the same execution context. A pinned mapping bypasses its Schema partition hook. */
+    readonly execute: (logicform: LogicformType, options?: {
+        readonly mappingId?: string;
+    }) => Promise<{
+        readonly result: readonly Readonly<Record<string, unknown>>[];
+    }>;
+}
+export type LogicformPartition = (logicform: LogicformType, context: LogicformPartitionContext) => Promise<{
+    readonly shards: readonly LogicformPartitionShard[];
+}>;
 /** Extension point for plugin-owned Schema draft metadata. */
 export interface SemanticSchemaMetadata {
 }
@@ -52,12 +78,14 @@ export interface SemanticSchemaDraft extends Omit<SchemaTypeDraft, '_id' | 'id'
     readonly id: string;
     /** Marks the single Schema whose complete rows are loaded as calendar execution context. */
     readonly is_calendar?: boolean;
+    readonly partition?: LogicformPartition;
     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 partition?: LogicformPartition;
     readonly properties: readonly ResolvedSemanticProperty[];
 }
 export interface SemanticTypeNormalizeContext {