@malloydata/malloy 0.0.24-dev230302224355 → 0.0.24-dev230305212748

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -9,6 +9,7 @@ import { TableSourceContext } from "./MalloyParser";
 import { QuerySourceContext } from "./MalloyParser";
 import { SQLSourceNameContext } from "./MalloyParser";
 import { LiteralTimestampContext } from "./MalloyParser";
+import { LiteralHourContext } from "./MalloyParser";
 import { LiteralDayContext } from "./MalloyParser";
 import { LiteralWeekContext } from "./MalloyParser";
 import { LiteralMonthContext } from "./MalloyParser";
@@ -295,6 +296,18 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitLiteralTimestamp?: (ctx: LiteralTimestampContext) => void;
+    /**
+     * Enter a parse tree produced by the `literalHour`
+     * labeled alternative in `MalloyParser.dateLiteral`.
+     * @param ctx the parse tree
+     */
+    enterLiteralHour?: (ctx: LiteralHourContext) => void;
+    /**
+     * Exit a parse tree produced by the `literalHour`
+     * labeled alternative in `MalloyParser.dateLiteral`.
+     * @param ctx the parse tree
+     */
+    exitLiteralHour?: (ctx: LiteralHourContext) => void;
     /**
      * Enter a parse tree produced by the `literalDay`
      * labeled alternative in `MalloyParser.dateLiteral`.

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -9,6 +9,7 @@ import { TableSourceContext } from "./MalloyParser";
 import { QuerySourceContext } from "./MalloyParser";
 import { SQLSourceNameContext } from "./MalloyParser";
 import { LiteralTimestampContext } from "./MalloyParser";
+import { LiteralHourContext } from "./MalloyParser";
 import { LiteralDayContext } from "./MalloyParser";
 import { LiteralWeekContext } from "./MalloyParser";
 import { LiteralMonthContext } from "./MalloyParser";
@@ -248,6 +249,13 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitLiteralTimestamp?: (ctx: LiteralTimestampContext) => Result;
+    /**
+     * Visit a parse tree produced by the `literalHour`
+     * labeled alternative in `MalloyParser.dateLiteral`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLiteralHour?: (ctx: LiteralHourContext) => Result;
     /**
      * Visit a parse tree produced by the `literalDay`
      * labeled alternative in `MalloyParser.dateLiteral`.

package/dist/lang/malloy-to-ast.d.ts

@@ -53,6 +53,11 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     protected getFilterShortcut(cx: parse.FilterShortcutContext): ast.Filter;
     protected getExploreSource(pcx: parse.ExploreSourceContext): ast.Source;
     protected makeSqlString(pcx: parse.SqlStringContext, sqlStr: ast.SQLString): void;
+    /**
+     * Parse a time string into an AST TimeLiteral, if the string fails
+     * the parse, make sure it highlights properly
+     */
+    protected parseTime(pcx: ParserRuleContext, parse: (s: string) => ast.ExpressionDef | undefined): ast.ExpressionDef;
     visitMalloyDocument(pcx: parse.MalloyDocumentContext): ast.Document;
     visitDefineSourceStatement(pcx: parse.DefineSourceStatementContext): ast.DefineSourceList | ast.DefineSource;
     visitsourceDefinition(pcx: parse.SourceDefinitionContext): ast.DefineSource;
@@ -141,8 +146,8 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitPickStatement(pcx: parse.PickStatementContext): ast.Pick;
     visitNamedSource(pcx: parse.NamedSourceContext): ast.NamedSource;
     visitExprFilter(pcx: parse.ExprFilterContext): ast.ExprFilter;
-    protected getLiteralTime(cx: ParserRuleContext): ast.ExpressionDef;
     visitLiteralTimestamp(pcx: parse.LiteralTimestampContext): ast.ExpressionDef;
+    visitLiteralHour(pcx: parse.LiteralHourContext): ast.ExpressionDef;
     visitLiteralDay(pcx: parse.LiteralDayContext): ast.ExpressionDef;
     visitLiteralWeek(pcx: parse.LiteralWeekContext): ast.ExpressionDef;
     visitLiteralMonth(pcx: parse.LiteralMonthContext): ast.ExpressionDef;

