@malloydata/malloy 0.0.205-dev241028163321 → 0.0.205-dev241028192658

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

@@ -0,0 +1,48 @@
+import { AtomicTypeDef, TypeDesc } from '../../model';
+export declare const nullT: TypeDesc;
+export declare const numberT: TypeDesc;
+export declare const stringT: TypeDesc;
+export declare const dateT: TypeDesc;
+export declare const timestampT: TypeDesc;
+export declare const boolT: TypeDesc;
+export declare const errorT: TypeDesc;
+export declare const viewT: TypeDesc;
+export declare const aggregateBoolT: TypeDesc;
+export declare const anyAtomicT: TypeDesc[];
+/**
+ * Checks if a given type is in a list
+ * @param check The type to check (can be undefined)
+ * @param from List of types which are OK
+ */
+export declare function any(check: TypeDesc | undefined, from: TypeDesc[]): boolean;
+/**
+ * Checks if a possibly undefined candidate matches a type
+ * @param good The real type
+ * @param checkThis The possibly undefined candidate
+ */
+export declare function eq(good: TypeDesc, checkThis: TypeDesc | undefined): boolean;
+/**
+ * Checks if a given type is in a list, ignoring aggregate
+ * @param check The type to check (can be undefined)
+ * @param from List of types which are OK
+ */
+export declare function typeIn(check: TypeDesc | undefined, from: TypeDesc[]): boolean;
+/**
+ * Checks if the base types, ignoring expressionType, are equal
+ * @param left Left type
+ * @param right Right type
+ * @param nullOk True if a NULL is an acceptable match
+ */
+export declare function typeEq(left: TypeDesc, right: TypeDesc, nullOk?: boolean, errorOk?: boolean): boolean;
+/**
+ *
+ * For error messages, returns a comma seperated list of readable names
+ * for a list of types.
+ * @param types List of type or objects with types
+ */
+export declare function inspect(...types: (TypeDesc | undefined)[]): string;
+/**
+ * Used when using a TypeDesc or TypeDesc-like interface to
+ * create a field, don't copy the non type fields.
+ */
+export declare function atomicDef(td: AtomicTypeDef | TypeDesc): AtomicTypeDef;

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

