@malloydata/malloy 0.0.2 → 0.0.4

package/dist/dialect/standardsql.js

@@ -1,361 +0,0 @@
-"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.StandardSQLDialect = void 0;
-const utils_1 = require("../model/utils");
-const model_1 = require("../model");
-const dialect_1 = require("./dialect");
-const castMap = {
-    number: "float64",
-};
-// These are the units that "TIMESTAMP_ADD" accepts
-const timestampAddUnits = [
-    "microsecond",
-    "millisecond",
-    "second",
-    "minute",
-    "hour",
-    "day",
-];
-const extractMap = {
-    day_of_week: "dayofweek",
-    day_of_year: "dayofyear",
-};
-class StandardSQLDialect extends dialect_1.Dialect {
-    constructor() {
-        super(...arguments);
-        this.name = "standardsql";
-        this.defaultNumberType = "FLOAT64";
-        this.udfPrefix = "__udf";
-        this.hasFinalStage = false;
-        this.stringTypeName = "STRING";
-        this.divisionIsInteger = false;
-        this.supportsSumDistinctFunction = false;
-        this.unnestWithNumbers = false;
-        this.defaultSampling = { enable: false };
-        this.supportUnnestArrayAgg = false;
-        this.supportsCTEinCoorelatedSubQueries = false;
-        this.functionInfo = {
-            timestamp_seconds: { returnType: "timestamp" },
-        };
-        this.keywords = `
-  ALL
-  AND
-  ANY
-  ARRAY
-  AS
-  ASC
-  ASSERT_ROWS_MODIFIED
-  AT
-  BETWEEN
-  BY
-  CASE
-  CAST
-  COLLATE
-  CONTAINS
-  CREATE
-  CROSS
-  CUBE
-  CURRENT
-  DEFAULT
-  DEFINE
-  DESC
-  DISTINCT
-  ELSE
-  END
-  ENUM
-  ESCAPE
-  EXCEPT
-  EXCLUDE
-  EXISTS
-  EXTRACT
-  FALSE
-  FETCH
-  FOLLOWING
-  FOR
-  FROM
-  FULL
-  GROUP
-  GROUPING
-  GROUPS
-  HASH
-  HAVING
-  IF
-  IGNORE
-  IN
-  INNER
-  INTERSECT
-  INTERVAL
-  INTO
-  IS
-  JOIN
-  LATERAL
-  LEFT
-  LIKE
-  LIMIT
-  LOOKUP
-  MERGE
-  NATURAL
-  NEW
-  NO
-  NOT
-  NULL
-  NULLS
-  OF
-  ON
-  OR
-  ORDER
-  OUTER
-  OVER
-  PARTITION
-  PRECEDING
-  PROTO
-  RANGE
-  RECURSIVE
-  RESPECT
-  RIGHT
-  ROLLUP
-  ROWS
-  SELECT
-  SET
-  SOME
-  STRUCT
-  TABLESAMPLE
-  THEN
-  TO
-  TREAT
-  TRUE
-  UNBOUNDED
-  UNION
-  UNNEST
-  USING
-  WHEN
-  WHERE
-  WINDOW
-  WITH
-  WITHIN`.split(/\s/);
-    }
-    quoteTablePath(tablePath) {
-        return `\`${tablePath}\``;
-    }
-    sqlGroupSetTable(groupSetCount) {
-        return `CROSS JOIN (SELECT row_number() OVER() -1  group_set FROM UNNEST(GENERATE_ARRAY(0,${groupSetCount},1)))`;
-    }
-    sqlAnyValue(groupSet, fieldName) {
-        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${fieldName} END)`;
-    }
-    // can array agg or any_value a struct...
-    sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
-        let tail = "";
-        if (limit !== undefined) {
-            tail += ` LIMIT ${limit}`;
-        }
-        const fields = fieldList
-            .map((f) => `\n  ${f.sqlExpression} as ${f.sqlOutputName}`)
-            .join(", ");
-        return `ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}\n  ) END IGNORE NULLS ${orderBy} ${tail})`;
-    }
-    sqlAnyValueTurtle(groupSet, fieldList) {
-        const fields = fieldList
-            .map((f) => `${f.sqlExpression} as ${f.sqlOutputName}`)
-            .join(", ");
-        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}))`;
-    }
-    sqlAnyValueLastTurtle(name, groupSet, sqlName) {
-        return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${name}__${groupSet} END) as ${sqlName}`;
-    }
-    sqlCoaleseMeasuresInline(groupSet, fieldList) {
-        const fields = fieldList
-            .map((f) => `${f.sqlExpression} as ${f.sqlOutputName}`)
-            .join(", ");
-        const nullValues = fieldList
-            .map((f) => `NULL as ${f.sqlOutputName}`)
-            .join(", ");
-        return `COALESCE(ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}) END), STRUCT(${nullValues}))`;
-    }
-    //
-    // this code used to be:
-    //
-    //   from += `JOIN UNNEST(GENERATE_ARRAY(0,${this.maxGroupSet},1)) as group_set\n`;
-    //
-    // BigQuery will allocate more resources if we use a CROSS JOIN so we do that instead.
-    //
-    sqlUnnestAlias(source, alias, fieldList, needDistinctKey, isArray) {
-        if (isArray) {
-            if (needDistinctKey) {
-                return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, value FROM UNNEST(${source}) value))) as ${alias}`;
-            }
-            else {
-                return `LEFT JOIN UNNEST(ARRAY((SELECT AS STRUCT value FROM unnest(${source}) value))) as ${alias}`;
-            }
-        }
-        else if (needDistinctKey) {
-            return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, * FROM UNNEST(${source})))) as ${alias}`;
-        }
-        else {
-            return `LEFT JOIN UNNEST(${source}) as ${alias}`;
-        }
-    }
-    sqlSumDistinctHashedKey(sqlDistinctKey) {
-        sqlDistinctKey = `CAST(${sqlDistinctKey} AS STRING)`;
-        const upperPart = `cast(cast(concat('0x', substr(to_hex(md5(${sqlDistinctKey})), 1, 15)) as int64) as numeric) * 4294967296`;
-        const lowerPart = `cast(cast(concat('0x', substr(to_hex(md5(${sqlDistinctKey})), 16, 8)) as int64) as numeric)`;
-        // See the comment below on `sql_sum_distinct` for why we multiply by this decimal
-        const precisionShiftMultiplier = "0.000000001";
-        return `(${upperPart} + ${lowerPart}) * ${precisionShiftMultiplier}`;
-    }
-    sqlGenerateUUID() {
-        return `GENERATE_UUID()`;
-    }
-    sqlFieldReference(alias, fieldName, _fieldType, _isNested, _isArray) {
-        return `${alias}.${fieldName}`;
-    }
-    sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
-        let p = sourceSQLExpression;
-        if (isSingleton) {
-            p = `[${p}]`;
-        }
-        return `UNNEST(${p})`;
-    }
-    sqlCreateFunction(id, funcText) {
-        return `CREATE TEMPORARY FUNCTION ${id}(__param ANY TYPE) AS ((\n${(0, utils_1.indent)(funcText)}));\n`;
-    }
-    sqlCreateTableAsSelect(tableName, sql) {
-        return `
-CREATE TABLE IF NOT EXISTS \`${tableName}\`
-OPTIONS (
-    expiration_timestamp=TIMESTAMP_ADD(current_timestamp(),  INTERVAL 1 hour)
-)
-AS (
-${(0, utils_1.indent)(sql)}
-);
-`;
-    }
-    sqlCreateFunctionCombineLastStage(lastStageName) {
-        return `SELECT ARRAY((SELECT AS STRUCT * FROM ${lastStageName}))\n`;
-    }
-    sqlSelectAliasAsStruct(alias) {
-        return `(SELECT AS STRUCT ${alias}.*)`;
-    }
-    sqlMaybeQuoteIdentifier(identifier) {
-        return this.keywords.indexOf(identifier.toUpperCase()) > 0
-            ? "`" + identifier + "`"
-            : identifier;
-    }
-    sqlNow() {
-        return (0, model_1.mkExpr) `CURRENT_TIMESTAMP()`;
-    }
-    sqlTrunc(sqlTime, units) {
-        if (sqlTime.valueType == "date") {
-            if ((0, model_1.isDateUnit)(units)) {
-                return (0, model_1.mkExpr) `DATE_TRUNC(${sqlTime.value},${units})`;
-            }
-            return (0, model_1.mkExpr) `TIMESTAMP(${sqlTime.value})`;
-        }
-        return (0, model_1.mkExpr) `TIMESTAMP_TRUNC(${sqlTime.value},${units})`;
-    }
-    sqlExtract(expr, units) {
-        const extractTo = extractMap[units] || units;
-        return (0, model_1.mkExpr) `EXTRACT(${extractTo} FROM ${expr.value})`;
-    }
-    sqlAlterTime(op, expr, n, timeframe) {
-        let theTime = expr.value;
-        let computeType = expr.valueType;
-        if (timeframe != "day" && timestampAddUnits.includes(timeframe)) {
-            // The units must be done in timestamp, no matter the input type
-            computeType = "timestamp";
-            if (expr.valueType != "timestamp") {
-                theTime = (0, model_1.mkExpr) `TIMESTAMP(${theTime})`;
-            }
-        }
-        else if (expr.valueType == "timestamp") {
-            theTime = (0, model_1.mkExpr) `DATETIME(${theTime})`;
-            computeType = "datetime";
-        }
-        const funcName = computeType.toUpperCase() + (op == "+" ? "_ADD" : "_SUB");
-        const newTime = (0, model_1.mkExpr) `${funcName}(${theTime}, INTERVAL ${n} ${timeframe})`;
-        return computeType == "datetime" ? (0, model_1.mkExpr) `TIMESTAMP(${newTime})` : newTime;
-    }
-    ignoreInProject(fieldName) {
-        return fieldName === "_PARTITIONTIME";
-    }
-    sqlCast(cast) {
-        if (cast.srcType !== cast.dstType) {
-            const dstType = castMap[cast.dstType] || cast.dstType;
-            // This just makes the code look a little prettier ...
-            if (!cast.safe && cast.srcType && (0, model_1.isTimeFieldType)(cast.srcType)) {
-                if (dstType == "date") {
-                    return (0, model_1.mkExpr) `DATE(${cast.expr})`;
-                }
-                return (0, model_1.mkExpr) `TIMESTAMP(${cast.expr})`;
-            }
-            const castFunc = cast.safe ? "SAFE_CAST" : "CAST";
-            return (0, model_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
-        }
-        return cast.expr;
-    }
-    sqlRegexpMatch(expr, regexp) {
-        return (0, model_1.mkExpr) `REGEXP_CONTAINS(${expr}, r${regexp})`;
-    }
-    sqlLiteralTime(timeString, type, timezone) {
-        if (type === "date") {
-            return `DATE('${timeString}')`;
-        }
-        else if (type === "timestamp") {
-            return `TIMESTAMP('${timeString}', '${timezone}')`;
-        }
-        else {
-            throw new Error(`Unknown Liternal time format ${type}`);
-        }
-    }
-    sqlMeasureTime(from, to, units) {
-        let lVal = from.value;
-        let rVal = to.value;
-        let diffUsing = "TIMESTAMP_DIFF";
-        if (units == "second" || units == "minute" || units == "hour") {
-            if (from.valueType != "timestamp") {
-                lVal = (0, model_1.mkExpr) `TIMESTAMP(${lVal})`;
-            }
-            if (to.valueType != "timestamp") {
-                rVal = (0, model_1.mkExpr) `TIMESTAMP(${rVal})`;
-            }
-        }
-        else {
-            diffUsing = "DATE_DIFF";
-            if (from.valueType != "date") {
-                lVal = (0, model_1.mkExpr) `DATE(${lVal})`;
-            }
-            if (to.valueType != "date") {
-                rVal = (0, model_1.mkExpr) `DATE(${rVal})`;
-            }
-        }
-        return (0, model_1.mkExpr) `${diffUsing}(${rVal}, ${lVal}, ${units})`;
-    }
-    sqlSampleTable(tableSQL, sample) {
-        if (sample !== undefined) {
-            if ((0, model_1.isSamplingEnable)(sample) && sample.enable) {
-                sample = this.defaultSampling;
-            }
-            if ((0, model_1.isSamplingRows)(sample)) {
-                throw new Error(`StandardSQL doesn't support sampling by rows only percent`);
-            }
-            else if ((0, model_1.isSamplingPercent)(sample)) {
-                return `(SELECT * FROM ${tableSQL}  TABLESAMPLE SYSTEM (${sample.percent} PERCENT))`;
-            }
-        }
-        return tableSQL;
-    }
-}
-exports.StandardSQLDialect = StandardSQLDialect;
-//# sourceMappingURL=standardsql.js.map

