@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/lang/ast/source-properties/joins.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Joins = exports.ExpressionJoin = exports.KeyJoin = exports.Join = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
-const utils_1 = require("../expressions/utils");
 const join_space_field_1 = require("../field-space/join-space-field");
 const definition_list_1 = require("../types/definition-list");
 const malloy_element_1 = require("../types/malloy-element");
@@ -66,7 +65,7 @@ class KeyJoin extends Join {
             structRelationship: {
                 type: 'one',
                 matrixOperation: 'left',
-                onExpression: ["('join fixup'='not done yet')"],
+                onExpression: { node: 'error', message: "('join fixup'='not done yet')" },
             },
             location: this.location,
         };
@@ -92,14 +91,16 @@ class KeyJoin extends Join {
                     inStruct.structRelationship = {
                         type: 'one',
                         matrixOperation: 'left',
-                        onExpression: [
-                            {
-                                type: 'field',
-                                path: [this.name.refString, inStruct.primaryKey],
+                        onExpression: {
+                            node: '=',
+                            kids: {
+                                left: {
+                                    node: 'field',
+                                    path: [this.name.refString, inStruct.primaryKey],
+                                },
+                                right: exprX.value,
                             },
-                            '=',
-                            ...exprX.value,
-                        ],
+                        },
                     };
                     return;
                 }
@@ -144,7 +145,7 @@ class ExpressionJoin extends Join {
         }
         const joinRel = inStruct.structRelationship;
         if ((0, malloy_types_1.isJoinOn)(joinRel)) {
-            joinRel.onExpression = (0, utils_1.compressExpr)(exprX.value);
+            joinRel.onExpression = exprX.value;
         }
     }
     structDef(parameterSpace) {

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

@@ -1,12 +1,10 @@
-import { Expr, Fragment, TimeFieldType, TimestampUnit, FieldValueType, CastType } from '../../model/malloy_types';
+import { Expr, TimeFieldType, TimestampUnit, FieldValueType, CastType, TypecastExpr, TimeDeltaExpr } from '../../model/malloy_types';
 import { TimeResult } from './types/time-result';
-export declare function timeOffset(timeType: TimeFieldType, from: Expr, op: '+' | '-', n: Expr, timeframe: TimestampUnit): Expr;
+export declare function timeOffset(timeType: TimeFieldType, from: Expr, op: '+' | '-', n: Expr, timeframe: TimestampUnit): TimeDeltaExpr;
 export declare function castTo(castType: CastType | {
     raw: string;
-}, from: Expr, fromType: FieldValueType, safe?: boolean): Expr;
-export declare function castTimestampToDate(from: Expr, safe?: boolean): Expr;
-export declare function castDateToTimestamp(from: Expr, safe?: boolean): Expr;
+}, from: Expr, fromType: FieldValueType, safe?: boolean): TypecastExpr;
+export declare function castTimestampToDate(from: Expr, safe?: boolean): TypecastExpr;
+export declare function castDateToTimestamp(from: Expr, safe?: boolean): TypecastExpr;
 export declare function resolution(timeframe: string): TimeFieldType;
 export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult;
-export declare function timestampOffset(from: Fragment[], op: '+' | '-', n: Fragment[], timeframe: TimestampUnit, fromNotTimestamp?: boolean): Fragment[];
-export declare function dateOffset(from: Fragment[], op: '+' | '-', n: Fragment[], timeframe: TimestampUnit): Fragment[];

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

@@ -22,58 +22,53 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dateOffset = exports.timestampOffset = exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
+exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
 const malloy_types_1 = require("../../model/malloy_types");
