@malloydata/malloy 0.0.300 → 0.0.301

package/dist/lang/ast/query-items/field-declaration.js

@@ -263,8 +263,13 @@ class FieldDefinitionValue extends space_field_1.SpaceField {
         return this.fieldName;
     }
     fieldDef() {
-        var _a;
-        const def = (_a = this.defInSource) !== null && _a !== void 0 ? _a : this.exprDef.fieldDef(this.space, this.name);
+        var _a, _b;
+        // Checking `defInQuery` is necessary to support a case where a field needs
+        // to be looked up from the output space (ex: in `order_by: a`), but where
+        // the field is defined in a group_by expression (ex: `group_by: a.day`).
+        // In this case, this.exprDef.fieldDef() only ever returns an
+        // AtomicFieldDef anyways, so it is safe in this particular implementation.
+        const def = (_b = (_a = this.defInSource) !== null && _a !== void 0 ? _a : this.defInQuery) !== null && _b !== void 0 ? _b : this.exprDef.fieldDef(this.space, this.name);
         this.defInSource = def;
         return def;
     }

package/dist/lang/ast/statements/define-source.js

@@ -26,6 +26,7 @@ exports.DefineSourceList = exports.DefineSource = void 0;
 const error_factory_1 = require("../error-factory");
 const malloy_element_1 = require("../types/malloy-element");
 const noteable_1 = require("../types/noteable");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
 class DefineSource extends malloy_element_1.MalloyElement {
     constructor(name, sourceExpr, exported, parameters) {
         super();
@@ -44,33 +45,34 @@ class DefineSource extends malloy_element_1.MalloyElement {
         }
     }
     execute(doc) {
-        var _a;
+        var _a, _b, _c;
         if (doc.modelEntry(this.name)) {
             this.logError('source-definition-name-conflict', `Cannot redefine '${this.name}'`);
+            return;
         }
-        else {
-            const theSource = (_a = this.sourceExpr) === null || _a === void 0 ? void 0 : _a.getSource();
-            if (theSource === undefined) {
-                return;
-            }
-            const parameters = this.deduplicatedParameters();
-            const structDef = theSource.withParameters(undefined, this.parameters);
-            this.validateParameterShadowing(parameters, structDef);
-            if (error_factory_1.ErrorFactory.didCreate(structDef)) {
-                return;
-            }
-            const entry = {
-                ...structDef,
-                as: this.name,
-                location: this.location,
-            };
-            if (this.note) {
-                entry.annotation = structDef.annotation
-                    ? { ...this.note, inherits: structDef.annotation }
-                    : this.note;
-            }
-            doc.setEntry(this.name, { entry, exported: this.exported });
+        const theSource = (_a = this.sourceExpr) === null || _a === void 0 ? void 0 : _a.getSource();
+        if (theSource === undefined) {
+            return;
+        }
+        const parameters = this.deduplicatedParameters();
+        const structDef = theSource.withParameters(undefined, this.parameters);
+        this.validateParameterShadowing(parameters, structDef);
+        if (error_factory_1.ErrorFactory.didCreate(structDef)) {
+            return;
+        }
+        const entry = {
+            ...structDef,
+            as: this.name,
+            location: this.location,
+        };
+        if (this.note) {
+            entry.annotation = structDef.annotation
+                ? { ...this.note, inherits: structDef.annotation }
+                : this.note;
         }
+        entry.partitionComposite =
+            (_c = (0, composite_source_utils_1.getPartitionCompositeDesc)(this.note, structDef, (_b = this.sourceExpr) !== null && _b !== void 0 ? _b : this)) !== null && _c !== void 0 ? _c : structDef.partitionComposite;
+        doc.setEntry(this.name, { entry, exported: this.exported });
     }
     deduplicatedParameters() {
         if (this.parameters === undefined)

package/dist/lang/parse-log.d.ts

@@ -384,6 +384,7 @@ type MessageParameterTypes = {
     'grouped-by-not-found': string;
     'non-scalar-grouped-by': string;
     'missing-required-group-by': string;
+    'invalid-partition-composite': string;
 };
 export declare const MESSAGE_FORMATTERS: PartialErrorCodeMessageMap;
 export type MessageCode = keyof MessageParameterTypes;

package/dist/model/composite_source_utils.d.ts

@@ -1,6 +1,6 @@
 import type { BooleanFilter, NumberFilter, StringFilter, TemporalFilter } from '@malloydata/malloy-filter';
 import type { MalloyElement } from '../lang/ast';
-import type { FieldUsage, PipeSegment, SourceDef, Expr, StructDef, RequiredGroupBy } from './malloy_types';
+import type { FieldUsage, PipeSegment, SourceDef, Expr, RequiredGroupBy, Annotation, PartitionCompositeDesc, StructDef } from './malloy_types';
 type CompositeCouldNotFindFieldError = {
     code: 'could_not_find_field';
     data: {
@@ -51,6 +51,7 @@ interface CompositeFailure {
     source: SourceDef;
     issues: CompositeIssue[];
 }
+export declare function getPartitionCompositeDesc(annotation: Annotation | undefined, structDef: StructDef, logTo: MalloyElement): PartitionCompositeDesc | undefined;
 type SingleNarrowedCompositeFieldResolution = {
     source: SourceDef;
     nested?: SingleNarrowedCompositeFieldResolution | undefined;
@@ -84,7 +85,7 @@ export declare function fieldUsageJoinPaths(fieldUsage: FieldUsage[]): string[][
 export declare function checkRequiredGroupBys(compositeResolvedSourceDef: SourceDef, segment: PipeSegment): RequiredGroupBy[];
 export declare function pathEq(a: string[], b: string[]): boolean;
 export declare function pathBegins(path: string[], prefix: string[]): boolean;
-export declare function hasCompositesAnywhere(source: StructDef): boolean;
+export declare function hasCompositesAnywhere(source: SourceDef): boolean;
 export declare function logCompositeError(error: CompositeError, logTo: MalloyElement): void;
 export declare function compileFilterExpression(ft: string, fexpr: Expr): {
     kind: 'date' | 'timestamp';

package/dist/model/composite_source_utils.js

@@ -6,6 +6,7 @@
  *  LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPartitionCompositeDesc = getPartitionCompositeDesc;
 exports.resolveCompositeSources = resolveCompositeSources;
 exports.fieldUsagePaths = fieldUsagePaths;
 exports.formatFieldUsages = formatFieldUsages;
@@ -27,10 +28,11 @@ exports.compileFilterExpression = compileFilterExpression;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("../lang/utils");
+const annotation_1 = require("../annotation");
 function _resolveCompositeSources(path, source, rootFields, nests, fieldUsage, 
 // for resolving nested composites; the list of sources to try
 sources) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     // TODO skip all this if the tree doesn't have any composite sources
     let base = { ...source };
     let anyComposites = false;
@@ -93,8 +95,9 @@ sources) {
                 abort();
                 continue overSources;
             }
-            if (inputSource.type === 'composite') {
-                const resolveInner = _resolveCompositeSources(path, inputSource, genRootFields(rootFields, path, fieldsForLookup, false), nests, compositeUsageInThisSource, inputSource.sources);
+            if (inputSource.type === 'composite' ||
+                inputSource.partitionComposite !== undefined) {
+                const resolveInner = _resolveCompositeSources(path, inputSource, genRootFields(rootFields, path, fieldsForLookup, false), nests, compositeUsageInThisSource, inputSource.type === 'composite' ? inputSource.sources : undefined);
                 if ('error' in resolveInner) {
                     // Third point where we abort; if a nested composite failed; we don't call abort() because we want to unnest the failures from
                     if (resolveInner.error.code === 'no_suitable_composite_source_input') {
@@ -171,6 +174,29 @@ sources) {
             };
         }
     }
+    else if (source.partitionComposite !== undefined) {
+        anyComposites = true;
+        const expanded = expandFieldUsage(fieldUsage, rootFields).result;
+        // TODO possibly abort if expanded has missing fields...
+        const expandedCategorized = categorizeFieldUsage(expanded);
+        const { partitionFilter, issues } = getPartitionCompositeFilter(source.partitionComposite, expandedCategorized.sourceUsage);
+        if (issues !== undefined) {
+            return {
+                error: {
+                    code: 'no_suitable_composite_source_input',
+                    data: {
+                        failures: issues.map(iss => ({ source, issues: iss })),
+                        usage: expanded,
+                        path,
+                    },
+                },
+            };
+        }
+        base = {
+            ...source,
+            filterList: [...((_e = source.filterList) !== null && _e !== void 0 ? _e : []), partitionFilter],
+        };
+    }
     if (!joinsProcessed) {
         const expanded = expandFieldUsage(fieldUsage, getJoinFields(rootFields, path));
         if (expanded.missingFields.length > 0) {
@@ -260,6 +286,89 @@ function categorizeFieldUsage(fieldUsage) {
     }
     return categorized;
 }
+function getPartitionCompositePartition(partitionComposite, fieldUsage) {
+    const issues = [];
+    const compositeFieldsUsed = fieldUsage.filter(u => partitionComposite.compositeFields.some(f => u.path.length === 1 && u.path[0] === f));
+    for (const partition of partitionComposite.partitions) {
+        const missingFields = compositeFieldsUsed.filter(u => u.path.length !== 1 || !partition.fields.includes(u.path[0]));
+        if (missingFields.length === 0) {
+            return { partitionId: partition.id, issues: undefined };
+        }
+        issues.push(missingFields.map(f => ({ type: 'missing-field', field: f })));
+    }
+    return {
+        partitionId: undefined,
+        issues,
+    };
+}
+function getPartitionCompositeFilter(partitionComposite, fieldUsage) {
+    const { partitionId, issues } = getPartitionCompositePartition(partitionComposite, fieldUsage);
+    if (issues !== undefined)
+        return { issues, partitionFilter: undefined };
+    const partitionFilter = {
+        node: 'filterCondition',
+        code: '',
+        expressionType: 'scalar',
+        e: {
+            node: '=',
+            kids: {
+                left: {
+                    node: 'field',
+                    // TODO validate field exists
+                    path: [partitionComposite.partitionField],
+                },
+                right: {
+                    node: 'stringLiteral',
+                    literal: partitionId,
+                },
+            },
+        },
+    };
+    return { partitionFilter, issues: undefined };
+}
+function getPartitionCompositeDesc(annotation, structDef, logTo) {
+    if (annotation === undefined)
+        return undefined;
+    const compilerFlags = (0, annotation_1.annotationToTag)(annotation, { prefix: /^#!\s*/ }).tag;
+    const partitionCompositeTag = compilerFlags.tag('experimental', 'partition_composite');
+    if (partitionCompositeTag === undefined)
+        return undefined;
+    if (structDef.type === 'composite') {
+        logTo.logError('invalid-partition-composite', 'Source is already composite; cannot apply partition composite');
+        return undefined;
+    }
+    const partitionField = partitionCompositeTag.text('partition_field');
+    const partitionsTag = partitionCompositeTag.tag('partitions');
+    if (partitionField === undefined) {
+        logTo.logError('invalid-partition-composite', 'Partition composite must specify `partition_field`');
+        return undefined;
+    }
+    if (partitionsTag === undefined) {
+        logTo.logError('invalid-partition-composite', 'Partition composite must specify `partitions`');
+        return undefined;
+    }
+    const partitions = [];
+    const allFields = new Set();
+    const ids = Object.keys(partitionsTag.getProperties());
+    for (const id of ids) {
+        const partitionTag = partitionsTag.tag(id);
+        if (partitionTag === undefined) {
+            logTo.logError('invalid-partition-composite', `Invalid partition specification for \`${id}\`; must be a tag with property \\fields\``);
+            return undefined;
+        }
+        const fields = Object.keys(partitionsTag.getProperties());
+        allFields.forEach(f => allFields.add(f));
+        partitions.push({ id, fields });
+    }
+    for (const field of [partitionField, ...allFields]) {
+        const def = structDef.fields.find(f => { var _a; return ((_a = f.as) !== null && _a !== void 0 ? _a : f.name) === field; });
+        if (def === undefined) {
+            logTo.logError('invalid-partition-composite', `Composite partition field \`${field}\` not present in source`);
+        }
+    }
+    const compositeFields = structDef.fields.map(f => { var _a; return (_a = f.as) !== null && _a !== void 0 ? _a : f.name; });
+    return { partitionField, partitions, compositeFields };
+}
 function composeAnnotations(base, slice) {
     var _a, _b, _c, _d;
     if (base === undefined)
@@ -854,10 +963,11 @@ function sortIssuesByReferenceLocation(issues) {
     });
 }
 function hasCompositesAnywhere(source) {
-    if (source.type === 'composite')
+    if (source.type === 'composite' || source.partitionComposite !== undefined) {
         return true;
+    }
     for (const field of source.fields) {
-        if ((0, malloy_types_1.isJoined)(field) && hasCompositesAnywhere(field)) {
+        if ((0, malloy_types_1.isJoined)(field) && (0, malloy_types_1.isSourceDef)(field) && hasCompositesAnywhere(field)) {
             return true;
         }
     }

package/dist/model/malloy_types.d.ts

@@ -623,6 +623,14 @@ interface StructDefBase extends HasLocation, NamedObject {
     modelAnnotation?: ModelAnnotation;
     fields: FieldDef[];
 }
+export interface PartitionCompositeDesc {
+    partitionField: string;
+    partitions: {
+        id: string;
+        fields: string[];
+    }[];
+    compositeFields: string[];
+}
 interface SourceDefBase extends StructDefBase, Filtered, ResultStructMetadata {
     arguments?: Record<string, Argument>;
     parameters?: Record<string, Parameter>;
@@ -630,6 +638,7 @@ interface SourceDefBase extends StructDefBase, Filtered, ResultStructMetadata {
     connection: string;
     primaryKey?: PrimaryKeyRef;
     dialect: string;
+    partitionComposite?: PartitionCompositeDesc;
 }
 /** which field is the primary key in this struct */
 export type PrimaryKeyRef = string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.300";
+export declare const MALLOY_VERSION = "0.0.301";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.300';
+exports.MALLOY_VERSION = '0.0.301';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.300",
+  "version": "0.0.301",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.300",
-    "@malloydata/malloy-interfaces": "0.0.300",
-    "@malloydata/malloy-tag": "0.0.300",
+    "@malloydata/malloy-filter": "0.0.301",
+    "@malloydata/malloy-interfaces": "0.0.301",
+    "@malloydata/malloy-tag": "0.0.301",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",