@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

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

@@ -0,0 +1,117 @@
+"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.ExprGranularTime = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const expr_time_1 = require("./expr-time");
+const fragtype_utils_1 = require("../fragtype-utils");
+const range_1 = require("./range");
+const time_utils_1 = require("../time-utils");
+const expression_def_1 = require("../types/expression-def");
+/**
+ * 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 expression_def_1.ExpressionDef {
+    constructor(expr, units, truncate) {
+        super({ expr });
+        this.expr = expr;
+        this.units = units;
+        this.truncate = truncate;
+        this.elementType = "granularTime";
+        this.legalChildTypes = [fragtype_utils_1.FT.timestampT, fragtype_utils_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, ast_utils_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 = expr_time_1.ExprTime.fromValue("timestamp", begin);
+        const endTime = new expr_time_1.ExprTime("timestamp", (0, time_utils_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
+        const range = new range_1.Range(beginTime, endTime);
+        return range.apply(fs, op, expr);
+    }
+    dateRange(fs, op, expr) {
+        const begin = this.getExpression(fs);
+        const beginTime = new expr_time_1.ExprTime("date", begin.value, begin.expressionType);
+        const endAt = (0, time_utils_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
+        const end = new expr_time_1.ExprTime("date", endAt, begin.expressionType);
+        const range = new range_1.Range(beginTime, end);
+        return range.apply(fs, op, expr);
+    }
+}
+exports.ExprGranularTime = ExprGranularTime;
+//# sourceMappingURL=expr-granular-time.js.map

package/dist/lang/ast/expressions/expr-id-reference.d.ts

@@ -0,0 +1,12 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldReference } from "../query-items/field-references";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprIdReference extends ExpressionDef {
+    readonly fieldReference: FieldReference;
+    elementType: string;
+    constructor(fieldReference: FieldReference);
+    get refString(): string;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+}

package/dist/lang/ast/expressions/expr-id-reference.js

@@ -0,0 +1,75 @@
+"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.ExprIdReference = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const space_param_1 = require("../types/space-param");
+const expression_def_1 = require("../types/expression-def");
+class ExprIdReference extends expression_def_1.ExpressionDef {
+    constructor(fieldReference) {
+        super();
+        this.fieldReference = fieldReference;
+        this.elementType = "ExpressionIdReference";
+        this.has({ fieldPath: fieldReference });
+    }
+    get refString() {
+        return this.fieldReference.refString;
+    }
+    getExpression(fs) {
+        const def = this.fieldReference.getField(fs);
+        if (def.found) {
+            const value = [{ type: def.found.refType, path: this.refString }];
+            return {
+                ...def.found.typeDesc(),
+                value,
+            };
+        }
+        this.log(def.error);
+        return (0, ast_utils_1.errorFor)(def.error);
+    }
+    apply(fs, op, expr) {
+        const entry = this.fieldReference.getField(fs).found;
+        if (entry instanceof space_param_1.SpaceParam) {
+            const cParam = entry.parameter();
+            if ((0, malloy_types_1.isConditionParameter)(cParam)) {
+                const lval = expr.getExpression(fs);
+                return {
+                    dataType: "boolean",
+                    expressionType: lval.expressionType,
+                    value: [
+                        {
+                            type: "apply",
+                            value: lval.value,
+                            to: [{ type: "parameter", path: this.refString }],
+                        },
+                    ],
+                };
+            }
+        }
+        return super.apply(fs, op, expr);
+    }
+}
+exports.ExprIdReference = ExprIdReference;
+//# sourceMappingURL=expr-id-reference.js.map

package/dist/lang/ast/expressions/expr-logical-op.d.ts

@@ -0,0 +1,9 @@
+import { BinaryBoolean } from "./binary-boolean";
+export declare class ExprLogicalOp extends BinaryBoolean<"and" | "or"> {
+    elementType: string;
+    legalChildTypes: (import("../types/type-desc").TypeDesc | {
+        aggregate: boolean;
+        dataType: import("../types/type-desc").FieldValueType;
+        expressionType: import("../../..").ExpressionType;
+    })[];
+}

package/dist/lang/ast/expressions/expr-logical-op.js

@@ -0,0 +1,36 @@
+"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.ExprLogicalOp = void 0;
+const binary_boolean_1 = require("./binary-boolean");
+const fragtype_utils_1 = require("../fragtype-utils");
+class ExprLogicalOp extends binary_boolean_1.BinaryBoolean {
+    constructor() {
+        super(...arguments);
+        this.elementType = "logical operator";
+        this.legalChildTypes = [fragtype_utils_1.FT.boolT, { ...fragtype_utils_1.FT.boolT, aggregate: true }];
+    }
+}
+exports.ExprLogicalOp = ExprLogicalOp;
+//# sourceMappingURL=expr-logical-op.js.map

package/dist/lang/ast/expressions/expr-max.d.ts

@@ -0,0 +1,9 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldValueType } from "../types/type-desc";
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprMax extends ExprAggregateFunction {
+    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    constructor(expr: ExpressionDef);
+    returns(forExpression: ExprValue): FieldValueType;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprMax = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprMax extends expr_aggregate_function_1.ExprAggregateFunction {
+    constructor(expr) {
+        super("max", expr);
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+    }
+    returns(forExpression) {
+        return forExpression.dataType;
+    }
+}
+exports.ExprMax = ExprMax;
+//# sourceMappingURL=expr-max.js.map

package/dist/lang/ast/expressions/expr-min.d.ts

@@ -0,0 +1,9 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldValueType } from "../types/type-desc";
+import { ExprAggregateFunction } from "./expr-aggregate-function";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprMin extends ExprAggregateFunction {
+    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    constructor(expr: ExpressionDef);
+    returns(forExpression: ExprValue): FieldValueType;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprMin = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expr_aggregate_function_1 = require("./expr-aggregate-function");
+class ExprMin extends expr_aggregate_function_1.ExprAggregateFunction {
+    constructor(expr) {
+        super("min", expr);
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT, fragtype_utils_1.FT.stringT, fragtype_utils_1.FT.dateT, fragtype_utils_1.FT.timestampT];
+    }
+    returns(forExpression) {
+        return forExpression.dataType;
+    }
+}
+exports.ExprMin = ExprMin;
+//# sourceMappingURL=expr-min.js.map

package/dist/lang/ast/expressions/expr-minus.d.ts

@@ -0,0 +1,9 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprMinus extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    elementType: string;
+    constructor(expr: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,48 @@
+"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.ExprMinus = void 0;
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprMinus extends expression_def_1.ExpressionDef {
+    constructor(expr) {
+        super({ expr });
+        this.expr = expr;
+        this.elementType = "unary minus";
+        this.legalChildTypes = [fragtype_utils_1.FT.numberT];
+    }
+    getExpression(fs) {
+        const expr = this.expr.getExpression(fs);
+        if (this.typeCheck(this.expr, expr)) {
+            if (expr.value.length > 1) {
+                return { ...expr, value: ["-(", ...expr.value, ")"] };
+            }
+            return { ...expr, value: ["-", ...expr.value] };
+        }
+        return (0, ast_utils_1.errorFor)("negate requires number");
+    }
+}
+exports.ExprMinus = ExprMinus;
+//# sourceMappingURL=expr-minus.js.map

package/dist/lang/ast/expressions/expr-mul-div.d.ts

@@ -0,0 +1,4 @@
+import { BinaryNumeric } from "./binary-numeric";
+export declare class ExprMulDiv extends BinaryNumeric<"*" | "/" | "%"> {
+    elementType: string;
+}

package/dist/lang/ast/expressions/expr-mul-div.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprMulDiv = void 0;
+/*
+ * 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.
+ */
+const binary_numeric_1 = require("./binary-numeric");
+class ExprMulDiv extends binary_numeric_1.BinaryNumeric {
+    constructor() {
+        super(...arguments);
+        this.elementType = "*/%";
+    }
+}
+exports.ExprMulDiv = ExprMulDiv;
+//# sourceMappingURL=expr-mul-div.js.map

