@malloydata/malloy 0.0.289 → 0.0.291

package/dist/lang/ast/expressions/time-literal.js

@@ -162,6 +162,7 @@ class LiteralTimestamp extends TimeLiteral {
         const hasSubsecs = literalTs.match(/^([^.,]+)[,.](\d+)$/);
         if (hasSubsecs) {
             literalTs = hasSubsecs[1];
+            units = undefined;
             // subSecs = hasSubsecs[2];
             // mtoy TODO subsecond units not ignored
         }
@@ -199,6 +200,28 @@ class GranularLiteral extends TimeLiteral {
         let rangeEnd = this.getNext();
         if (rangeEnd) {
             const testValue = left.getExpression(fs);
+            if (testValue.type === 'date' && op === '=' && this.units === 'day') {
+                // TODO remove the === 'day' check above and warn
+                // if (this.units !== 'day') {
+                //   this.logWarning(
+                //     'time-equality-not-granular',
+                //     `Equality comparisons of a date to a literal ${this.units} will compare the first day of the ${this.units}; use a literal day instead, or use \`?\` to check whether the date is within the ${this.units}.`
+                //   );
+                // }
+                return super.apply(fs, op, left);
+            }
+            if (testValue.type === 'timestamp' &&
+                op === '=' &&
+                this.units === undefined) {
+                // TODO remove the === 'second' check above and warn
+                // if (this.units !== 'second') {
+                //   this.logWarning(
+                //     'time-equality-not-granular',
+                //     `Equality comparisons of a timestamp to a literal ${this.units} will compare the first instant of the ${this.units}; use a literal timestamp (to the second) instead, or use \`?\` to check whether the date is within the ${this.units}.`
+                //   );
+                // }
+                return super.apply(fs, op, left);
+            }
             if (testValue.type === 'timestamp') {
                 const newStart = (0, expression_def_1.getMorphicValue)(rangeStart, 'timestamp');
                 const newEnd = (0, expression_def_1.getMorphicValue)(rangeEnd, 'timestamp');

package/dist/lang/ast/query-elements/query-arrow.js

@@ -81,7 +81,7 @@ class QueryArrow extends query_base_1.QueryBase {
         if (segment !== undefined) {
             const unsatisfiedGroupBys = (0, composite_source_utils_1.checkRequiredGroupBys)(compositeResolvedSourceDef !== null && compositeResolvedSourceDef !== void 0 ? compositeResolvedSourceDef : inputStruct, segment);
             for (const unsatisfiedGroupBy of unsatisfiedGroupBys) {
-                this.logError('missing-required-group-by', `Group by of \`${unsatisfiedGroupBy.path.join('.')}\` is required but not present`, {
+                this.logError('missing-required-group-by', `Group by or single value filter of \`${unsatisfiedGroupBy.path.join('.')}\` is required but not present`, {
                     at: unsatisfiedGroupBy.at,
                 });
             }

package/dist/lang/ast/query-utils.d.ts

@@ -2,4 +2,3 @@ import type { PipeSegment } from '../../model';
 import type { MalloyElement } from './types/malloy-element';
 export declare function detectAndRemovePartialStages(pipeline: PipeSegment[], logTo: MalloyElement): PipeSegment[];
 export declare function unsatisfiedRequiredGroupBys(segment: PipeSegment | undefined, requiredGroupBys: string[][]): string[][];
-export declare function validateRequiredGroupBys(segment: PipeSegment, logTo: MalloyElement, requiredGroupBys: string[][]): void;

package/dist/lang/ast/query-utils.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectAndRemovePartialStages = detectAndRemovePartialStages;
 exports.unsatisfiedRequiredGroupBys = unsatisfiedRequiredGroupBys;
-exports.validateRequiredGroupBys = validateRequiredGroupBys;
 const model_1 = require("../../model");
 // We don't want to ever generate actual 'partial' stages, so convert this
 // into a reduce so the compiler doesn't explode
@@ -67,10 +66,4 @@ function unsatisfiedRequiredGroupBys(segment, requiredGroupBys) {
     }
     return result;
 }
-function validateRequiredGroupBys(segment, logTo, requiredGroupBys) {
-    const missing = unsatisfiedRequiredGroupBys(segment, requiredGroupBys);
-    for (const requiredGroupBy of missing) {
-        logTo.logError('missing-required-group-by', `Group by of \`${requiredGroupBy.join('.')}\` is required but not present`);
-    }
-}
 //# sourceMappingURL=query-utils.js.map

package/dist/lang/ast/source-elements/named-source.js

@@ -116,7 +116,7 @@ class NamedSource extends source_1.Source {
         return this.evaluateArguments(parameterSpace, base.parameters, []);
     }
     evaluateArguments(parameterSpace, parametersIn, parametersOut) {
-        var _a, _b;
+        var _a, _b, _c;
         const outArguments = { ...this.sourceArguments };
         const passedNames = new Set();
         for (const argument of (_a = this.args) !== null && _a !== void 0 ? _a : []) {
@@ -144,7 +144,15 @@ class NamedSource extends source_1.Source {
                 if (pVal.type === 'filter expression' &&
                     parameter.type === 'filter expression' &&
                     parameter.filterType) {
-                    (0, expression_def_1.checkFilterExpression)(argument.value, parameter.filterType, value);
+                    if (value.node === 'parameter') {
+                        const filterType = (_c = pVal['filterType']) !== null && _c !== void 0 ? _c : 'missing-filter-type';
+                        if (parameter.filterType !== filterType) {
+                            argument.value.logError('filter-expression-type', `Parameter types filter<${parameter.filterType}> and filter<${filterType}> do not match`);
+                        }
+                    }
+                    else {
+                        (0, expression_def_1.checkFilterExpression)(argument.value, parameter.filterType, value);
+                    }
                 }
                 if (pVal.type !== parameter.type && (0, malloy_types_1.isCastType)(parameter.type)) {
                     value = (0, time_utils_1.castTo)(parameter.type, pVal.value, pVal.type, true);

package/dist/lang/ast/typedesc-utils.d.ts

@@ -1,4 +1,4 @@
-import type { AtomicTypeDef, TypeDesc } from '../../model';
+import type { AtomicTypeDef, EvalSpace, Parameter, TypeDesc } from '../../model';
 export declare const nullT: TypeDesc;
 export declare const numberT: TypeDesc;
 export declare const stringT: TypeDesc;
@@ -46,3 +46,4 @@ export declare function inspect(...types: (TypeDesc | undefined)[]): string;
  * create a field, don't copy the non type fields.
  */
 export declare function atomicDef(td: AtomicTypeDef | TypeDesc): AtomicTypeDef;
+export declare function parameterTypeDesc(p: Parameter, evalSpace: EvalSpace): TypeDesc;

package/dist/lang/ast/typedesc-utils.js

@@ -29,6 +29,7 @@ exports.typeIn = typeIn;
 exports.typeEq = typeEq;
 exports.inspect = inspect;
 exports.atomicDef = atomicDef;
+exports.parameterTypeDesc = parameterTypeDesc;
 const model_1 = require("../../model");
 function mkTypeDesc(
 // The problem is that record and array, as currently defined, require a dialect
@@ -155,4 +156,16 @@ function atomicDef(td) {
     }
     return { type: 'error' };
 }
+function parameterTypeDesc(p, evalSpace) {
+    const t = p.type;
+    const theType = t === 'filter expression'
+        ? { type: t, filterType: p.filterType }
+        : atomicDef(p);
+    return {
+        ...theType,
+        expressionType: 'scalar',
+        evalSpace,
+        fieldUsage: [],
+    };
+}
 //# sourceMappingURL=typedesc-utils.js.map

package/dist/lang/ast/types/space-param.js

@@ -78,15 +78,7 @@ class AbstractParameter extends SpaceParam {
         return this._parameter;
     }
     typeDesc() {
-        const p = this.parameter();
-        const t = p.type;
-        const theType = t === 'filter expression' ? { type: t } : TDU.atomicDef(p);
-        return {
-            ...theType,
-            expressionType: 'scalar',
-            evalSpace: 'constant',
-            fieldUsage: [],
-        };
+        return TDU.parameterTypeDesc(this.parameter(), 'constant');
     }
 }
 exports.AbstractParameter = AbstractParameter;
@@ -99,17 +91,9 @@ class DefinedParameter extends SpaceParam {
         return this.paramDef;
     }
     typeDesc() {
-        const p = this.parameter();
-        const t = p.type;
-        const theType = t === 'filter expression' ? { type: t } : TDU.atomicDef(p);
-        return {
-            ...theType,
-            expressionType: 'scalar',
-            // TODO Not sure whether params are considered "input space". It seems like they
-            // could be input or constant, depending on usage (same as above).
-            evalSpace: 'input',
-            fieldUsage: [],
-        };
+        // TODO Not sure whether params are considered "input space". It seems like they
+        // could be input or constant, depending on usage (same as above).
+        return TDU.parameterTypeDesc(this.parameter(), 'input');
     }
 }
 exports.DefinedParameter = DefinedParameter;

package/dist/model/composite_source_utils.d.ts

@@ -1,5 +1,6 @@
+import type { BooleanFilter, NumberFilter, StringFilter, TemporalFilter } from '@malloydata/malloy-filter';
 import type { MalloyElement } from '../lang/ast';
-import type { FieldUsage, PipeSegment, SourceDef, StructDef, RequiredGroupBy } from './malloy_types';
+import type { FieldUsage, PipeSegment, SourceDef, Expr, StructDef, RequiredGroupBy } from './malloy_types';
 type CompositeCouldNotFindFieldError = {
     code: 'could_not_find_field';
     data: {
@@ -86,4 +87,17 @@ export declare function pathBegins(path: string[], prefix: string[]): boolean;
 export declare function sortFieldUsageByReferenceLocation(usage: FieldUsage[]): FieldUsage[];
 export declare function hasCompositesAnywhere(source: StructDef): boolean;
 export declare function logCompositeError(error: CompositeError, logTo: MalloyElement): void;
+export declare function compileFilterExpression(ft: string, fexpr: Expr): {
+    kind: 'date' | 'timestamp';
+    parsed: TemporalFilter;
+} | {
+    kind: 'string';
+    parsed: StringFilter;
+} | {
+    kind: 'boolean';
+    parsed: BooleanFilter;
+} | {
+    kind: 'number';
+    parsed: NumberFilter;
+} | undefined;
 export {};

package/dist/model/composite_source_utils.js

@@ -24,6 +24,8 @@ exports.pathBegins = pathBegins;
 exports.sortFieldUsageByReferenceLocation = sortFieldUsageByReferenceLocation;
 exports.hasCompositesAnywhere = hasCompositesAnywhere;
 exports.logCompositeError = logCompositeError;
+exports.compileFilterExpression = compileFilterExpression;
+const malloy_filter_1 = require("@malloydata/malloy-filter");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 function _resolveCompositeSources(path, source, rootFields, nests, fieldUsage, 
@@ -505,6 +507,7 @@ function getFieldUsageForField(field) {
     return [];
 }
 function nestLevelsAt(nests, at) {
+    var _a;
     if (at === undefined)
         return nests;
     return {
@@ -512,7 +515,8 @@ function nestLevelsAt(nests, at) {
         nested: nests.nested.map(n => nestLevelsAt(n, at)),
         fieldsReferenced: fieldUsageAt(nests.fieldsReferencedDirectly, at),
         ungroupings: ungroupingsAt(nests.ungroupings, at),
-        requiredGroupBys: requiredGroupBysAt(nests.requiredGroupBys, at),
+        requiredGroupBys: (_a = requiredGroupBysAt(nests.requiredGroupBys, at)) !== null && _a !== void 0 ? _a : [],
+        singleValueFilters: nests.singleValueFilters,
     };
 }
 function fieldUsageAt(fieldUsage, at) {
@@ -552,12 +556,13 @@ function joinedUngroupings(joinPath, ungroupings) {
     }));
 }
 function extractNestLevels(segment) {
-    var _a, _b;
+    var _a, _b, _c;
     const fieldsReferencedDirectly = [];
     const fieldsReferenced = [];
     const nested = [];
     const ungroupings = [];
     const requiredGroupBys = [];
+    const singleValueFilters = [];
     if (segment.type === 'project' ||
         segment.type === 'partial' ||
         segment.type === 'reduce') {
@@ -580,6 +585,12 @@ function extractNestLevels(segment) {
                 requiredGroupBys.push(...((_b = field.requiresGroupBy) !== null && _b !== void 0 ? _b : []));
             }
         }
+        for (const filter of (_c = segment.filterList) !== null && _c !== void 0 ? _c : []) {
+            if (!(0, malloy_types_1.expressionIsScalar)(filter.expressionType))
+                continue;
+            const fields = getSingleValueFilterFields(filter.e);
+            singleValueFilters.push(...fields);
+        }
     }
     const levels = {
         fieldsReferencedDirectly,
@@ -587,9 +598,70 @@ function extractNestLevels(segment) {
         fieldsReferenced,
         ungroupings,
         requiredGroupBys,
+        singleValueFilters,
     };
     return nestLevelsAt(levels, segment.referencedAt);
 }
+function getSingleValueFilterFields(filter) {
+    const fieldPaths = [];
+    if (filter.node === 'and') {
+        fieldPaths.push(...getSingleValueFilterFields(filter.kids.left));
+        fieldPaths.push(...getSingleValueFilterFields(filter.kids.right));
+    }
+    else if (filter.node === '()') {
+        fieldPaths.push(...getSingleValueFilterFields(filter.e));
+    }
+    else {
+        const path = isSingleValueFilterNode(filter);
+        if (path) {
+            fieldPaths.push(path);
+        }
+    }
+    return fieldPaths;
+}
+function isSingleValueFilterNode(e) {
+    if (e.node === 'filterMatch') {
+        if (e.kids.expr.node === 'field') {
+            const result = compileFilterExpression(e.dataType, e.kids.filterExpr);
+            if (!result)
+                return [];
+            if ((result.parsed.operator === 'null' && !result.parsed.not) ||
+                (result.kind === 'boolean' &&
+                    ['false', 'true'].includes(result.parsed.operator) &&
+                    !result.parsed.not) ||
+                (result.kind === 'date' &&
+                    result.parsed.operator === 'in' &&
+                    result.parsed.in.moment === 'literal' &&
+                    result.parsed.in.units === 'day' &&
+                    !result.parsed.not) ||
+                (result.kind === 'timestamp' &&
+                    result.parsed.operator === 'in' &&
+                    result.parsed.in.moment === 'literal' &&
+                    result.parsed.in.units === undefined &&
+                    !result.parsed.not) ||
+                // TODO: handle 'today', 'now', 'yesterday', etc.
+                ((result.kind === 'number' || result.kind === 'string') &&
+                    result.parsed.operator === '=' &&
+                    result.parsed.values.length === 1 &&
+                    !result.parsed.not)) {
+                return e.kids.expr.path;
+            }
+        }
+    }
+    else if (e.node === '=') {
+        if (e.kids.left.node === 'field' &&
+            (e.kids.right.node === 'true' ||
+                e.kids.right.node === 'false' ||
+                e.kids.right.node === 'timeLiteral' ||
+                e.kids.right.node === 'numberLiteral' ||
+                e.kids.right.node === 'stringLiteral')) {
+            return e.kids.left.path;
+        }
+    }
+    else if (e.node === 'is-null' && e.e.node === 'field') {
+        return e.e.path;
+    }
+}
 function expandRefs(nests, fields) {
     var _a, _b, _c;
     const newNests = [];
@@ -655,6 +727,7 @@ function expandRefs(nests, fields) {
             ungroupings: [],
             nested: [],
             requiredGroupBys: (_a = ungrouping.requiresGroupBy) !== null && _a !== void 0 ? _a : [],
+            singleValueFilters: [],
         }, fields);
         missingFields.push(...((_b = expanded.missingFields) !== null && _b !== void 0 ? _b : []));
         for (const field of expanded.result.requiredGroupBys) {
@@ -676,6 +749,7 @@ function expandRefs(nests, fields) {
             requiredGroupBys,
             unsatisfiableGroupBys,
             nested,
+            singleValueFilters: nests.singleValueFilters,
         },
         missingFields: missingFields.length > 0 ? missingFields : undefined,
     };
@@ -700,13 +774,16 @@ function checkRequiredGroupBys(compositeResolvedSourceDef, segment) {
     return unsatisfied;
 }
 function getUnsatisfiedRequiredGroupBys(level) {
-    const fields = level.fieldsReferencedDirectly;
+    const fields = [
+        ...level.fieldsReferencedDirectly.map(f => f.path),
+        ...level.singleValueFilters,
+    ];
     const requiredGroupBys = [...level.requiredGroupBys];
     for (const nested of level.nested) {
         requiredGroupBys.push(...getUnsatisfiedRequiredGroupBys(nested));
     }
     return [
-        ...requiredGroupBys.filter(rgb => !fields.some(f => pathEq(f.path, rgb.path))),
+        ...requiredGroupBys.filter(rgb => !fields.some(f => pathEq(f, rgb.path))),
         ...level.unsatisfiableGroupBys,
     ];
 }
@@ -803,7 +880,7 @@ function logCompositeError(error, logTo) {
                     }
                     else if (issue.type === 'missing-required-group-by') {
                         const fieldRef = `\`${issue.requiredGroupBy.path.join('.')}\``;
-                        logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: missing group by ${fieldRef} as required in ${source}${requiredFields}`, { at: issue.requiredGroupBy.at });
+                        logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: missing group by or single value filter of ${fieldRef} as required in ${source}${requiredFields}`, { at: issue.requiredGroupBy.at });
                     }
                     else {
                         const joinRef = `\`${issue.path.join('.')}\``;
@@ -817,4 +894,31 @@ function logCompositeError(error, logTo) {
         logTo.logError('could-not-resolve-composite-source', 'Could not resolve composite source');
     }
 }
+function compileFilterExpression(ft, fexpr) {
+    if (fexpr.node !== 'filterLiteral') {
+        return undefined;
+    }
+    const fsrc = fexpr.filterSrc;
+    if (ft === 'date' || ft === 'timestamp') {
+        const result = malloy_filter_1.TemporalFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    else if (ft === 'string') {
+        const result = malloy_filter_1.StringFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    else if (ft === 'number') {
+        const result = malloy_filter_1.NumberFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    else if (ft === 'boolean') {
+        const result = malloy_filter_1.BooleanFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    return undefined;
+}
 //# sourceMappingURL=composite_source_utils.js.map

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.289";
+export declare const MALLOY_VERSION = "0.0.291";

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.289';
+exports.MALLOY_VERSION = '0.0.291';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.289",
+  "version": "0.0.291",
   "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.289",
-    "@malloydata/malloy-interfaces": "0.0.289",
-    "@malloydata/malloy-tag": "0.0.289",
+    "@malloydata/malloy-filter": "0.0.291",
+    "@malloydata/malloy-interfaces": "0.0.291",
+    "@malloydata/malloy-tag": "0.0.291",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",