package/dist/lang/malloy-to-ast.js

@@ -259,6 +259,19 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         sqlStr.push(lastChars || '');
         this.astAt(sqlStr, pcx);
     }
+    /**
+     * Parse a time string into an AST TimeLiteral, if the string fails
+     * the parse, make sure it highlights properly
+     */
+    parseTime(pcx, parse) {
+        let def = parse(pcx.text);
+        if (!def) {
+            this.contextError(pcx, 'Time data parse error');
+            // return a value node so the parse can continue
+            def = new ast.LiteralTimestamp({ text: pcx.text });
+        }
+        return this.astAt(def, pcx);
+    }
     visitMalloyDocument(pcx) {
         const stmts = this.onlyDocStatements(pcx.malloyStatement().map(scx => this.visit(scx)));
         return new ast.Document(stmts);
@@ -912,31 +925,26 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const filters = this.visit(pcx.filteredBy());
         return new ast.ExprFilter(this.getFieldExpr(pcx.fieldExpr()), filters);
     }
-    getLiteralTime(cx) {
-        const parsed = ast.GranularLiteral.parse(cx.text);
-        if (parsed === undefined) {
-            this.contextError(cx, `${cx.text} is not a legal day specification`);
-            return new ast.ExprNow();
-        }
-        return parsed;
-    }
     visitLiteralTimestamp(pcx) {
-        return this.getLiteralTime(pcx);
+        return this.parseTime(pcx, ast.LiteralTimestamp.parse);
+    }
+    visitLiteralHour(pcx) {
+        return this.parseTime(pcx, ast.LiteralHour.parse);
     }
     visitLiteralDay(pcx) {
-        return this.getLiteralTime(pcx);
+        return this.parseTime(pcx, ast.LiteralDay.parse);
     }
     visitLiteralWeek(pcx) {
-        return this.getLiteralTime(pcx);
+        return this.parseTime(pcx, ast.LiteralWeek.parse);
     }
     visitLiteralMonth(pcx) {
-        return this.getLiteralTime(pcx);
+        return this.parseTime(pcx, ast.LiteralMonth.parse);
     }
     visitLiteralQuarter(pcx) {
-        return this.getLiteralTime(pcx);
+        return this.parseTime(pcx, ast.LiteralQuarter.parse);
     }
     visitLiteralYear(pcx) {
-        return this.getLiteralTime(pcx);
+        return this.parseTime(pcx, ast.LiteralYear.parse);
     }
     visitImportStatement(pcx) {
         const url = this.stripQuotes(pcx.importURL().text);

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

@@ -33,6 +33,7 @@ const expression_def_1 = require("../ast/types/expression-def");
 const test_translator_1 = require("./test-translator");
 const isEqual_1 = __importDefault(require("lodash/isEqual"));
 const util_1 = require("util");
+const granular_result_1 = require("../ast/types/granular-result");
 const inspectCompile = false;
 /*
  * Thinking of these tests as just "do things parse", there should maybe
@@ -306,6 +307,7 @@ class BetaExpression extends Testable {
             if (aStruct.type === 'struct') {
                 const tstFS = new static_space_1.StaticSpace(aStruct);
                 const exprDef = exprAst.getExpression(tstFS);
+                this.compiled = exprDef;
                 if (inspectCompile) {
                     console.log('EXPRESSION: ', (0, test_translator_1.pretty)(exprDef));
                 }
@@ -322,6 +324,12 @@ class BetaExpression extends Testable {
             throw new Error(`Not an expression: ${whatIsIt}`);
         }
     }
+    generated() {
+        if (!this.compiled) {
+            throw new Error('Must compile expression before fetching generated code');
+        }
+        return this.compiled;
+    }
 }
 function exprOK(s) {
     return () => {
@@ -902,25 +910,120 @@ describe('qops', () => {
         }
     });
 });
-describe('expressions', () => {
-    describe('literals', () => {
-        test('integer', exprOK('42'));
-        test('string', exprOK("'fortywo-two'"));
-        test('string with quoted quote', exprOK("'Isn" + '\\' + "'t this nice'"));
-        test('string with quoted backslash', exprOK("'Is " + '\\' + '\\' + " nice'"));
-        test('year', exprOK('@1960'));
-        test('quarter', exprOK('@1960-Q1'));
-        test('week', exprOK('@WK1960-06-26'));
-        test('month', exprOK('@1960-06'));
-        test('day', exprOK('@1960-06-30'));
-        test('minute', exprOK('@1960-06-30 10:30'));
-        test('second', exprOK('@1960-06-30 10:30:31'));
-        test('null', exprOK('null'));
-        test('now', exprOK('now'));
-        test('true', exprOK('true'));
-        test('false', exprOK('false'));
-        test('regex', exprOK("r'RegularExpression'"));
+describe('literals', () => {
+    test('integer', exprOK('42'));
+    test('string', exprOK("'fortywo-two'"));
+    test('string with quoted quote', exprOK("'Isn" + '\\' + "'t this nice'"));
+    test('string with quoted backslash', exprOK("'Is " + '\\' + '\\' + " nice'"));
+    const literalTimes = [
+        ['@1960', 'date', 'year', { literal: '1960-01-01' }],
+        ['@1960-Q2', 'date', 'quarter', { literal: '1960-04-01' }],
+        ['@1960-06', 'date', 'month', { literal: '1960-06-01' }],
+        ['@1960-06-26-WK', 'date', 'week', { literal: '1960-06-26' }],
+        ['@1960-06-30-WK', 'date', 'week', { literal: '1960-06-26' }],
+        ['@1960-06-30', 'date', 'day', { literal: '1960-06-30' }],
+        ['@1960-06-30 10', 'timestamp', 'hour', { literal: '1960-06-30 10:00:00' }],
+        [
+            '@1960-06-30 10:30',
+            'timestamp',
+            'minute',
+            { literal: '1960-06-30 10:30:00' },
+        ],
+        [
+            '@1960-06-30 10:30:00',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00' },
+        ],
+        [
+            '@1960-06-30 10:30:00.123',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00.123' },
+        ],
+        [
+            '@1960-06-30T10:30:00',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00' },
+        ],
+        [
+            '@1960-06-30 10:30:00+0',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00', timezone: '+0' },
+        ],
+        [
+            '@1960-06-30 10:30:00-7',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00', timezone: '-7' },
+        ],
+        [
+            '@1960-06-30 10:30:00-00:15',
+            'timestamp',
+            undefined,
+            { literal: '1960-06-30 10:30:00', timezone: '-00:15' },
+        ],
+        [
+            '@1960-06-30 10:30:00[America/Los_Angeles]',
+            'timestamp',
+            undefined,
+            {
+                literal: '1960-06-30 10:30:00',
+                timezone: 'America/Los_Angeles',
+                tzIsLocale: true,
+            },
+        ],
+    ];
+    test.each(literalTimes)('%s', (expr, timeType, timeframe, result) => {
+        const exprModel = new BetaExpression(expr);
+        expect(exprModel).modelCompiled();
+        const ir = exprModel.generated();
+        expect(ir.dataType).toEqual(timeType);
+        if (timeframe) {
+            expect((0, granular_result_1.isGranularResult)(ir)).toBeTruthy();
+            if ((0, granular_result_1.isGranularResult)(ir)) {
+                expect(ir.timeframe).toEqual(timeframe);
+            }
+        }
+        else {
+            expect((0, granular_result_1.isGranularResult)(ir)).toBeFalsy();
+        }
+        expect(ir.value[0]).toEqual(expect.objectContaining(result));
+    });
+    const morphicLiterals = [
+        ['@1960', '1960-01-01 00:00:00'],
+        ['@1960-Q2', '1960-04-01 00:00:00'],
+        ['@1960-06', '1960-06-01 00:00:00'],
+        ['@1960-06-30-Wk', '1960-06-26 00:00:00'],
+        ['@1960-06-30', '1960-06-30 00:00:00'],
+        ['@1960-06-30 00:00', undefined],
+    ];
+    test.each(morphicLiterals)('morphic value for %s is %s', (expr, morphic) => {
+        const exprModel = new BetaExpression(expr);
+        expect(exprModel).modelCompiled();
+        const ir = exprModel.generated();
+        const morphTo = ir.morphic && ir.morphic['timestamp'];
+        if (morphic) {
+            expect(morphTo).toBeDefined();
+            if (morphTo) {
+                expect(morphTo[0]).toEqual(expect.objectContaining({ literal: morphic }));
+            }
+        }
+        else {
+            expect(morphTo).toBeUndefined();
+        }
     });
+    test('minute+locale', exprOK('@1960-06-30 10:30[America/Los_Angeles]'));
+    test('second 8601', exprOK('@1960-06-30T10:30:31'));
+    test('null', exprOK('null'));
+    test('now', exprOK('now'));
+    test('true', exprOK('true'));
+    test('false', exprOK('false'));
+    test('regex', exprOK("r'RegularExpression'"));
+});
+describe('expressions', () => {
     describe('timeframes', () => {
         const timeframes = [
             'second',

package/dist/model/malloy_types.d.ts

@@ -197,6 +197,7 @@ export interface TimeLiteralFragment extends DialectFragmentBase {
     literal: string;
     literalType: TimeFieldType;
     timezone: string;
+    tzIsLocale?: boolean;
 }
 export interface StringLiteralFragment extends DialectFragmentBase {
     function: 'stringLiteral';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.24-dev230302224355",
+  "version": "0.0.24-dev230305212748",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/lang/ast/expressions/granular-literal.d.ts

@@ -1,20 +0,0 @@
-import { TimeFieldType, TimestampUnit } from '../../../model/malloy_types';
-import { ExprValue } from '../types/expr-value';
-import { FieldSpace } from '../types/field-space';
-import { ExpressionDef } from '../types/expression-def';
-/**
- * GranularTime made from a literal. Funky because it doesn't know if it
- * is a date or a timestamp in many cases until it is applied.
- */
-export declare class GranularLiteral extends ExpressionDef {
-    readonly moment: string;
-    readonly until: string;
-    readonly units: TimestampUnit;
-    elementType: string;
-    timeType?: TimeFieldType;
-    constructor(moment: string, until: string, units: TimestampUnit);
-    granular(): boolean;
-    static parse(possibleLiteral: string): GranularLiteral | undefined;
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
-    getExpression(_fs: FieldSpace): ExprValue;
-}

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

@@ -1,148 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GranularLiteral = void 0;
-const luxon_1 = require("luxon");
-const malloy_types_1 = require("../../../model/malloy_types");
-const range_1 = require("./range");
-const expr_time_1 = require("./expr-time");
-const time_utils_1 = require("../time-utils");
-const expression_def_1 = require("../types/expression-def");
-/**
- * GranularTime made from a literal. Funky because it doesn't know if it
- * is a date or a timestamp in many cases until it is applied.
- */
-class GranularLiteral extends expression_def_1.ExpressionDef {
-    constructor(moment, until, units) {
-        super();
-        this.moment = moment;
-        this.until = until;
-        this.units = units;
-        this.elementType = 'timeLiteral';
-    }
-    granular() {
-        return true;
-    }
-    static parse(possibleLiteral) {
-        const s = possibleLiteral.slice(1);
-        const fYear = 'yyyy';
-        const fMonth = `${fYear}-LL`;
-        const fDay = `${fMonth}-dd`;
-        const fMinute = `${fDay} HH:mm`;
-        const fSecond = `${fMinute}:ss`;
-        const tss = luxon_1.DateTime.fromFormat(s, fSecond);
-        if (tss.isValid) {
-            const nextSecond = tss.plus({ second: 1 }).toFormat(fSecond);
-            const tsLit = new GranularLiteral(s, nextSecond, 'second');
-            tsLit.timeType = 'timestamp';
-            return tsLit;
-        }
-        const tsm = luxon_1.DateTime.fromFormat(s, fMinute);
-        if (tsm.isValid) {
-            // working around a weird bigquery bug ...
-            const thisMin = s + ':00';
-            const nextMinute = tsm.plus({ minute: 1 }).toFormat(fMinute) + ':00';
-            const tsLit = new GranularLiteral(thisMin, nextMinute, 'minute');
-            tsLit.timeType = 'timestamp';
-            return tsLit;
-        }
-        const quarter = s.match(/(\d{4})-[qQ](\d)$/);
-        if (quarter) {
-            const qplus = Number.parseInt(quarter[2]) - 1;
-            let qstart = luxon_1.DateTime.fromFormat(quarter[1], 'yyyy');
-            if (qplus > 0) {
-                qstart = qstart.plus({ quarters: qplus });
-            }
-            const qend = qstart.plus({ quarter: 1 });
-            return new GranularLiteral(`${qstart.toFormat(fDay)}`, `${qend.toFormat(fDay)}`, 'quarter');
-        }
-        const yyyymmdd = luxon_1.DateTime.fromFormat(s, fDay);
-        if (yyyymmdd.isValid) {
-            const next = yyyymmdd.plus({ days: 1 });
-            return new GranularLiteral(`${yyyymmdd.toFormat(fDay)}`, `${next.toFormat(fDay)}`, 'day');
-        }
-        const yyyymm = luxon_1.DateTime.fromFormat(s, fMonth);
-        if (yyyymm.isValid) {
-            const next = yyyymm.plus({ months: 1 });
-            return new GranularLiteral(`${yyyymm.toFormat(fDay)}`, `${next.toFormat(fDay)}`, 'month');
-        }
-        const yyyy = luxon_1.DateTime.fromFormat(s, fYear);
-        if (yyyy.isValid) {
-            const year = yyyy.toFormat('yyyy-01-01');
-            const nextYear = yyyy.plus({ year: 1 }).toFormat('yyyy-01-01');
-            return new GranularLiteral(year, nextYear, 'year');
-        }
-        if (s.startsWith('WK')) {
-            const yyyymmdd = luxon_1.DateTime.fromFormat(s.slice(2), fDay);
-            if (yyyymmdd.isValid) {
-                // wonky because luxon uses monday weeks and bigquery uses sunday weeks
-                let sunday = yyyymmdd;
-                if (yyyymmdd.weekday !== 7) {
-                    sunday = yyyymmdd.startOf('week').minus({ day: 1 });
-                }
-                const next = sunday.plus({ days: 7 });
-                return new GranularLiteral(`${sunday.toFormat(fDay)}`, `${next.toFormat(fDay)}`, 'week');
-            }
-        }
-        return undefined;
-    }
-    apply(fs, op, left) {
-        const lhs = left.getExpression(fs);
-        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
-            let rangeType = 'timestamp';
-            if (lhs.dataType === 'date' && !this.timeType) {
-                rangeType = 'date';
-            }
-            const range = new range_1.Range(new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.moment, rangeType, 'UTC')), new expr_time_1.ExprTime(rangeType, (0, time_utils_1.timeLiteral)(this.until, rangeType, 'UTC')));
-            return range.apply(fs, op, left);
-        }
-        return super.apply(fs, op, left);
-    }
-    getExpression(_fs) {
-        const dataType = this.timeType || 'date';
-        const value = {
-            dataType,
-            expressionType: 'scalar',
-            value: (0, time_utils_1.timeLiteral)(this.moment, dataType, 'UTC'),
-        };
-        // Literals with date resolution can be used as timestamps or dates,
-        // this is the third attempt to make that work. It still feels like
-        // there should be a better way to make this happen, but the point
-        // at which the data is needed, the handle is gone to the ExpressionDef
-        // which would allow a method call into this class. I think the second
-        // if clause is redundant (see "parse" above, but I'm paranoid)
-        if (dataType === 'date' && (0, malloy_types_1.isDateUnit)(this.units)) {
-            value.alsoTimestamp = true;
-        }
-        if (this.units !== 'second') {
-            return {
-                ...value,
-                timeframe: this.units,
-            };
-        }
-        return value;
-    }
-}
-exports.GranularLiteral = GranularLiteral;
-//# sourceMappingURL=granular-literal.js.map