@malloydata/malloy 0.0.1

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

@@ -0,0 +1,109 @@
+import { TimestampUnit, ExtractUnit, TimeFieldType } from "../../model/malloy_types";
+import { FSPair } from "../field-space";
+import { ExpressionDef, BinaryBoolean, ExprValue, MalloyElement, Comparison } from "./index";
+export declare class Timeframe extends MalloyElement {
+    elementType: string;
+    readonly text: TimestampUnit;
+    constructor(timeframeName: string);
+}
+/**
+ * GranularTime is a moment in time which ALSO has a "granularity"
+ * commonly this are created by applying ".datePart" to an expression
+ * 1) They have a value, which is the moment in time
+ * 2) When used in a comparison, they act like a range, for the
+ *    duration of 1 unit of granularity
+ */
+export declare class ExprGranularTime extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly units: TimestampUnit;
+    readonly truncate: boolean;
+    elementType: string;
+    legalChildTypes: import("./ast-types").FragType[];
+    constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
+    granular(): boolean;
+    getExpression(fs: FSPair): ExprValue;
+    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
+    protected timestampRange(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    protected dateRange(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+}
+/**
+ * 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: FSPair, op: string, left: ExpressionDef): ExprValue;
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class ExprNow extends ExpressionDef {
+    elementType: string;
+    getExpression(_fs: FSPair): ExprValue;
+}
+export declare class ExprDuration extends ExpressionDef {
+    readonly n: ExpressionDef;
+    readonly timeframe: TimestampUnit;
+    elementType: string;
+    legalChildTypes: import("./ast-types").FragType[];
+    constructor(n: ExpressionDef, timeframe: TimestampUnit);
+    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
+    getExpression(_fs: FSPair): ExprValue;
+}
+export declare class ExprCompare extends BinaryBoolean<Comparison> {
+    elementType: string;
+    constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class Apply extends ExprCompare {
+    readonly left: ExpressionDef;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(left: ExpressionDef, right: ExpressionDef);
+}
+export declare class PartialCompare extends ExpressionDef {
+    readonly op: Comparison;
+    readonly right: ExpressionDef;
+    elementType: string;
+    constructor(op: Comparison, right: ExpressionDef);
+    granular(): boolean;
+    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FSPair): ExprValue | undefined;
+    getExpression(_fs: FSPair): ExprValue;
+}
+/**
+ * TODO: This is sort of a hand clone of the "Range" class, they should
+ * be siblings of a common abstract classs.
+ */
+export declare class ForRange extends ExpressionDef {
+    readonly from: ExpressionDef;
+    readonly duration: ExpressionDef;
+    readonly timeframe: Timeframe;
+    elementType: string;
+    legalChildTypes: import("./ast-types").FragType[];
+    constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
+    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FSPair): ExprValue | undefined;
+    getExpression(_fs: FSPair): ExprValue;
+}
+export declare class ExprTimeExtract extends ExpressionDef {
+    readonly extractText: string;
+    readonly args: ExpressionDef[];
+    elementType: string;
+    static pluralMap: Record<string, ExtractUnit>;
+    static extractor(funcName: string): ExtractUnit | undefined;
+    constructor(extractText: string, args: ExpressionDef[]);
+    getExpression(fs: FSPair): ExprValue;
+}
+export declare class ExprFunc extends ExpressionDef {
+    readonly name: string;
+    readonly args: ExpressionDef[];
+    elementType: string;
+    constructor(name: string, args: ExpressionDef[]);
+    getExpression(fs: FSPair): ExprValue;
+}

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

