@malloydata/malloy 0.0.204 → 0.0.205-dev241028173215

package/dist/dialect/functions/util.d.ts

@@ -1,4 +1,4 @@
-import { FunctionParameterDef, FieldValueType, TypeDesc, Expr, FunctionParamTypeDesc, ExpressionValueType } from '../../model/malloy_types';
+import { FunctionParameterDef, TypeDesc, Expr, FunctionParamTypeDesc, LeafExpressionType } from '../../model/malloy_types';
 import { SQLExprElement } from '../../model/utils';
 export interface DialectFunctionOverloadDef {
     returnType: TypeDesc;
@@ -29,14 +29,14 @@ export declare function makeParam(name: string, ...allowedTypes: FunctionParamTy
     param: FunctionParameterDef;
     arg: Expr;
 };
-export declare function maxScalar(dataType: FieldValueType): TypeDesc;
-export declare function maxAggregate(dataType: FieldValueType): TypeDesc;
-export declare function anyExprType(dataType: FieldValueType): FunctionParamTypeDesc;
-export declare function maxUngroupedAggregate(dataType: FieldValueType): FunctionParamTypeDesc;
-export declare function maxAnalytic(dataType: FieldValueType): FunctionParamTypeDesc;
-export declare function minScalar(dataType: FieldValueType): TypeDesc;
-export declare function minAggregate(dataType: FieldValueType): TypeDesc;
-export declare function minAnalytic(dataType: FieldValueType): TypeDesc;
+export declare function maxScalar(type: LeafExpressionType): TypeDesc;
+export declare function maxAggregate(type: LeafExpressionType): TypeDesc;
+export declare function anyExprType(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function maxUngroupedAggregate(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function maxAnalytic(type: LeafExpressionType): FunctionParamTypeDesc;
+export declare function minScalar(type: LeafExpressionType): TypeDesc;
+export declare function minAggregate(type: LeafExpressionType): TypeDesc;
+export declare function minAnalytic(type: LeafExpressionType): TypeDesc;
 export declare function overload(returnType: TypeDesc, params: FunctionParameterDef[], e: Expr, options?: {
     needsWindowOrderBy?: boolean;
     between?: {
@@ -48,26 +48,26 @@ export declare function overload(returnType: TypeDesc, params: FunctionParameter
     defaultOrderByArgIndex?: number;
     supportsOrderBy?: boolean | 'only_default';
 }): DialectFunctionOverloadDef;
-export type TypeDescBlueprint = ExpressionValueType | {
+export type TypeDescBlueprint = LeafExpressionType | {
     generic: string;
 } | {
-    literal: ExpressionValueType | {
+    literal: LeafExpressionType | {
         generic: string;
     };
 } | {
-    constant: ExpressionValueType | {
+    constant: LeafExpressionType | {
         generic: string;
     };
 } | {
-    dimension: ExpressionValueType | {
+    dimension: LeafExpressionType | {
         generic: string;
     };
 } | {
-    measure: ExpressionValueType | {
+    measure: LeafExpressionType | {
         generic: string;
     };
 } | {
-    calculation: ExpressionValueType | {
+    calculation: LeafExpressionType | {
         generic: string;
     };
 };
@@ -75,7 +75,7 @@ type ParamTypeBlueprint = TypeDescBlueprint | TypeDescBlueprint[] | {
     variadic: TypeDescBlueprint | TypeDescBlueprint[];
 };
 export interface SignatureBlueprint {
-    generic?: [string, ExpressionValueType[]];
+    generic?: [string, LeafExpressionType[]];
     takes: {
         [name: string]: ParamTypeBlueprint;
     };

package/dist/dialect/functions/util.js

@@ -103,68 +103,36 @@ function makeParam(name, ...allowedTypes) {
     return { param: param(name, ...allowedTypes), arg: arg(name) };
 }
 exports.makeParam = makeParam;
-function maxScalar(dataType) {
-    return {
-        dataType,
-        expressionType: 'scalar',
-        evalSpace: 'input',
-    };
+function maxScalar(type) {
+    return { type, expressionType: 'scalar', evalSpace: 'input' };
 }
 exports.maxScalar = maxScalar;
-function maxAggregate(dataType) {
-    return {
-        dataType,
-        expressionType: 'aggregate',
-        evalSpace: 'input',
-    };
+function maxAggregate(type) {
+    return { type, expressionType: 'aggregate', evalSpace: 'input' };
 }
 exports.maxAggregate = maxAggregate;
-function anyExprType(dataType) {
-    return {
-        dataType,
-        expressionType: undefined,
-        evalSpace: 'input',
-    };
+function anyExprType(type) {
+    return { type, expressionType: undefined, evalSpace: 'input' };
 }
 exports.anyExprType = anyExprType;
-function maxUngroupedAggregate(dataType) {
-    return {
-        dataType,
-        expressionType: 'ungrouped_aggregate',
-        evalSpace: 'input',
-    };
+function maxUngroupedAggregate(type) {
+    return { type, expressionType: 'ungrouped_aggregate', evalSpace: 'input' };
 }
 exports.maxUngroupedAggregate = maxUngroupedAggregate;
-function maxAnalytic(dataType) {
-    return {
-        dataType,
-        expressionType: 'aggregate_analytic',
-        evalSpace: 'input',
-    };
+function maxAnalytic(type) {
+    return { type, expressionType: 'aggregate_analytic', evalSpace: 'input' };
 }
 exports.maxAnalytic = maxAnalytic;
-function minScalar(dataType) {
-    return {
-        dataType,
-        expressionType: 'scalar',
-        evalSpace: 'input',
-    };
+function minScalar(type) {
+    return { type, expressionType: 'scalar', evalSpace: 'input' };
 }
 exports.minScalar = minScalar;
-function minAggregate(dataType) {
-    return {
-        dataType,
-        expressionType: 'aggregate',
-        evalSpace: 'input',
-    };
+function minAggregate(type) {
+    return { type, expressionType: 'aggregate', evalSpace: 'input' };
 }
 exports.minAggregate = minAggregate;
-function minAnalytic(dataType) {
-    return {
-        dataType,
-        expressionType: 'scalar_analytic',
-        evalSpace: 'input',
-    };
+function minAnalytic(type) {
+    return { type, expressionType: 'scalar_analytic', evalSpace: 'input' };
 }
 exports.minAnalytic = minAnalytic;
 function overload(returnType, params, e, options) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { DuckDBDialect, StandardSQLDialect, TrinoDialect, PostgresDialect, SnowflakeDialect, MySQLDialect, registerDialect, arg, qtz, overload, minScalar, anyExprType, minAggregate, maxScalar, sql, makeParam, param, variadicParam, literal, spread, Dialect, } from './dialect';
 export type { DialectFieldList, DialectFunctionOverloadDef, QueryInfo, MalloyStandardFunctionImplementations, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, } from './dialect';
-export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, SQLSentence, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, LeafAtomicTypeDef, LeafAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, } from './model';
+export type { QueryDataRow, StructDef, TableSourceDef, SQLSourceDef, SourceDef, JoinFieldDef, NamedSourceDefs, MalloyQueryData, DateUnit, ExtractUnit, TimestampUnit, TemporalFieldType, QueryData, QueryValue, Expr, FilterCondition, SQLSentence, FieldDef, PipeSegment, QueryFieldDef, IndexFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryResult, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Sampling, Annotation, LeafAtomicTypeDef, LeafAtomicDef, AtomicTypeDef, AtomicFieldDef, ArrayDef, ArrayTypeDef, RecordTypeDef, RepeatedRecordTypeDef, } from './model';
 export { arrayEachFields, isRepeatedRecord, isSourceDef, Segment, isLeafAtomic, isJoined, isJoinedSource, isSamplingEnable, isSamplingPercent, isSamplingRows, expressionIsAggregate, expressionIsAnalytic, expressionIsCalculation, expressionIsScalar, expressionIsUngroupedAggregate, indent, composeSQLExpr, } from './model';
 export { MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';

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

@@ -33,7 +33,7 @@ exports.errorFor = void 0;
  */
 function errorFor(reason) {
     return {
-        dataType: 'error',
+        type: 'error',
         expressionType: 'scalar',
         value: { node: 'error', message: reason },
         evalSpace: 'constant',

package/dist/lang/ast/expressions/binary-boolean.js

@@ -21,10 +21,33 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryBoolean = void 0;
 const ast_utils_1 = require("../ast-utils");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const binary_operators_1 = require("../types/binary_operators");
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
@@ -35,14 +58,14 @@ class BinaryBoolean extends expression_def_1.ExpressionDef {
         this.op = op;
         this.right = right;
         this.elementType = 'abstract boolean binary';
-        this.legalChildTypes = [fragtype_utils_1.FT.boolT];
+        this.legalChildTypes = [TDU.boolT];
     }
     getExpression(fs) {
         const left = this.left.getExpression(fs);
         const right = this.right.getExpression(fs);
         if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
             return (0, expr_value_1.computedExprValue)({
-                dataType: 'boolean',
+                dataType: { type: 'boolean' },
                 value: {
                     node: (0, binary_operators_1.getExprNode)(this.op),
                     kids: { left: left.value, right: right.value },
@@ -50,7 +73,7 @@ class BinaryBoolean extends expression_def_1.ExpressionDef {
                 from: [left, right],
             });
         }
-        return (0, ast_utils_1.errorFor)('logial required boolean');
+        return (0, ast_utils_1.errorFor)('logical-op expected boolean');
     }
 }
 exports.BinaryBoolean = BinaryBoolean;

package/dist/lang/ast/expressions/binary-numeric.js

@@ -21,9 +21,32 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryNumeric = void 0;
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const expression_def_1 = require("../types/expression-def");
 class BinaryNumeric extends expression_def_1.ExpressionDef {
     constructor(left, op, right) {
@@ -32,7 +55,7 @@ class BinaryNumeric extends expression_def_1.ExpressionDef {
         this.op = op;
         this.right = right;
         this.elementType = 'numeric binary abstract';
-        this.legalChildTypes = [fragtype_utils_1.FT.numberT];
+        this.legalChildTypes = [TDU.numberT];
     }
     getExpression(fs) {
         return this.right.apply(fs, this.op, this.left);

package/dist/lang/ast/expressions/boolean.js

@@ -21,10 +21,33 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Boolean = void 0;
 const expression_def_1 = require("../types/expression-def");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 class Boolean extends expression_def_1.ExpressionDef {
     constructor(value) {
         super();
@@ -32,7 +55,7 @@ class Boolean extends expression_def_1.ExpressionDef {
         this.elementType = 'boolean literal';
     }
     getExpression() {
-        return { ...fragtype_utils_1.FT.boolT, value: { node: this.value } };
+        return { ...TDU.boolT, value: { node: this.value } };
     }
 }
 exports.Boolean = Boolean;

package/dist/lang/ast/expressions/case.js

@@ -5,16 +5,37 @@
  * This source code is licensed under the MIT license found in the
  *  LICENSE file in the root directory of this source tree.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CaseWhen = exports.Case = void 0;
 const expr_value_1 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const malloy_element_1 = require("../types/malloy-element");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 function typeCoalesce(ev1, ev2) {
-    return ev1 === undefined ||
-        ev1.dataType === 'null' ||
-        ev1.dataType === 'error'
+    return ev1 === undefined || ev1.type === 'null' || ev1.type === 'error'
         ? ev2
         : ev1;
 }
@@ -28,7 +49,6 @@ class Case extends expression_def_1.ExpressionDef {
         this.has({ elseValue, value });
     }
     getExpression(fs) {
-        var _a;
         const resultExpr = {
             node: 'case',
             kids: {
@@ -39,9 +59,10 @@ class Case extends expression_def_1.ExpressionDef {
         const dependents = [];
         let value = undefined;
         if (this.value) {
-            value = this.value.getExpression(fs);
-            dependents.push(value);
-            resultExpr.kids.caseValue = value.value;
+            const v = this.value.getExpression(fs);
+            dependents.push(v);
+            resultExpr.kids.caseValue = v.value;
+            value = v;
         }
         const choiceValues = [];
         for (const c of this.choices) {
@@ -53,24 +74,24 @@ class Case extends expression_def_1.ExpressionDef {
         let returnType;
         for (const aChoice of choiceValues) {
             if (value !== undefined) {
-                if (!fragtype_utils_1.FT.typeEq(aChoice.when, value)) {
+                if (!TDU.typeEq(aChoice.when, value)) {
                     return this.loggedErrorExpr('case-when-type-does-not-match', {
-                        whenType: aChoice.when.dataType,
-                        valueType: value.dataType,
+                        whenType: aChoice.when.type,
+                        valueType: value.type,
                     });
                 }
             }
             else {
-                if (!fragtype_utils_1.FT.typeEq(aChoice.when, fragtype_utils_1.FT.boolT)) {
+                if (!TDU.typeEq(aChoice.when, TDU.boolT)) {
                     return this.loggedErrorExpr('case-when-must-be-boolean', {
-                        whenType: aChoice.when.dataType,
+                        whenType: aChoice.when.type,
                     });
                 }
             }
-            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, aChoice.then, true)) {
+            if (returnType && !TDU.typeEq(returnType, aChoice.then, true)) {
                 return this.loggedErrorExpr('case-then-type-does-not-match', {
-                    thenType: aChoice.then.dataType,
-                    returnType: returnType.dataType,
+                    thenType: aChoice.then.type,
+                    returnType: returnType.type,
                 });
             }
             returnType = typeCoalesce(returnType, aChoice.then);
@@ -79,10 +100,10 @@ class Case extends expression_def_1.ExpressionDef {
         }
         if (this.elseValue) {
             const elseValue = this.elseValue.getExpression(fs);
-            if (returnType && !fragtype_utils_1.FT.typeEq(returnType, elseValue, true)) {
+            if (returnType && !TDU.typeEq(returnType, elseValue, true)) {
                 return this.loggedErrorExpr('case-else-type-does-not-match', {
-                    elseType: elseValue.dataType,
-                    returnType: returnType.dataType,
+                    elseType: elseValue.type,
+                    returnType: returnType.type,
                 });
             }
             returnType = typeCoalesce(returnType, elseValue);
@@ -91,7 +112,7 @@ class Case extends expression_def_1.ExpressionDef {
         }
         return (0, expr_value_1.computedExprValue)({
             value: resultExpr,
-            dataType: (_a = returnType === null || returnType === void 0 ? void 0 : returnType.dataType) !== null && _a !== void 0 ? _a : 'null',
+            dataType: returnType ? TDU.atomicDef(returnType) : { type: 'null' },
             from: dependents,
         });
     }

package/dist/lang/ast/expressions/expr-aggregate-function.d.ts

@@ -1,4 +1,4 @@
-import { AggregateFunctionType, FieldValueType } from '../../../model/malloy_types';
+import { AggregateFunctionType } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
@@ -12,7 +12,7 @@ export declare abstract class ExprAggregateFunction extends ExpressionDef {
     explicitSource?: boolean;
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
     constructor(func: AggregateFunctionType, expr?: ExpressionDef, explicitSource?: boolean);
-    returns(_forExpression: ExprValue): FieldValueType;
+    abstract returns(fromExpr: ExprValue): ExprValue;
     getExpression(fs: FieldSpace): ExprValue;
     isSymmetricFunction(): boolean;
     getJoinUsage(fs: FieldSpace): JoinPath[];

package/dist/lang/ast/expressions/expr-aggregate-function.js

@@ -21,13 +21,36 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExprAggregateFunction = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const utils_1 = require("../../../model/utils");
 const ast_utils_1 = require("../ast-utils");
 const static_space_1 = require("../field-space/static-space");
-const fragtype_utils_1 = require("../fragtype-utils");
+const TDU = __importStar(require("../typedesc-utils"));
 const field_references_1 = require("../query-items/field-references");
 const expression_def_1 = require("../types/expression-def");
 const space_field_1 = require("../types/space-field");
@@ -36,7 +59,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
     constructor(func, expr, explicitSource) {
         super();
         this.func = func;
-        this.legalChildTypes = [fragtype_utils_1.FT.numberT];
+        this.legalChildTypes = [TDU.numberT];
         this.elementType = func;
         this.explicitSource = explicitSource;
         if (expr) {
@@ -44,9 +67,6 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
             this.has({ expr: expr });
         }
     }
-    returns(_forExpression) {
-        return 'number';
-    }
     getExpression(fs) {
         var _a, _b, _c;
         // It is never useful to use output fields in an aggregate expression
@@ -63,10 +83,10 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 const sourceFoot = result.found;
                 const footType = sourceFoot.typeDesc();
                 if (!(sourceFoot instanceof static_space_1.StructSpaceField)) {
-                    if ((0, malloy_types_1.isAtomicFieldType)(footType.dataType)) {
+                    if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
                         expr = this.source;
                         exprVal = {
-                            dataType: footType.dataType,
+                            ...TDU.atomicDef(footType),
                             expressionType: footType.expressionType,
                             value: footType.evalSpace === 'output'
                                 ? { node: 'outputField', name: this.source.refString }
@@ -87,7 +107,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                         }
                     }
                     else {
-                        return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.dataType}`);
+                        return this.loggedErrorExpr('invalid-aggregate-source', `Aggregate source cannot be a ${footType.type}`);
                     }
                 }
             }
@@ -101,7 +121,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
         if ((0, malloy_types_1.expressionIsAggregate)(exprVal.expressionType)) {
             return this.loggedErrorExpr('aggregate-of-aggregate', 'Aggregate expression cannot be aggregate');
         }
-        const isAnError = exprVal.dataType === 'error';
+        const isAnError = exprVal.type === 'error';
         if (!isAnError) {
             const joinUsage = this.getJoinUsage(inputFS);
             // Did the user spceify a source, either as `source.agg()` or `path.to.join.agg()` or `path.to.field.agg()`
@@ -141,7 +161,7 @@ class ExprAggregateFunction extends expression_def_1.ExpressionDef {
                 f.structPath = structPath;
             }
             return {
-                dataType: this.returns(exprVal),
+                ...this.returns(exprVal),
                 expressionType: 'aggregate',
                 value: f,
                 evalSpace: 'output',

package/dist/lang/ast/expressions/expr-alternation-tree.js

@@ -77,7 +77,7 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
                 const isIn = expr.getExpression(fs);
                 const values = inList.map(v => v.getExpression(fs));
                 return (0, expr_value_1.computedExprValue)({
-                    dataType: 'boolean',
+                    dataType: { type: 'boolean' },
                     value: {
                         node: 'in',
                         not: applyOp === '!=',
@@ -93,7 +93,7 @@ class ExprAlternationTree extends expression_def_1.ExpressionDef {
         const choice1 = this.left.apply(fs, applyOp, expr);
         const choice2 = this.right.apply(fs, applyOp, expr);
         return (0, expr_value_1.computedExprValue)({
-            dataType: 'boolean',
+            dataType: { type: 'boolean' },
             value: {
                 node: this.op === '&' ? 'and' : 'or',
                 kids: { left: choice1.value, right: choice2.value },

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

@@ -1,4 +1,5 @@
 import { FieldReference } from '../query-items/field-references';
+import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { ExprAggregateFunction } from './expr-aggregate-function';
 export declare abstract class ExprAsymmetric extends ExprAggregateFunction {
@@ -7,5 +8,6 @@ export declare abstract class ExprAsymmetric extends ExprAggregateFunction {
     readonly source?: FieldReference | undefined;
     constructor(func: 'sum' | 'avg', expr: ExpressionDef | undefined, source?: FieldReference | undefined, explicitSource?: boolean);
     isSymmetricFunction(): boolean;
+    returns(ev: ExprValue): ExprValue;
     defaultFieldName(): undefined | string;
 }

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

@@ -35,6 +35,9 @@ class ExprAsymmetric extends expr_aggregate_function_1.ExprAggregateFunction {
     isSymmetricFunction() {
         return false;
     }
+    returns(ev) {
+        return ev;
+    }
     defaultFieldName() {
         if (this.source && this.expr === undefined) {
             const tag = this.source.nameString;

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

@@ -36,17 +36,15 @@ class ExprCast extends expression_def_1.ExpressionDef {
     }
     getExpression(fs) {
         const expr = this.expr.getExpression(fs);
-        let dataType = 'error';
+        let dataType = { type: 'error' };
         if (typeof this.castType === 'string') {
-            dataType = this.castType;
+            dataType = { type: this.castType };
         }
         else {
             const dialect = fs.dialectObj();
             if (dialect) {
                 if (dialect.validateTypeName(this.castType.raw)) {
-                    // TODO theoretically `sqlTypeToMalloyType` can get number subtypes,
-                    // but `TypeDesc` does not support them.
-                    dataType = dialect.sqlTypeToMalloyType(this.castType.raw).type;
+                    dataType = dialect.sqlTypeToMalloyType(this.castType.raw);
                 }
                 else {
                     this.logError('invalid-sql-native-type', `Cast type \`${this.castType.raw}\` is invalid for ${dialect.name} dialect`);
@@ -58,7 +56,7 @@ class ExprCast extends expression_def_1.ExpressionDef {
         }
         return (0, expr_value_1.computedExprValue)({
             dataType,
-            value: (0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe),
+            value: (0, time_utils_1.castTo)(this.castType, expr.value, expr.type, this.safe),
             from: [expr],
         });
     }