package/dist/lang/ast/expressions/expr-not.d.ts

@@ -0,0 +1,10 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { FieldSpace } from "../types/field-space";
+import { Unary } from "./unary";
+export declare class ExprNot extends Unary {
+    elementType: string;
+    legalChildTypes: import("../types/type-desc").TypeDesc[];
+    constructor(expr: ExpressionDef);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,49 @@
+"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.ExprNot = void 0;
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const unary_1 = require("./unary");
+const utils_1 = require("./utils");
+class ExprNot extends unary_1.Unary {
+    constructor(expr) {
+        super(expr);
+        this.elementType = "not";
+        this.legalChildTypes = [fragtype_utils_1.FT.boolT, fragtype_utils_1.FT.nullT];
+    }
+    getExpression(fs) {
+        const notThis = this.expr.getExpression(fs);
+        if (this.typeCheck(this.expr, notThis)) {
+            return {
+                ...notThis,
+                dataType: "boolean",
+                value: (0, utils_1.nullsafeNot)(notThis.value),
+            };
+        }
+        return (0, ast_utils_1.errorFor)("not requires boolean");
+    }
+}
+exports.ExprNot = ExprNot;
+//# sourceMappingURL=expr-not.js.map

package/dist/lang/ast/expressions/expr-now.d.ts

@@ -0,0 +1,7 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprNow extends ExpressionDef {
+    elementType: string;
+    getExpression(_fs: FieldSpace): ExprValue;
+}

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

@@ -0,0 +1,46 @@
+"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.ExprNow = void 0;
+const expression_def_1 = require("../types/expression-def");
+class ExprNow extends expression_def_1.ExpressionDef {
+    constructor() {
+        super(...arguments);
+        this.elementType = "timestamp";
+    }
+    getExpression(_fs) {
+        return {
+            dataType: "timestamp",
+            expressionType: "scalar",
+            value: [
+                {
+                    type: "dialect",
+                    function: "now",
+                },
+            ],
+        };
+    }
+}
+exports.ExprNow = ExprNow;
+//# sourceMappingURL=expr-now.js.map

package/dist/lang/ast/expressions/expr-null.d.ts

@@ -0,0 +1,6 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprNULL extends ExpressionDef {
+    elementType: string;
+    getExpression(): ExprValue;
+}

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

@@ -0,0 +1,41 @@
+"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.ExprNULL = void 0;
+const expression_def_1 = require("../types/expression-def");
+class ExprNULL extends expression_def_1.ExpressionDef {
+    constructor() {
+        super(...arguments);
+        this.elementType = "NULL";
+    }
+    getExpression() {
+        return {
+            dataType: "null",
+            value: ["NULL"],
+            expressionType: "scalar",
+        };
+    }
+}
+exports.ExprNULL = ExprNULL;
+//# sourceMappingURL=expr-null.js.map

package/dist/lang/ast/expressions/expr-number.d.ts

@@ -0,0 +1,10 @@
+import { ExprValue } from "../types/expr-value";
+import { FieldSpace } from "../types/field-space";
+import { ExpressionDef } from "../types/expression-def";
+export declare class ExprNumber extends ExpressionDef {
+    readonly n: string;
+    elementType: string;
+    constructor(n: string);
+    getExpression(_fs: FieldSpace): ExprValue;
+    constantExpression(): ExprValue;
+}

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

@@ -0,0 +1,42 @@
+"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.ExprNumber = void 0;
+const fragtype_utils_1 = require("../fragtype-utils");
+const expression_def_1 = require("../types/expression-def");
+class ExprNumber extends expression_def_1.ExpressionDef {
+    constructor(n) {
+        super();
+        this.n = n;
+        this.elementType = "numeric literal";
+    }
+    getExpression(_fs) {
+        return this.constantExpression();
+    }
+    constantExpression() {
+        return { ...fragtype_utils_1.FT.numberT, value: [this.n] };
+    }
+}
+exports.ExprNumber = ExprNumber;
+//# sourceMappingURL=expr-number.js.map

package/dist/lang/ast/expressions/expr-parens.d.ts

@@ -0,0 +1,10 @@
+import { ExprValue } from "../types/expr-value";
+import { ExpressionDef } from "../types/expression-def";
+import { FieldSpace } from "../types/field-space";
+export declare class ExprParens extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    elementType: string;
+    constructor(expr: ExpressionDef);
+    requestExpression(fs: FieldSpace): ExprValue | undefined;
+    getExpression(fs: FieldSpace): ExprValue;
+}