@@ -0,0 +1,550 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprFunc = exports.ExprTimeExtract = exports.ForRange = exports.PartialCompare = exports.Apply = exports.ExprCompare = exports.ExprDuration = exports.ExprNow = exports.GranularLiteral = exports.ExprGranularTime = exports.Timeframe = void 0;
+const luxon_1 = require("luxon");
+const malloy_types_1 = require("../../model/malloy_types");
+const index_1 = require("./index");
+class Timeframe extends index_1.MalloyElement {
+    constructor(timeframeName) {
+        super();
+        this.elementType = "timeframe";
+        let tf = timeframeName.toLowerCase();
+        if (tf.endsWith("s")) {
+            tf = tf.slice(0, -1);
+        }
+        this.text = (0, malloy_types_1.isTimestampUnit)(tf) ? tf : "second";
+    }
+}
+exports.Timeframe = Timeframe;
+/**
+ * GranularTime is a moment in time which ALSO has a "granularity"
+ * commonly this are created by applying ".datePart" to an expression
+ * 1) They have a value, which is the moment in time
+ * 2) When used in a comparison, they act like a range, for the
+ *    duration of 1 unit of granularity
+ */
+class ExprGranularTime extends index_1.ExpressionDef {
+    constructor(expr, units, truncate) {
+        super({ expr });
+        this.expr = expr;
+        this.units = units;
+        this.truncate = truncate;
+        this.elementType = "granularTime";
+        this.legalChildTypes = [index_1.FT.timestampT, index_1.FT.dateT];
+    }
+    granular() {
+        return true;
+    }
+    getExpression(fs) {
+        const timeframe = this.units;
+        const exprVal = this.expr.getExpression(fs);
+        if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
+            const tsVal = {
+                ...exprVal,
+                dataType: exprVal.dataType,
+                timeframe: timeframe,
+            };
+            if (this.truncate) {
+                tsVal.value = [
+                    {
+                        type: "dialect",
+                        function: "trunc",
+                        expr: { value: exprVal.value, valueType: exprVal.dataType },
+                        units: timeframe,
+                    },
+                ];
+            }
+            return tsVal;
+        }
+        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
+        return (0, index_1.errorFor)(`granularity typecheck`);
+    }
+    apply(fs, op, left) {
+        const rangeType = this.getExpression(fs).dataType;
+        const _valueType = left.getExpression(fs).dataType;
+        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? "date" : "timestamp";
+        if (rangeType == "date" && granularityType == "date") {
+            return this.dateRange(fs, op, left);
+        }
+        return this.timestampRange(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
+    
+        */
+    }
+    timestampRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = index_1.ExprTime.fromValue("timestamp", begin);
+        const endTime = new index_1.ExprTime("timestamp", (0, index_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.aggregate);
+        const range = new index_1.Range(beginTime, endTime);
+        return range.apply(fs, op, expr);
+    }
+    dateRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = new index_1.ExprTime("date", begin.value, begin.aggregate);
+        const endAt = (0, index_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
+        const end = new index_1.ExprTime("date", endAt, begin.aggregate);
+        const range = new index_1.Range(beginTime, end);
+        return range.apply(fs, op, expr);
+    }
+}
+exports.ExprGranularTime = ExprGranularTime;
+/**
+ * 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 index_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 dialect = fs.in.getDialect();
+            const range = new index_1.Range(new index_1.ExprTime(rangeType, dialect.sqlLiteralTime(this.moment, rangeType, "UTC")), new index_1.ExprTime(rangeType, dialect.sqlLiteralTime(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,
+            aggregate: false,
+            value: [fs.in.getDialect().sqlLiteralTime(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;
+class ExprNow extends index_1.ExpressionDef {
+    constructor() {
+        super(...arguments);
+        this.elementType = "timestamp";
+    }
+    getExpression(_fs) {
+        return {
+            dataType: "timestamp",
+            aggregate: false,
+            value: [
+                {
+                    type: "dialect",
+                    function: "now",
+                },
+            ],
+        };
+    }
+}
+exports.ExprNow = ExprNow;
+class ExprDuration extends index_1.ExpressionDef {
+    constructor(n, timeframe) {
+        super({ n });
+        this.n = n;
+        this.timeframe = timeframe;
+        this.elementType = "duration";
+        this.legalChildTypes = [index_1.FT.timestampT, index_1.FT.dateT];
+    }
+    apply(fs, op, left) {
+        const lhs = left.getExpression(fs);
+        this.typeCheck(this, lhs);
+        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === "+" || op === "-")) {
+            const num = this.n.getExpression(fs);
+            if (!index_1.FT.typeEq(num, index_1.FT.numberT)) {
+                this.log(`Duration units needs number not '${num.dataType}`);
+                return (0, index_1.errorFor)("illegal unit expression");
+            }
+            let resultGranularity;
+            // Only allow the output of this to be granular if the
+            // granularities match, this is still an area where
+            // more thought is required.
+            if ((0, index_1.isGranularResult)(lhs) && lhs.timeframe == this.timeframe) {
+                resultGranularity = lhs.timeframe;
+            }
+            if (lhs.dataType === "timestamp") {
+                const result = (0, index_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
+                return (0, index_1.timeResult)({
+                    dataType: "timestamp",
+                    aggregate: lhs.aggregate || num.aggregate,
+                    value: result,
+                }, resultGranularity);
+            }
+            return (0, index_1.timeResult)({
+                dataType: "date",
+                aggregate: lhs.aggregate || num.aggregate,
+                value: (0, index_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
+            }, resultGranularity);
+        }
+        return super.apply(fs, op, left);
+    }
+    getExpression(_fs) {
+        return {
+            dataType: "duration",
+            aggregate: false,
+            value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
+        };
+    }
+}
+exports.ExprDuration = ExprDuration;
+class ExprCompare extends index_1.BinaryBoolean {
+    constructor(left, op, right) {
+        super(left, op, right);
+        this.elementType = "a<=>b";
+        this.legalChildTypes = compareTypes[op];
+    }
+    getExpression(fs) {
+        if (!this.right.granular()) {
+            const rhs = this.right.requestExpression(fs);
+            if (rhs && (0, index_1.isGranularResult)(rhs)) {
+                const newRight = new ExprGranularTime(this.right, rhs.timeframe, false);
+                return newRight.apply(fs, this.op, this.left);
+            }
+        }
+        return this.right.apply(fs, this.op, this.left);
+    }
+}
+exports.ExprCompare = ExprCompare;
+class Apply extends ExprCompare {
+    constructor(left, right) {
+        super(left, "=", right);
+        this.left = left;
+        this.right = right;
+        this.elementType = "apply";
+    }
+}
+exports.Apply = Apply;
+const compareTypes = {
+    "~": [index_1.FT.stringT],
+    "!~": [index_1.FT.stringT],
+    "<": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
+    "<=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
+    "=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
+    "!=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
+    ">=": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
+    ">": [index_1.FT.numberT, index_1.FT.stringT, index_1.FT.dateT, index_1.FT.timestampT],
+};
+class PartialCompare extends index_1.ExpressionDef {
+    constructor(op, right) {
+        super({ right });
+        this.op = op;
+        this.right = right;
+        this.elementType = "<=> a";
+    }
+    granular() {
+        return this.right.granular();
+    }
+    apply(fs, op, expr) {
+        return this.right.apply(fs, this.op, expr);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log(`Partial comparison does not have a value`);
+        return (0, index_1.errorFor)("no value for partial compare");
+    }
+}
+exports.PartialCompare = PartialCompare;
+/**
+ * TODO: This is sort of a hand clone of the "Range" class, they should
+ * be siblings of a common abstract classs.
+ */
+class ForRange extends index_1.ExpressionDef {
+    constructor(from, duration, timeframe) {
+        super({ from, duration, timeframe });
+        this.from = from;
+        this.duration = duration;
+        this.timeframe = timeframe;
+        this.elementType = "forRange";
+        this.legalChildTypes = [index_1.FT.timestampT, index_1.FT.dateT];
+    }
+    apply(fs, op, expr) {
+        const startV = this.from.getExpression(fs);
+        const checkV = expr.getExpression(fs);
+        if (!this.typeCheck(expr, checkV)) {
+            return (0, index_1.errorFor)("no time for range");
+        }
+        const nV = this.duration.getExpression(fs);
+        if (nV.dataType !== "number") {
+            this.log(`FOR duration count must be a number, not '${nV.dataType}'`);
+            return (0, index_1.errorFor)("FOR not number");
+        }
+        const units = this.timeframe.text;
+        // If the duration resolution is smaller than date, we have
+        // to do the computaion with timestamps.
+        const durationRes = (0, index_1.resolution)(units);
+        let rangeType = durationRes;
+        // Next, if the beginning of the range is a timestamp, then we
+        // also have to do the computation as a timestamp
+        if (startV.dataType === "timestamp") {
+            rangeType = "timestamp";
+        }
+        // everything is dates, do date math
+        if (checkV.dataType === "date" && rangeType === "date") {
+            const rangeStart = this.from;
+            const rangeEndV = (0, index_1.timeOffset)("date", startV.value, "+", nV.value, units);
+            const rangeEnd = new index_1.ExprTime("date", rangeEndV);
+            return new index_1.Range(rangeStart, rangeEnd).apply(fs, op, expr);
+        }
+        // Now it doesn't matter if the range is a date or a timestamp,
+        // the comparison will be in timestamp space,
+        const applyTo = index_1.ExprTime.fromValue("timestamp", checkV);
+        let rangeStart = this.from;
+        let from = startV.value;
+        if (startV.dataType === "date") {
+            // Time literals with timestamp units can also be used as timestamps;
+            const alreadyTs = (0, index_1.isGranularResult)(startV) && startV.alsoTimestamp;
+            if (!alreadyTs) {
+                // ... not a literal, need a cast
+                from = (0, index_1.castDateToTimestamp)(from);
+            }
+            rangeStart = new index_1.ExprTime("timestamp", from, startV.aggregate);
+        }
+        const to = (0, index_1.timeOffset)("timestamp", from, "+", nV.value, units);
+        const rangeEnd = new index_1.ExprTime("timestamp", to, startV.aggregate);
+        return new index_1.Range(rangeStart, rangeEnd).apply(fs, op, applyTo);
+    }
+    requestExpression(_fs) {
+        return undefined;
+    }
+    getExpression(_fs) {
+        this.log("A Range is not a value");
+        return (0, index_1.errorFor)("range has no value");
+    }
+}
+exports.ForRange = ForRange;
+class ExprTimeExtract extends index_1.ExpressionDef {
+    constructor(extractText, args) {
+        super({ args });
+        this.extractText = extractText;
+        this.args = args;
+        this.elementType = "timeExtract";
+    }
+    static extractor(funcName) {
+        const mappedName = ExprTimeExtract.pluralMap[funcName];
+        if (mappedName) {
+            return mappedName;
+        }
+        if ((0, malloy_types_1.isExtractUnit)(funcName)) {
+            return funcName;
+        }
+    }
+    getExpression(fs) {
+        const extractTo = ExprTimeExtract.extractor(this.extractText);
+        if (extractTo) {
+            if (this.args.length !== 1) {
+                this.log(`Extraction function ${extractTo} requires one argument`);
+                return (0, index_1.errorFor)(`{this.name} arg count`);
+            }
+            const from = this.args[0];
+            if (from instanceof index_1.Range) {
+                const first = from.first.getExpression(fs);
+                const last = from.last.getExpression(fs);
+                if (!(0, malloy_types_1.isTimeFieldType)(first.dataType)) {
+                    from.first.log(`Can't extract ${extractTo} from '${first.dataType}'`);
+                    return (0, index_1.errorFor)(`${extractTo} bad type ${first.dataType}`);
+                }
+                if (!(0, malloy_types_1.isTimeFieldType)(last.dataType)) {
+                    from.last.log(`Cannot extract ${extractTo} from '${last.dataType}'`);
+                    return (0, index_1.errorFor)(`${extractTo} bad type ${last.dataType}`);
+                }
+                if (!(0, malloy_types_1.isTimestampUnit)(extractTo)) {
+                    this.log(`Cannot extract ${extractTo} from a range`);
+                    return (0, index_1.errorFor)(`${extractTo} bad extraction`);
+                }
+                return {
+                    dataType: "number",
+                    aggregate: first.aggregate || last.aggregate,
+                    value: [
+                        {
+                            type: "dialect",
+                            function: "timeDiff",
+                            units: extractTo,
+                            left: { valueType: first.dataType, value: first.value },
+                            right: { valueType: last.dataType, value: last.value },
+                        },
+                    ],
+                };
+            }
+            else {
+                const argV = from.getExpression(fs);
+                if ((0, malloy_types_1.isTimeFieldType)(argV.dataType)) {
+                    return {
+                        dataType: "number",
+                        aggregate: argV.aggregate,
+                        value: [
+                            {
+                                type: "dialect",
+                                function: "extract",
+                                expr: { value: argV.value, valueType: argV.dataType },
+                                units: extractTo,
+                            },
+                        ],
+                    };
+                }
+                this.log(`${this.extractText}() requires time type, not '${argV.dataType}'`);
+                return (0, index_1.errorFor)(`${this.extractText} bad type ${argV.dataType}`);
+            }
+        }
+        throw this.internalError(`Illegal extraction unit '${this.extractText}'`);
+    }
+}
+exports.ExprTimeExtract = ExprTimeExtract;
+ExprTimeExtract.pluralMap = {
+    years: "year",
+    quarters: "quarter",
+    months: "month",
+    weeks: "week",
+    days: "day",
+    hours: "hour",
+    minutes: "minute",
+    seconds: "second",
+};
+class ExprFunc extends index_1.ExpressionDef {
+    constructor(name, args) {
+        super({ args });
+        this.name = name;
+        this.args = args;
+        this.elementType = "function call()";
+    }
+    getExpression(fs) {
+        var _a, _b;
+        let anyAggregate = false;
+        let collectType;
+        const funcCall = [`${this.name}(`];
+        for (const fexpr of this.args) {
+            const expr = fexpr.getExpression(fs);
+            if (expr.aggregate) {
+                anyAggregate = true;
+            }
+            if (collectType) {
+                funcCall.push(",");
+            }
+            else {
+                collectType = expr.dataType;
+            }
+            funcCall.push(...expr.value);
+        }
+        funcCall.push(")");
+        const funcInfo = fs.in.getDialect().getFunctionInfo(this.name);
+        const dataType = (_b = (_a = funcInfo === null || funcInfo === void 0 ? void 0 : funcInfo.returnType) !== null && _a !== void 0 ? _a : collectType) !== null && _b !== void 0 ? _b : "number";
+        return {
+            dataType: dataType,
+            aggregate: anyAggregate,
+            value: (0, index_1.compressExpr)(funcCall),
+        };
+    }
+}
+exports.ExprFunc = ExprFunc;
+//# sourceMappingURL=ast-time-expr.js.map