-const utils_1 = require("./expressions/utils");
 function timeOffset(timeType, from, op, n, timeframe) {
-    return [
-        {
-            type: 'dialect',
-            function: 'delta',
-            base: { valueType: timeType, value: from },
-            op,
+    return {
+        node: 'delta',
+        kids: {
+            base: { ...from, dataType: timeType },
             delta: n,
-            units: timeframe,
         },
-    ];
+        op,
+        units: timeframe,
+    };
 }
 exports.timeOffset = timeOffset;
 function castTo(castType, from, fromType, safe = false) {
     const cast = {
-        type: 'dialect',
-        function: 'cast',
+        node: 'cast',
         dstType: castType,
-        expr: from,
+        e: from,
         safe,
     };
     if ((0, malloy_types_1.isAtomicFieldType)(fromType)) {
         cast.srcType = fromType;
     }
-    return [cast];
+    return cast;
 }
 exports.castTo = castTo;
 function castTimestampToDate(from, safe = false) {
     const cast = {
-        type: 'dialect',
-        function: 'cast',
+        node: 'cast',
         dstType: 'date',
         srcType: 'timestamp',
-        expr: from,
+        e: from,
         safe,
     };
-    return [cast];
+    return cast;
 }
 exports.castTimestampToDate = castTimestampToDate;
 function castDateToTimestamp(from, safe = false) {
     const cast = {
-        type: 'dialect',
-        function: 'cast',
+        node: 'cast',
         dstType: 'timestamp',
         srcType: 'date',
-        expr: from,
+        e: from,
         safe,
     };
-    return [cast];
+    return cast;
 }
 exports.castDateToTimestamp = castDateToTimestamp;
 function resolution(timeframe) {
@@ -95,39 +90,4 @@ function timeResult(t, tt) {
     return t;
 }
 exports.timeResult = timeResult;
-function timestampOffset(from, op, n, timeframe, fromNotTimestamp = false) {
-    const useDatetime = ['week', 'month', 'quarter', 'year'].includes(timeframe);
-    const add = op === '+' ? '_ADD' : '_SUB';
-    const units = timeframe.toUpperCase();
-    if (useDatetime) {
-        return [
-            `TIMESTAMP(DATETIME${add}(DATETIME(`,
-            ...from,
-            '),INTERVAL ',
-            ...n,
-            ` ${units}))`,
-        ];
-    }
-    const typeFrom = fromNotTimestamp ? ['TIMESTAMP(', ...from, ')'] : from;
-    return (0, utils_1.compressExpr)([
-        `TIMESTAMP${add}(`,
-        ...typeFrom,
-        ',INTERVAL ',
-        ...n,
-        ` ${units})`,
-    ]);
-}
-exports.timestampOffset = timestampOffset;
-function dateOffset(from, op, n, timeframe) {
-    const add = op === '+' ? '_ADD' : '_SUB';
-    const units = timeframe.toUpperCase();
-    return (0, utils_1.compressExpr)([
-        `DATE${add}(`,
-        ...from,
-        ',INTERVAL ',
-        ...n,
-        ` ${units})`,
-    ]);
-}
-exports.dateOffset = dateOffset;
 //# sourceMappingURL=time-utils.js.map

package/dist/lang/ast/types/binary_operators.d.ts

@@ -0,0 +1,9 @@
+import { BinaryOperator } from '../../../model';
+export type LogicalMalloyOperator = 'and' | 'or';
+export type ArithmeticMalloyOperator = '+' | '-' | '*' | '/' | '%';
+export type EqualityMalloyOperator = '~' | '!~' | '=' | '!=';
+export type CompareMalloyOperator = '<' | '<=' | '>' | '>=' | EqualityMalloyOperator;
+export type BinaryMalloyOperator = ArithmeticMalloyOperator | CompareMalloyOperator | LogicalMalloyOperator;
+export declare function getExprNode(mo: BinaryMalloyOperator): BinaryOperator;
+export declare function isEquality(op: string): op is EqualityMalloyOperator;
+export declare function isComparison(op: string): op is CompareMalloyOperator;

package/dist/lang/ast/types/binary_operators.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComparison = exports.isEquality = exports.getExprNode = void 0;
+function getExprNode(mo) {
+    switch (mo) {
+        case '~':
+            return 'like';
+        case '!~':
+            return '!like';
+    }
+    return mo;
+}
+exports.getExprNode = getExprNode;
+function isEquality(op) {
+    return op === '=' || op === '!=' || op === '~' || op === '!~';
+}
+exports.isEquality = isEquality;
+function isComparison(op) {
+    return (isEquality(op) || op === '>=' || op === '<=' || op === '>' || op === '<');
+}
+exports.isComparison = isComparison;
+//# sourceMappingURL=binary_operators.js.map

package/dist/lang/ast/types/expr-result.d.ts

@@ -1,7 +1,7 @@
-import { Fragment, TypeDesc } from '../../../model/malloy_types';
-type MorphicValues = Record<string, Fragment[]>;
+import { Expr, TypeDesc } from '../../../model/malloy_types';
+type MorphicValues = Record<string, Expr>;
 export interface ExprResult extends TypeDesc {
-    value: Fragment[];
+    value: Expr;
     morphic?: MorphicValues;
 }
 export {};

package/dist/lang/ast/types/expression-def.d.ts

@@ -2,6 +2,7 @@ import { TimestampUnit, FieldValueType } from '../../../model/malloy_types';
 import { ExprValue } from './expr-value';
 import { FieldSpace } from './field-space';
 import { MalloyElement } from './malloy-element';
+import { BinaryMalloyOperator } from './binary_operators';
 /**
  * Root node for any element in an expression. These essentially
  * create a sub-tree in the larger AST. Expression nodes know
@@ -44,7 +45,7 @@ export declare abstract class ExpressionDef extends MalloyElement {
      * @param expr The "other" (besdies 'this') value
      * @return The translated expression
      */
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
     canSupportPartitionBy(): boolean;
     canSupportOrderBy(): boolean;
     canSupportLimit(): boolean;
@@ -56,7 +57,7 @@ export declare class ExprDuration extends ExpressionDef {
     elementType: string;
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
-    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
     getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare function getMorphicValue(mv: ExprValue, mt: FieldValueType): ExprValue | undefined;
@@ -71,4 +72,4 @@ export declare function getMorphicValue(mv: ExprValue, mt: FieldValueType): Expr
  * @param right Right Value
  * @return ExprValue of the expression
  */
-export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: string, right: ExpressionDef): ExprValue;
+export declare function applyBinary(fs: FieldSpace, left: ExpressionDef, op: BinaryMalloyOperator, right: ExpressionDef): ExprValue;

package/dist/lang/ast/types/expression-def.js

@@ -28,10 +28,9 @@ const ast_utils_1 = require("../ast-utils");
 const utils_1 = require("../expressions/utils");
 const fragtype_utils_1 = require("../fragtype-utils");
 const time_utils_1 = require("../time-utils");
-const comparison_1 = require("./comparison");
-const equality_1 = require("./equality");
 const granular_result_1 = require("./granular-result");
 const malloy_element_1 = require("./malloy-element");
+const binary_operators_1 = require("./binary_operators");
 class TypeMismatch extends Error {
 }
 /**
@@ -154,7 +153,7 @@ class ExprDuration extends ExpressionDef {
         return {
             dataType: 'duration',
             expressionType: 'scalar',
-            value: ['__ERROR_DURATION_IS_NOT_A_VALUE__'],
+            value: { node: 'error', message: 'Duration is not a value' },
             evalSpace: 'constant',
         };
     }
@@ -182,70 +181,64 @@ exports.getMorphicValue = getMorphicValue;
 function timeCompare(left, lhs, op, rhs) {
     const leftIsTime = (0, malloy_types_1.isTimeFieldType)(lhs.dataType);
     const rightIsTime = (0, malloy_types_1.isTimeFieldType)(rhs.dataType);
+    const node = (0, binary_operators_1.getExprNode)(op);
     if (leftIsTime && rightIsTime) {
         if (lhs.dataType !== rhs.dataType) {
             const lval = willMorphTo(lhs, 'timestamp');
             const rval = willMorphTo(rhs, 'timestamp');
             if (lval && rval) {
-                return (0, utils_1.compose)(lval, op, rval);
+                return { node, kids: { left: lval, right: lval } };
             }
         }
         else {
-            return (0, utils_1.compose)(lhs.value, op, rhs.value);
+            return { node, kids: { left: lhs.value, right: rhs.value } };
         }
     }
     if ((leftIsTime || rightIsTime) &&
         lhs.dataType !== 'null' &&
         rhs.dataType !== 'null') {
         left.log(`Cannot compare a ${lhs.dataType} to a ${rhs.dataType}`);
-        return ['false'];
+        return { node: 'false' };
     }
     return undefined;
 }
 function regexEqual(left, right) {
     if (left.dataType === 'string') {
         if (right.dataType === 'regular expression') {
-            return [
-                {
-                    type: 'dialect',
-                    function: 'regexpMatch',
-                    expr: left.value,
-                    regexp: right.value,
-                },
-            ];
+            return {
+                node: 'regexpMatch',
+                kids: { expr: left.value, regex: right.value },
+            };
         }
     }
     else if (right.dataType === 'string') {
         if (left.dataType === 'regular expression') {
-            return [
-                {
-                    type: 'dialect',
-                    function: 'regexpMatch',
-                    expr: right.value,
-                    regexp: left.value,
-                },
-            ];
+            return {
+                node: 'regexpMatch',
+                kids: { expr: right.value, regex: left.value },
+            };
         }
     }
     return undefined;
 }
 function nullCompare(left, op, right) {
     const not = op === '!=' || op === '!~';
+    const nullCmp = not ? 'is-not-null' : 'is-null';
     if (left.dataType === 'null' || right.dataType === 'null') {
-        const maybeNot = not ? ' NOT' : '';
         if (left.dataType !== 'null') {
-            return [...left.value, ` IS${maybeNot} NULL`];
+            return { node: nullCmp, e: left.value };
         }
         if (right.dataType !== 'null') {
-            return [...right.value, `IS${maybeNot} NULL`];
+            return { node: nullCmp, e: right.value };
         }
-        return [not ? 'false' : 'true'];
+        return { node: not ? 'false' : 'true' };
     }
     return undefined;
 }
 function equality(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
+    const node = (0, binary_operators_1.getExprNode)(op);
     const err = errorCascade('boolean', lhs, rhs);
     if (err)
         return err;
@@ -261,15 +254,15 @@ function equality(fs, left, op, right) {
             }
         }
     }
-    let value = timeCompare(left, lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
+    let value = timeCompare(left, lhs, op, rhs) || {
+        node,
+        kids: { left: lhs.value, right: rhs.value },
+    };
     if (lhs.dataType !== 'error' && rhs.dataType !== 'error') {
         switch (op) {
             case '~':
             case '!~': {
-                if (lhs.dataType === 'string' && rhs.dataType === 'string') {
-                    value = (0, utils_1.compose)(lhs.value, 'LIKE', rhs.value);
-                }
-                else {
+                if (lhs.dataType !== 'string' || rhs.dataType !== 'string') {
                     const regexCmp = regexEqual(lhs, rhs);
                     if (regexCmp === undefined) {
                         throw new TypeMismatch("Incompatible types for match('~') operator");
@@ -282,11 +275,12 @@ function equality(fs, left, op, right) {
             case '=':
             case '!=': {
                 const nullCmp = nullCompare(lhs, op, rhs);
+                const eqNode = value;
                 if (nullCmp) {
                     value = nullCmp;
                 }
                 else {
-                    value = (0, utils_1.nullsafeNot)(regexEqual(lhs, rhs) || (0, utils_1.compose)(lhs.value, '=', rhs.value), op);
+                    value = (0, utils_1.nullsafeNot)(regexEqual(lhs, rhs) || eqNode, op);
                 }
                 break;
             }
@@ -310,7 +304,10 @@ function compare(fs, left, op, right) {
     if (noCompare) {
         return { ...noCompare, dataType: 'boolean' };
     }
-    const value = timeCompare(left, lhs, op, rhs) || (0, utils_1.compose)(lhs.value, op, rhs.value);
+    const value = timeCompare(left, lhs, op, rhs) || {
+        node: (0, binary_operators_1.getExprNode)(op),
+        kids: { left: lhs.value, right: rhs.value },
+    };
     return {
         dataType: 'boolean',
         expressionType,
@@ -318,9 +315,6 @@ function compare(fs, left, op, right) {
         value: value,
     };
 }
-function oneOf(op, ...operators) {
-    return operators.includes(op);
-}
 function numeric(fs, left, op, right) {
     const lhs = left.getExpression(fs);
     const rhs = right.getExpression(fs);
@@ -342,7 +336,7 @@ function numeric(fs, left, op, right) {
         return {
             dataType: 'number',
             expressionType,
-            value: (0, utils_1.compose)(lhs.value, op, rhs.value),
+            value: { node: op, kids: { left: lhs.value, right: rhs.value } },
             evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
         };
     }
@@ -389,19 +383,19 @@ function delta(fs, left, op, right) {
  * @return ExprValue of the expression
  */
 function applyBinary(fs, left, op, right) {
-    if ((0, equality_1.isEquality)(op)) {
+    if ((0, binary_operators_1.isEquality)(op)) {
         return equality(fs, left, op, right);
     }
-    if ((0, comparison_1.isComparison)(op)) {
+    if ((0, binary_operators_1.isComparison)(op)) {
         return compare(fs, left, op, right);
     }
-    if (oneOf(op, '+', '-')) {
+    if (op === '+' || op === '-') {
         return delta(fs, left, op, right);
     }
     if (op === '*') {
         return numeric(fs, left, op, right);
     }
-    if (oneOf(op, '/', '%')) {
+    if (op === '/' || op === '%') {
         const num = left.getExpression(fs);
         const denom = right.getExpression(fs);
         const noGo = unsupportError(left, num, right, denom);
@@ -419,17 +413,15 @@ function applyBinary(fs, left, op, right) {
             right.log('Denominator must be a number');
         }
         else {
-            const div = {
-                type: 'dialect',
-                function: op === '/' ? 'div' : 'mod',
-                numerator: num.value,
-                denominator: denom.value,
+            const divmod = {
+                node: op,
+                kids: { left: num.value, right: denom.value },
             };
             return {
                 dataType: 'number',
                 expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
                 evalSpace: (0, malloy_types_1.mergeEvalSpaces)(num.evalSpace, denom.evalSpace),
-                value: [div],
+                value: divmod,
             };
         }
         return (0, ast_utils_1.errorFor)('divide type mismatch');
@@ -443,7 +435,7 @@ function errorCascade(dataType, ...es) {
         return {
             dataType,
             expressionType: (0, malloy_types_1.maxOfExpressionTypes)(es.map(e => e.expressionType)),
-            value: ["'cascading error'"],
+            value: { node: 'error', message: 'cascading error' },
             evalSpace: (0, malloy_types_1.mergeEvalSpaces)(...es.map(e => e.evalSpace)),
         };
     }
@@ -455,12 +447,13 @@ function unsupportError(l, lhs, r, rhs) {
     const ret = {
         dataType: lhs.dataType,
         expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
-        value: ["'unsupported operation'"],
+        value: { node: 'error', message: 'sql-native unsupported' },
         evalSpace: (0, malloy_types_1.mergeEvalSpaces)(lhs.evalSpace, rhs.evalSpace),
     };
     if (lhs.dataType === 'sql native') {
         l.log(`Unsupported SQL native type '${lhs.rawType}' not allowed in expression[unsupported-sql-native-type-not-allowed-in-expression]`);
-        return { ...ret, dataType: rhs.dataType };
+        ret.dataType = rhs.dataType;
+        return ret;
     }
     if (rhs.dataType === 'sql native') {
         r.log(`Unsupported SQL native type '${rhs.rawType}' not allowed in expression[unsupported-sql-native-type-not-allowed-in-expression]`);

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

@@ -2170,17 +2170,6 @@ export declare class ExprCoalesceContext extends FieldExprContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
-export declare class ExprCountDisinctContext extends FieldExprContext {
-    COUNT(): TerminalNode;
-    OPAREN(): TerminalNode;
-    DISTINCT(): TerminalNode;
-    fieldExpr(): FieldExprContext;
-    CPAREN(): TerminalNode;
-    constructor(ctx: FieldExprContext);
-    enterRule(listener: MalloyParserListener): void;
-    exitRule(listener: MalloyParserListener): void;
-    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
-}
 export declare class ExprPathlessAggregateContext extends FieldExprContext {
     aggregate(): AggregateContext;
     OPAREN(): TerminalNode;