@@ -0,0 +1,157 @@
+"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.atomicDef = exports.inspect = exports.typeEq = exports.typeIn = exports.eq = exports.any = exports.anyAtomicT = exports.aggregateBoolT = exports.viewT = exports.errorT = exports.boolT = exports.timestampT = exports.dateT = exports.stringT = exports.numberT = exports.nullT = void 0;
+const model_1 = require("../../model");
+function mkTypeDesc(
+// The problem is that record and array, as currently defined, require a dialect
+// which isn't available. In retrospect the dialect shouldn't be in the type,
+// it should only be in the field, which I wil do eventually.
+dataType, expressionType = 'scalar', evalSpace = 'constant') {
+    return { type: dataType, expressionType, evalSpace };
+}
+exports.nullT = mkTypeDesc('null');
+exports.numberT = mkTypeDesc('number');
+exports.stringT = mkTypeDesc('string');
+exports.dateT = mkTypeDesc('date');
+exports.timestampT = mkTypeDesc('timestamp');
+exports.boolT = mkTypeDesc('boolean');
+exports.errorT = mkTypeDesc('error');
+exports.viewT = mkTypeDesc('turtle');
+exports.aggregateBoolT = mkTypeDesc('boolean', 'aggregate');
+exports.anyAtomicT = [exports.numberT, exports.stringT, exports.dateT, exports.timestampT, exports.boolT];
+/**
+ * Checks if a given type is in a list
+ * @param check The type to check (can be undefined)
+ * @param from List of types which are OK
+ */
+function any(check, from) {
+    if (check) {
+        const found = from.find(okType => eq(okType, check));
+        return found !== undefined;
+    }
+    return false;
+}
+exports.any = any;
+/**
+ * Checks if a possibly undefined candidate matches a type
+ * @param good The real type
+ * @param checkThis The possibly undefined candidate
+ */
+function eq(good, checkThis) {
+    return (checkThis !== undefined &&
+        model_1.TD.eq(good, checkThis) &&
+        good.expressionType === checkThis.expressionType);
+}
+exports.eq = eq;
+/**
+ * Checks if a given type is in a list, ignoring aggregate
+ * @param check The type to check (can be undefined)
+ * @param from List of types which are OK
+ */
+function typeIn(check, from) {
+    if (check) {
+        const found = from.find(okType => typeEq(okType, check));
+        return found !== undefined;
+    }
+    return false;
+}
+exports.typeIn = typeIn;
+/**
+ * Checks if the base types, ignoring expressionType, are equal
+ * @param left Left type
+ * @param right Right type
+ * @param nullOk True if a NULL is an acceptable match
+ */
+function typeEq(left, right, nullOk = false, errorOk = true) {
+    const maybeEq = model_1.TD.eq(left, right);
+    const nullEq = nullOk && (left.type === 'null' || right.type === 'null');
+    const errorEq = errorOk && (left.type === 'error' || right.type === 'error');
+    return maybeEq || nullEq || errorEq;
+}
+exports.typeEq = typeEq;
+/**
+ *
+ * For error messages, returns a comma seperated list of readable names
+ * for a list of types.
+ * @param types List of type or objects with types
+ */
+function inspect(...types) {
+    const strings = types.map(type => {
+        if (type) {
+            let inspected = type.type;
+            if (!(0, model_1.expressionIsScalar)(type.expressionType)) {
+                inspected = `${type.expressionType} ${inspected}`;
+            }
+            return inspected;
+        }
+        return 'undefined';
+    });
+    return strings.join(',');
+}
+exports.inspect = inspect;
+/**
+ * Used when using a TypeDesc or TypeDesc-like interface to
+ * create a field, don't copy the non type fields.
+ */
+function atomicDef(td) {
+    if (model_1.TD.isAtomic(td)) {
+        switch (td.type) {
+            case 'array': {
+                return {
+                    name: '',
+                    type: 'array',
+                    join: 'many',
+                    elementTypeDef: td.elementTypeDef,
+                    dialect: td.dialect,
+                    fields: td.fields,
+                };
+            }
+            case 'record': {
+                return {
+                    name: '',
+                    type: 'record',
+                    join: 'one',
+                    dialect: td.dialect,
+                    fields: td.fields,
+                };
+            }
+            case 'number': {
+                return td.numberType
+                    ? { type: 'number', numberType: td.numberType }
+                    : { type: 'number' };
+            }
+            case 'sql native': {
+                return td.rawType
+                    ? { type: 'sql native', rawType: td.rawType }
+                    : { type: 'sql native' };
+            }
+            default:
+                return { type: td.type };
+        }
+    }
+    return { type: 'error' };
+}
+exports.atomicDef = atomicDef;
+//# sourceMappingURL=typedesc-utils.js.map

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

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

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

@@ -1,54 +1,29 @@
-import { Expr, FieldValueType, TemporalFieldType, TimestampUnit } from '../../../model';
+import { Expr, ExpressionValueTypeDef, TemporalTypeDef, TimestampUnit } from '../../../model';
 import { ExprResult } from './expr-result';
 import { TimeResult } from './time-result';
 export type ExprValue = ExprResult | TimeResult;