package/dist/index.js

@@ -1,47 +0,0 @@
-"use strict";
-/*
- * Copyright 2022 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.toAsyncGenerator = exports.DataWriter = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.parseTableURL = exports.Result = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.MalloyTranslator = exports.HighlightType = exports.isFilteredAliasedName = exports.Segment = void 0;
-var model_1 = require("./model");
-// Used in Composer Demo
-Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return model_1.Segment; } });
-Object.defineProperty(exports, "isFilteredAliasedName", { enumerable: true, get: function () { return model_1.isFilteredAliasedName; } });
-var lang_1 = require("./lang");
-// Neede for VSCode extension
-Object.defineProperty(exports, "HighlightType", { enumerable: true, get: function () { return lang_1.HighlightType; } });
-// Needed for tests only
-Object.defineProperty(exports, "MalloyTranslator", { enumerable: true, get: function () { return lang_1.MalloyTranslator; } });
-var malloy_1 = require("./malloy");
-Object.defineProperty(exports, "Malloy", { enumerable: true, get: function () { return malloy_1.Malloy; } });
-Object.defineProperty(exports, "Runtime", { enumerable: true, get: function () { return malloy_1.Runtime; } });
-Object.defineProperty(exports, "AtomicFieldType", { enumerable: true, get: function () { return malloy_1.AtomicFieldType; } });
-Object.defineProperty(exports, "ConnectionRuntime", { enumerable: true, get: function () { return malloy_1.ConnectionRuntime; } });
-Object.defineProperty(exports, "SingleConnectionRuntime", { enumerable: true, get: function () { return malloy_1.SingleConnectionRuntime; } });
-Object.defineProperty(exports, "EmptyURLReader", { enumerable: true, get: function () { return malloy_1.EmptyURLReader; } });
-Object.defineProperty(exports, "InMemoryURLReader", { enumerable: true, get: function () { return malloy_1.InMemoryURLReader; } });
-Object.defineProperty(exports, "FixedConnectionMap", { enumerable: true, get: function () { return malloy_1.FixedConnectionMap; } });
-Object.defineProperty(exports, "MalloyError", { enumerable: true, get: function () { return malloy_1.MalloyError; } });
-Object.defineProperty(exports, "JoinRelationship", { enumerable: true, get: function () { return malloy_1.JoinRelationship; } });
-Object.defineProperty(exports, "SourceRelationship", { enumerable: true, get: function () { return malloy_1.SourceRelationship; } });
-Object.defineProperty(exports, "DateTimeframe", { enumerable: true, get: function () { return malloy_1.DateTimeframe; } });
-Object.defineProperty(exports, "TimestampTimeframe", { enumerable: true, get: function () { return malloy_1.TimestampTimeframe; } });
-Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return malloy_1.Result; } });
-Object.defineProperty(exports, "parseTableURL", { enumerable: true, get: function () { return malloy_1.parseTableURL; } });
-Object.defineProperty(exports, "QueryMaterializer", { enumerable: true, get: function () { return malloy_1.QueryMaterializer; } });
-Object.defineProperty(exports, "CSVWriter", { enumerable: true, get: function () { return malloy_1.CSVWriter; } });
-Object.defineProperty(exports, "JSONWriter", { enumerable: true, get: function () { return malloy_1.JSONWriter; } });
-Object.defineProperty(exports, "DataWriter", { enumerable: true, get: function () { return malloy_1.DataWriter; } });
-var connection_utils_1 = require("./connection_utils");
-Object.defineProperty(exports, "toAsyncGenerator", { enumerable: true, get: function () { return connection_utils_1.toAsyncGenerator; } });
-//# sourceMappingURL=index.js.map

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

@@ -1,231 +0,0 @@
-"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.nullsafeNot = exports.applyBinary = void 0;
-const malloy_types_1 = require("../../model/malloy_types");
-const index_1 = require("./index");
-/**
- * All of the magic of malloy expressions eventually flows to here,
- * where an operator is applied to two values. Depending on the
- * operator and value types this may involve transformations of
- * the values or even the operator.
- * @param fs FieldSpace for the symbols
- * @param left Left value
- * @param op The operator
- * @param right Right Value
- * @returns ExprValue of the expression
- */
-function applyBinary(fs, left, op, right) {
-    if ((0, index_1.isEquality)(op)) {
-        return equality(fs, left, op, right);
-    }
-    if ((0, index_1.isComparison)(op)) {
-        return compare(fs, left, op, right);
-    }
-    if (oneOf(op, "+", "-")) {
-        return delta(fs, left, op, right);
-    }
-    if (oneOf(op, "*")) {
-        return numeric(fs, left, op, right);
-    }
-    if (oneOf(op, "/")) {
-        const num = left.getExpression(fs);
-        const denom = right.getExpression(fs);
-        if (num.dataType != "number") {
-            left.log("Numerator for division mus tbe a number");
-        }
-        else if (denom.dataType != "number") {
-            right.log("Denominator for division mus tbe a number");
-        }
-        else {
-            const div = {
-                type: "dialect",
-                function: "div",
-                numerator: num.value,
-                denominator: denom.value,
-            };
-            return {
-                dataType: "number",
-                aggregate: num.aggregate || denom.aggregate,
-                value: [div],
-            };
-        }
-        return (0, index_1.errorFor)("divide type mismatch");
-    }
-    left.log(`Canot use ${op} operator here`);
-    return (0, index_1.errorFor)("applybinary bad operator");
-}
-exports.applyBinary = applyBinary;
-function oneOf(op, ...operators) {
-    return operators.includes(op);
-}
-function allAre(oneType, ...values) {
-    for (const v of values) {
-        if (v.dataType !== oneType) {
-            return false;
-        }
-    }
-    return true;
-}
-function regexEqual(left, right) {
-    if (left.dataType === "string") {
-        if (right.dataType === "regular expression") {
-            return [
-                {
-                    type: "dialect",
-                    function: "regexpMatch",
-                    expr: left.value,
-                    regexp: right.value[0].replace(/^r'/, "'"),
-                },
-            ];
-        }
-    }
-    else if (right.dataType === "string") {
-        if (left.dataType === "regular expression") {
-            return [
-                {
-                    type: "dialect",
-                    function: "regexpMatch",
-                    expr: right.value,
-                    regexp: left.value[0].replace(/^r'/, "'"),
-                },
-            ];
-        }
-    }
-    return undefined;
-}
-function nullCompare(left, op, right) {
-    const not = op === "!=" || op === "!~";
-    if (left.dataType === "null" || right.dataType === "null") {
-        const maybeNot = not ? " NOT" : "";
-        if (left.dataType !== "null") {
-            return [...left.value, ` IS${maybeNot} NULL`];
-        }
-        if (right.dataType !== "null") {
-            return [...right.value, `IS${maybeNot} NULL`];
-        }
-        return [not ? "false" : "true"];
-    }
-    return undefined;
-}
-function timeCompare(lhs, op, rhs) {
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (0, malloy_types_1.isTimeFieldType)(rhs.dataType)) {
-        if (lhs.dataType !== rhs.dataType) {
-            let lval = lhs.value;
-            let rval = rhs.value;
-            if (lhs.dataType === "timestamp") {
-                lval = (0, index_1.castTimestampToDate)(lval);
-            }
-            else {
-                rval = (0, index_1.castTimestampToDate)(rval);
-            }
-            return (0, index_1.compose)(lval, op, rval);
-        }
-    }
-    return undefined;
-}
-function nullsafeNot(expr, op) {
-    if (op === undefined || op === "!=" || op === "!~") {
-        return (0, malloy_types_1.mkExpr) `COALESCE(NOT(${expr}),FALSE)`;
-    }
-    return expr;
-}
-exports.nullsafeNot = nullsafeNot;
-function equality(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    let value = timeCompare(lhs, op, rhs) || (0, index_1.compose)(lhs.value, op, rhs.value);
-    if (lhs.dataType != "unknown" && rhs.dataType != "unknown") {
-        switch (op) {
-            case "~":
-            case "!~": {
-                if (lhs.dataType === "string" && rhs.dataType === "string") {
-                    value = (0, index_1.compose)(lhs.value, "LIKE", rhs.value);
-                }
-                else {
-                    const regexCmp = regexEqual(lhs, rhs);
-                    if (regexCmp === undefined) {
-                        throw new index_1.TypeMistmatch("Incompatible types for match('~') operator");
-                    }
-                    value = regexCmp;
-                }
-                value = nullsafeNot(value, op);
-                break;
-            }
-            case "=":
-            case "!=": {
-                const nullCmp = nullCompare(lhs, op, rhs);
-                if (nullCmp) {
-                    value = nullCmp;
-                }
-                else {
-                    value = nullsafeNot(regexEqual(lhs, rhs) || (0, index_1.compose)(lhs.value, "=", rhs.value), op);
-                }
-                break;
-            }
-        }
-    }
-    return {
-        dataType: "boolean",
-        aggregate: lhs.aggregate || rhs.aggregate,
-        value,
-    };
-}
-function compare(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    const anyAggregate = lhs.aggregate || rhs.aggregate;
-    const value = timeCompare(lhs, op, rhs) || (0, index_1.compose)(lhs.value, op, rhs.value);
-    return {
-        dataType: "boolean",
-        aggregate: anyAggregate,
-        value: value,
-    };
-}
-function numeric(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    const anyAggregate = lhs.aggregate || rhs.aggregate;
-    if (allAre("number", lhs, rhs)) {
-        return {
-            dataType: "number",
-            aggregate: anyAggregate,
-            value: (0, index_1.compose)(lhs.value, op, rhs.value),
-        };
-    }
-    left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
-    return (0, index_1.errorFor)("numbers required");
-}
-function delta(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
-        let duration = right;
-        if (rhs.dataType !== "duration") {
-            if ((0, index_1.isGranularResult)(lhs)) {
-                duration = new index_1.ExprDuration(right, lhs.timeframe);
-            }
-            else if (lhs.dataType === "date") {
-                duration = new index_1.ExprDuration(right, "day");
-            }
-            else {
-                left.log(`Can not offset time by '${rhs.dataType}'`);
-                return (0, index_1.errorFor)(`time plus ${rhs.dataType}`);
-            }
-        }
-        return duration.apply(fs, op, left);
-    }
-    return numeric(fs, left, op, right);
-}
-//# sourceMappingURL=apply-expr.js.map