@malloydata/malloy 0.0.137-dev240327175808 → 0.0.137-dev240328161656

package/dist/lang/ast/expressions/apply.d.ts

@@ -1,8 +1,11 @@
 import { ExprCompare } from './expr-compare';
 import { ExpressionDef } from '../types/expression-def';
+import { ExprValue } from '../types/expr-value';
+import { FieldSpace } from '../types/field-space';
 export declare class Apply extends ExprCompare {
     readonly left: ExpressionDef;
     readonly right: ExpressionDef;
     elementType: string;
     constructor(left: ExpressionDef, right: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/apply.js

@@ -25,6 +25,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Apply = void 0;
 const comparison_1 = require("../types/comparison");
 const expr_compare_1 = require("./expr-compare");
+const granular_result_1 = require("../types/granular-result");
+const expr_granular_time_1 = require("./expr-granular-time");
 class Apply extends expr_compare_1.ExprCompare {
     constructor(left, right) {
         super(left, comparison_1.Comparison.EqualTo, right);
@@ -32,6 +34,20 @@ class Apply extends expr_compare_1.ExprCompare {
         this.right = right;
         this.elementType = 'apply';
     }
+    getExpression(fs) {
+        let right = this.right;
+        if (!this.right.granular()) {
+            const rhs = this.right.requestExpression(fs);
+            if (rhs && (0, granular_result_1.isGranularResult)(rhs)) {
+                // Need to wrap granular computations to get granular behavior
+                right = new expr_granular_time_1.ExprGranularTime(this.right, rhs.timeframe, false);
+            }
+        }
+        if (right instanceof expr_granular_time_1.ExprGranularTime) {
+            return right.toRange(fs).apply(fs, this.op, this.left);
+        }
+        return super.getExpression(fs);
+    }
 }
 exports.Apply = Apply;
 //# sourceMappingURL=apply.js.map

package/dist/lang/ast/expressions/expr-compare.js

@@ -24,9 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprCompare = void 0;
 const fragtype_utils_1 = require("../fragtype-utils");
-const granular_result_1 = require("../types/granular-result");
 const binary_boolean_1 = require("./binary-boolean");
-const expr_granular_time_1 = require("./expr-granular-time");
 const compareTypes = {
     '~': [fragtype_utils_1.FT.stringT],
     '!~': [fragtype_utils_1.FT.stringT],
@@ -44,13 +42,6 @@ class ExprCompare extends binary_boolean_1.BinaryBoolean {
         this.legalChildTypes = compareTypes[op];
     }
     getExpression(fs) {
-        if (!this.right.granular()) {
-            const rhs = this.right.requestExpression(fs);
-            if (rhs && (0, granular_result_1.isGranularResult)(rhs)) {
-                const newRight = new expr_granular_time_1.ExprGranularTime(this.right, rhs.timeframe, false);
-                return newRight.apply(fs, this.op, this.left);
-            }
-        }
         return this.right.apply(fs, this.op, this.left);
     }
 }

package/dist/lang/ast/expressions/expr-granular-time.d.ts

@@ -19,6 +19,5 @@ export declare class ExprGranularTime extends ExpressionDef {
     constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
     granular(): boolean;
     getExpression(fs: FieldSpace): ExprValue;
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-    protected getRange(fs: FieldSpace): Range;
+    toRange(fs: FieldSpace): Range;
 }

package/dist/lang/ast/expressions/expr-granular-time.js

@@ -85,25 +85,22 @@ class ExprGranularTime extends expression_def_1.ExpressionDef {
             evalSpace: 'constant',
         };
     }
-    apply(fs, op, left) {
-        return this.getRange(fs).apply(fs, op, left);
-        /*
-          write tests for each of these cases ....
-    
-          vt  rt  gt  use
-          dt  dt  dt  dateRange
-          dt  dt  ts  == or timeStampRange
-          dt  ts  dt  timestampRange
-          dt  ts  ts  timeStampRange
-    
-          ts  ts  ts  timestampRange
-          ts  ts  dt  timestampRange
-          ts  dt  ts  timestampRange
-          ts  dt  dt  either
-    
-        */
-    }
-    getRange(fs) {
+    // apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue {
+    //   return this.getRange(fs).apply(fs, op, left);
+    //   /*
+    //     write tests for each of these cases ....
+    //     vt  rt  gt  use
+    //     dt  dt  dt  dateRange
+    //     dt  dt  ts  == or timeStampRange
+    //     dt  ts  dt  timestampRange
+    //     dt  ts  ts  timeStampRange
+    //     ts  ts  ts  timestampRange
+    //     ts  ts  dt  timestampRange
+    //     ts  dt  ts  timestampRange
+    //     ts  dt  dt  either
+    //   */
+    // }
+    toRange(fs) {
         const begin = this.getExpression(fs);
         if (begin.dataType === 'timestamp') {
             const beginTS = expr_time_1.ExprTime.fromValue('timestamp', begin);

package/dist/lang/test/expressions.spec.js

@@ -25,6 +25,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const model_1 = require("../../model");
 const test_translator_1 = require("./test-translator");
 require("./parse-expects");
+/**
+ * Convert an expression to a string, any fragment which is not a string turns into a variable,
+ * useful for maybe checking simple code generation, but it sort of hints at an interesting matcher
+ * @param expr Compiled expression
+ * @returns A string with variables A,B,... substituded for non string elements
+ */
+function exprToString(expr) {
+    let varCode = 'A'.charCodeAt(0);
+    const vars = {};
+    return expr
+        .map(f => {
+        if (typeof f === 'string') {
+            return f;
+        }
+        const key = JSON.stringify(f);
+        if (!vars[key]) {
+            vars[key] = String.fromCharCode(varCode);
+            varCode += 1;
+        }
+        return vars[key];
+    })
+        .join('');
+}
 describe('expressions', () => {
     describe('timeframes', () => {
         const timeframes = [
@@ -125,6 +148,39 @@ describe('expressions', () => {
         test('disallow interval from date to timestamp', () => {
             expect(new test_translator_1.BetaExpression('days(ad to ats)')).translationToFailWith('Cannot measure from date to timestamp');
         });
+        test('compare to truncation uses straight comparison', () => {
+            const compare = (0, test_translator_1.expr) `ad = ad.quarter`;
+            expect(compare).toTranslate();
+            const compare_expr = compare.translator.generated().value;
+            expect(exprToString(compare_expr)).toEqual('A=B');
+        });
+        test('compare to granular result expression uses straight comparison', () => {
+            const compare = (0, test_translator_1.expr) `ad = ad.quarter + 1`;
+            expect(compare).toTranslate();
+            const compare_expr = compare.translator.generated().value;
+            expect(exprToString(compare_expr)).toEqual('A=B');
+        });
+        test('apply granular-truncation uses range', () => {
+            const compare = (0, test_translator_1.expr) `ad ? ad.quarter`;
+            expect(compare).toTranslate();
+            const compare_expr = compare.translator.generated().value;
+            expect(exprToString(compare_expr)).toEqual('(A>=B)and(A<C)');
+        });
+        test('apply granular-literal alternation uses range', () => {
+            const compare = (0, test_translator_1.expr) `ad ? @2020 | @2022`;
+            expect(compare).toTranslate();
+            const compare_expr = compare.translator.generated().value;
+            expect(exprToString(compare_expr)).toEqual('((A>=B)and(A<C))or((A>=D)and(A<E))');
+        });
+        // this should use range, but it uses = and alternations are
+        // kind of needing help so this is a placeholder for
+        // future work
+        test.skip('apply granular-result alternation uses range', () => {
+            const compare = (0, test_translator_1.expr) `ad ? ad.year | ad.month`;
+            expect(compare).toTranslate();
+            const compare_expr = compare.translator.generated().value;
+            expect(exprToString(compare_expr)).toEqual('((A>=B)and(A<C))or((A>=D)and(A<E))');
+        });
         test('comparison promotes date literal to timestamp', () => {
             expect((0, test_translator_1.expr) `@2001 = ats`).toTranslate();
         });

package/dist/lang/test/test-translator.d.ts

@@ -59,16 +59,16 @@ export interface MarkedSource {
     locations: DocumentLocation[];
     translator?: TestTranslator;
 }
-interface HasTranslator extends MarkedSource {
-    translator: TestTranslator;
+interface HasTranslator<TT extends TestTranslator> extends MarkedSource {
+    translator: TT;
 }
-export declare function expr(unmarked: TemplateStringsArray, ...marked: string[]): HasTranslator;
-export declare function model(unmarked: TemplateStringsArray, ...marked: string[]): HasTranslator;
+export declare function expr(unmarked: TemplateStringsArray, ...marked: string[]): HasTranslator<BetaExpression>;
+export declare function model(unmarked: TemplateStringsArray, ...marked: string[]): HasTranslator<TestTranslator>;
 export declare function makeModelFunc(options: {
     model?: ModelDef;
     prefix?: string;
     wrap?: (code: string) => string;
-}): (unmarked: TemplateStringsArray, ...marked: string[]) => HasTranslator;
+}): (unmarked: TemplateStringsArray, ...marked: string[]) => HasTranslator<TestTranslator>;
 export declare function markSource(unmarked: TemplateStringsArray, ...marked: string[]): MarkedSource;
 export declare function getSelectOneStruct(sqlBlock: SQLBlockSource): SQLBlockStructDef;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.137-dev240327175808",
+  "version": "0.0.137-dev240328161656",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",