-export declare function computedExprValue({ value, dataType, rawType, from, }: {
+export declare function computedExprValue({ value, dataType, from, }: {
     value: Expr;
-    dataType: FieldValueType;
-    rawType?: string;
+    dataType: ExpressionValueTypeDef;
     from: ExprValue[];
 }): ExprValue;
-export declare function computedTimeResult({ value, dataType, rawType, from, timeframe, }: {
+export declare function computedTimeResult({ value, dataType, from, timeframe, }: {
     value: Expr;
-    rawType?: string;
-    dataType: TemporalFieldType;
+    dataType: TemporalTypeDef;
     timeframe?: TimestampUnit;
     from: ExprValue[];
-}): {
-    timeframe: TimestampUnit | undefined;
-    value: Expr;
-    morphic?: {
-        [x: string]: Expr;
-    } | undefined;
-    dataType: FieldValueType;
-    expressionType: import("../../../model").ExpressionType;
-    rawType?: string | undefined;
-    evalSpace: import("../../../model").EvalSpace;
-} | {
-    timeframe: TimestampUnit | undefined;
-    dataType: TemporalFieldType;
-    value: Expr;
-    morphic?: {
-        [x: string]: Expr;
-    } | undefined;
-    expressionType: import("../../../model").ExpressionType;
-    rawType?: string | undefined;
-    evalSpace: import("../../../model").EvalSpace;
-};
-export declare function computedErrorExprValue({ dataType, rawType, from, error, }: {
+}): TimeResult;
+export declare function computedErrorExprValue({ dataType, from, error, }: {
     error: string;
-    rawType?: string;
-    dataType?: FieldValueType;
+    dataType?: ExpressionValueTypeDef;
     from: ExprValue[];
 }): ExprValue;
 export declare function literalExprValue(options: {
     value: Expr;
-    rawType?: string;
-    dataType: FieldValueType;
+    dataType: ExpressionValueTypeDef;
 }): ExprValue;
-export declare function literalTimeResult({ value, dataType, rawType, timeframe, }: {
+export declare function literalTimeResult({ value, dataType, timeframe, }: {
     value: Expr;
-    rawType?: string;
-    dataType: TemporalFieldType;
+    dataType: TemporalTypeDef;
     timeframe?: TimestampUnit;
 }): TimeResult;

package/dist/lang/ast/types/expr-value.js

@@ -24,24 +24,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.literalTimeResult = exports.literalExprValue = exports.computedErrorExprValue = exports.computedTimeResult = exports.computedExprValue = void 0;
 const model_1 = require("../../../model");
-function computedExprValue({ value, dataType, rawType, from, }) {
+function computedExprValue({ value, dataType, from, }) {
     return {
+        ...dataType,
         value,
-        dataType,
-        rawType,
         expressionType: (0, model_1.maxOfExpressionTypes)(from.map(e => e.expressionType)),
         evalSpace: (0, model_1.mergeEvalSpaces)(...from.map(e => e.evalSpace)),
     };
 }
 exports.computedExprValue = computedExprValue;
-function computedTimeResult({ value, dataType, rawType, from, timeframe, }) {
-    return { ...computedExprValue({ value, dataType, rawType, from }), timeframe };
+function computedTimeResult({ value, dataType, from, timeframe, }) {
+    const xv = computedExprValue({ value, dataType, from });
+    const y = {
+        ...dataType,
+        expressionType: xv.expressionType,
+        evalSpace: xv.evalSpace,
+        value: xv.value,
+    };
+    if (timeframe) {
+        y.timeframe = timeframe;
+    }
+    return y;
 }
 exports.computedTimeResult = computedTimeResult;
-function computedErrorExprValue({ dataType, rawType, from, error, }) {
+function computedErrorExprValue({ dataType, from, error, }) {
     return computedExprValue({
-        dataType: dataType || 'error',
-        rawType,
+        dataType: dataType !== null && dataType !== void 0 ? dataType : { type: 'error' },
         value: { node: 'error', message: error },
         from,
     });
@@ -52,12 +60,18 @@ function literalExprValue(options) {
     return computedExprValue({ ...options, from: [] });
 }
 exports.literalExprValue = literalExprValue;
-function literalTimeResult({ value, dataType, rawType, timeframe, }) {
-    return {
-        ...computedExprValue({ value, dataType, rawType, from: [] }),
-        dataType,
-        timeframe,
+function literalTimeResult({ value, dataType, timeframe, }) {
+    const xv = computedExprValue({ value, dataType, from: [] });
+    const y = {
+        ...dataType,
+        expressionType: xv.expressionType,
+        evalSpace: xv.evalSpace,
+        value: xv.value,
     };
+    if (timeframe) {
+        y.timeframe = timeframe;
+    }
+    return y;
 }
 exports.literalTimeResult = literalTimeResult;
 //# sourceMappingURL=expr-value.js.map

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

@@ -1,4 +1,4 @@
-import { TimestampUnit, FieldValueType } from '../../../model/malloy_types';
+import { TimestampUnit } from '../../../model/malloy_types';
 import { ExprValue } from './expr-value';
 import { FieldSpace } from './field-space';
 import { MalloyElement } from './malloy-element';
@@ -69,7 +69,8 @@ export declare class ExprDuration extends ExpressionDef {
     apply(fs: FieldSpace, op: BinaryMalloyOperator, left: ExpressionDef): ExprValue;
     getExpression(fs: FieldSpace): ExprValue;
 }
-export declare function getMorphicValue(mv: ExprValue, mt: FieldValueType): ExprValue | undefined;
+export type MorphicType = 'date' | 'timestamp';
+export declare function getMorphicValue(mv: ExprValue, mt: MorphicType): ExprValue | undefined;
 /**
  * All of the magic of malloy expressions eventually flows to here,
  * where an operator is applied to two values. Depending on the