@malloydata/malloy 0.0.79 → 0.0.80-dev230824170739

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import { DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
+import { DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../model/malloy_types';
 import { DialectFunctionOverloadDef } from './functions';
 interface DialectField {
     type: string;
@@ -77,5 +77,8 @@ export declare abstract class Dialect {
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlOrderBy(orderTerms: string[]): string;
     sqlTzStr(qi: QueryInfo): string;
+    abstract sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
+    abstract malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
+    abstract validateTypeName(sqlType: string): boolean;
 }
 export {};

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,4 +1,4 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../../model/malloy_types';
+import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class DuckDBDialect extends Dialect {
@@ -54,6 +54,9 @@ export declare class DuckDBDialect extends Dialect {
     sqlLiteralString(literal: string): string;
     sqlLiteralRegexp(literal: string): string;
     getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
+    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
     castToString(expression: string): string;
     concat(...values: string[]): string;
+    validateTypeName(sqlType: string): boolean;
 }

package/dist/dialect/duckdb/duckdb.js

@@ -29,14 +29,28 @@ const functions_1 = require("./functions");
 const dialect_1 = require("../dialect");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
-const castMap = {
-    'number': 'double precision',
-    'string': 'varchar',
-};
 const pgExtractionMap = {
     'day_of_week': 'dow',
     'day_of_year': 'doy',
 };
+const duckDBToMalloyTypes = {
+    'BIGINT': { type: 'number', numberType: 'integer' },
+    'INTEGER': { type: 'number', numberType: 'integer' },
+    'TINYINT': { type: 'number', numberType: 'integer' },
+    'SMALLINT': { type: 'number', numberType: 'integer' },
+    'UBIGINT': { type: 'number', numberType: 'integer' },
+    'UINTEGER': { type: 'number', numberType: 'integer' },
+    'UTINYINT': { type: 'number', numberType: 'integer' },
+    'USMALLINT': { type: 'number', numberType: 'integer' },
+    'HUGEINT': { type: 'number', numberType: 'integer' },
+    'DOUBLE': { type: 'number', numberType: 'float' },
+    'VARCHAR': { type: 'string' },
+    'DATE': { type: 'date' },
+    'TIMESTAMP': { type: 'timestamp' },
+    'TIME': { type: 'string' },
+    'DECIMAL': { type: 'number', numberType: 'float' },
+    'BOOLEAN': { type: 'boolean' },
+};
 class DuckDBDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
@@ -262,9 +276,11 @@ class DuckDBDialect extends dialect_1.Dialect {
             return (0, malloy_types_1.mkExpr) `CAST((${cast.expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
         }
         if (cast.srcType !== cast.dstType) {
-            const dstType = castMap[cast.dstType] || cast.dstType;
+            const dstType = typeof cast.dstType === 'string'
+                ? this.malloyTypeToSQLType({ type: cast.dstType })
+                : cast.dstType.raw;
             const castFunc = cast.safe ? 'TRY_CAST' : 'CAST';
-            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
+            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
         }
         return cast.expr;
     }
@@ -335,12 +351,37 @@ class DuckDBDialect extends dialect_1.Dialect {
     getGlobalFunctionDef(name) {
         return functions_1.DUCKDB_FUNCTIONS.get(name);
     }
+    malloyTypeToSQLType(malloyType) {
+        if (malloyType.type === 'number') {
+            if (malloyType.numberType === 'integer') {
+                return 'integer';
+            }
+            else {
+                return 'double precision';
+            }
+        }
+        else if (malloyType.type === 'string') {
+            return 'varchar';
+        }
+        return malloyType.type;
+    }
+    sqlTypeToMalloyType(sqlType) {
+        return duckDBToMalloyTypes[sqlType.toUpperCase()];
+    }
     castToString(expression) {
         return `CAST(${expression} as VARCHAR)`;
     }
     concat(...values) {
         return values.join(' || ');
     }
+    validateTypeName(sqlType) {
+        // Letters:              BIGINT
+        // Numbers:              INT8
+        // Spaces:               TIMESTAMP WITH TIME ZONE
+        // Parentheses, Commas:  DECIMAL(1, 1)
+        // Brackets:             INT[ ]
+        return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
+    }
 }
 exports.DuckDBDialect = DuckDBDialect;
 //# sourceMappingURL=duckdb.js.map

package/dist/dialect/postgres/postgres.d.ts

@@ -1,4 +1,4 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../../model/malloy_types';
+import { DateUnit, Expr, ExtractUnit, Sampling, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class PostgresDialect extends Dialect {
@@ -55,6 +55,9 @@ export declare class PostgresDialect extends Dialect {
     sqlLiteralString(literal: string): string;
     sqlLiteralRegexp(literal: string): string;
     getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
+    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
     castToString(expression: string): string;
     concat(...values: string[]): string;
+    validateTypeName(sqlType: string): boolean;
 }

package/dist/dialect/postgres/postgres.js

@@ -27,10 +27,6 @@ const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("./functions");
 const dialect_1 = require("../dialect");
-const castMap = {
-    'number': 'double precision',
-    'string': 'varchar',
-};
 const pgExtractionMap = {
     'day_of_week': 'dow',
     'day_of_year': 'doy',
@@ -51,6 +47,31 @@ const inSeconds = {
     'day': 24 * 3600,
     'week': 7 * 24 * 3600,
 };
+const postgresToMalloyTypes = {
+    'character varying': { type: 'string' },
+    'name': { type: 'string' },
+    'text': { type: 'string' },
+    'date': { type: 'date' },
+    'integer': { type: 'number', numberType: 'integer' },
+    'bigint': { type: 'number', numberType: 'integer' },
+    'double precision': { type: 'number', numberType: 'float' },
+    'timestamp without time zone': { type: 'timestamp' },
+    'oid': { type: 'string' },
+    'boolean': { type: 'boolean' },
+    // ARRAY: "string",
+    'timestamp': { type: 'timestamp' },
+    '"char"': { type: 'string' },
+    'character': { type: 'string' },
+    'smallint': { type: 'number', numberType: 'integer' },
+    'xid': { type: 'string' },
+    'real': { type: 'number', numberType: 'float' },
+    'interval': { type: 'string' },
+    'inet': { type: 'string' },
+    'regtype': { type: 'string' },
+    'numeric': { type: 'number', numberType: 'float' },
+    'bytea': { type: 'string' },
+    'pg_ndistinct': { type: 'number', numberType: 'integer' },
+};
 class PostgresDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
@@ -276,12 +297,14 @@ class PostgresDialect extends dialect_1.Dialect {
             return (0, malloy_types_1.mkExpr) `CAST((${cast.expr})::TIMESTAMP AT TIME ZONE '${tz}' AS TIMESTAMP)`;
         }
         if (cast.srcType !== cast.dstType) {
-            const dstType = castMap[cast.dstType] || cast.dstType;
+            const dstType = typeof cast.dstType === 'string'
+                ? this.malloyTypeToSQLType({ type: cast.dstType })
+                : cast.dstType.raw;
             if (cast.safe) {
                 throw new Error("Postgres dialect doesn't support Safe Cast");
             }
             const castFunc = 'CAST';
-            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
+            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
         }
         return cast.expr;
     }
@@ -357,12 +380,37 @@ class PostgresDialect extends dialect_1.Dialect {
     getGlobalFunctionDef(name) {
         return functions_1.POSTGRES_FUNCTIONS.get(name);
     }
+    malloyTypeToSQLType(malloyType) {
+        if (malloyType.type === 'number') {
+            if (malloyType.numberType === 'integer') {
+                return 'integer';
+            }
+            else {
+                return 'double precision';
+            }
+        }
+        else if (malloyType.type === 'string') {
+            return 'varchar';
+        }
+        return malloyType.type;
+    }
+    sqlTypeToMalloyType(sqlType) {
+        return postgresToMalloyTypes[sqlType.toLowerCase()];
+    }
     castToString(expression) {
         return `CAST(${expression} as VARCHAR)`;
     }
     concat(...values) {
         return values.join(' || ');
     }
+    validateTypeName(sqlType) {
+        // Letters:              BIGINT
+        // Numbers:              INT8
+        // Spaces:               TIMESTAMP WITH TIME ZONE
+        // Parentheses, Commas:  NUMERIC(5, 2)
+        // Square Brackets:      INT64[]
+        return sqlType.match(/^[A-Za-z\s(),[\]0-9]*$/) !== null;
+    }
 }
 exports.PostgresDialect = PostgresDialect;
 //# sourceMappingURL=postgres.js.map

package/dist/dialect/standardsql/standardsql.d.ts

@@ -1,4 +1,4 @@
-import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment } from '../../model/malloy_types';
+import { Expr, ExtractUnit, Sampling, TimeValue, TimestampUnit, TypecastFragment, FieldAtomicTypeDef } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
@@ -51,6 +51,9 @@ export declare class StandardSQLDialect extends Dialect {
     sqlLiteralString(literal: string): string;
     sqlLiteralRegexp(literal: string): string;
     getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
+    malloyTypeToSQLType(malloyType: FieldAtomicTypeDef): string;
+    sqlTypeToMalloyType(sqlType: string): FieldAtomicTypeDef | undefined;
     castToString(expression: string): string;
     concat(...values: string[]): string;
+    validateTypeName(sqlType: string): boolean;
 }

package/dist/dialect/standardsql/standardsql.js

@@ -27,9 +27,6 @@ const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
 const functions_1 = require("./functions");
 const dialect_1 = require("../dialect");
-const castMap = {
-    'number': 'float64',
-};
 // These are the units that "TIMESTAMP_ADD" "TIMESTAMP_DIFF" accept
 function timestampMeasureable(units) {
     return [
@@ -57,6 +54,25 @@ function qtz(qi) {
         return tz;
     }
 }
+const bqToMalloyTypes = {
+    'DATE': { type: 'date' },
+    'STRING': { type: 'string' },
+    'INTEGER': { type: 'number', numberType: 'integer' },
+    'INT64': { type: 'number', numberType: 'integer' },
+    'FLOAT': { type: 'number', numberType: 'float' },
+    'FLOAT64': { type: 'number', numberType: 'float' },
+    'NUMERIC': { type: 'number', numberType: 'float' },
+    'BIGNUMERIC': { type: 'number', numberType: 'float' },
+    'TIMESTAMP': { type: 'timestamp' },
+    'BOOLEAN': { type: 'boolean' },
+    'BOOL': { type: 'boolean' },
+    'JSON': { type: 'json' },
+    // TODO (https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#tablefieldschema):
+    // BYTES
+    // DATETIME
+    // TIME
+    // GEOGRAPHY
+};
 class StandardSQLDialect extends dialect_1.Dialect {
     constructor() {
         super(...arguments);
@@ -335,9 +351,11 @@ ${(0, utils_1.indent)(sql)}
             return (0, malloy_types_1.mkExpr) `TIMESTAMP(${cast.expr}, '${tz}')`;
         }
         if (cast.srcType !== cast.dstType) {
-            const dstType = castMap[cast.dstType] || cast.dstType;
+            const dstType = typeof cast.dstType === 'string'
+                ? this.malloyTypeToSQLType({ type: cast.dstType })
+                : cast.dstType.raw;
             const castFunc = cast.safe ? 'SAFE_CAST' : 'CAST';
-            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr}  AS ${dstType})`;
+            return (0, malloy_types_1.mkExpr) `${castFunc}(${cast.expr} AS ${dstType})`;
         }
         return cast.expr;
     }
@@ -417,12 +435,34 @@ ${(0, utils_1.indent)(sql)}
     getGlobalFunctionDef(name) {
         return functions_1.STANDARDSQL_FUNCTIONS.get(name);
     }
+    malloyTypeToSQLType(malloyType) {
+        if (malloyType.type === 'number') {
+            if (malloyType.numberType === 'integer') {
+                return 'INT64';
+            }
+            else {
+                return 'FLOAT64';
+            }
+        }
+        return malloyType.type;
+    }
+    sqlTypeToMalloyType(sqlType) {
+        return bqToMalloyTypes[sqlType.toUpperCase()];
+    }
     castToString(expression) {
         return `CAST(${expression} as STRING)`;
     }
     concat(...values) {
         return values.join(' || ');
     }
+    validateTypeName(sqlType) {
+        // Letters:              BIGINT
+        // Numbers:              INT8
+        // Spaces,
+        // Parentheses, Commas:  NUMERIC(5, 2)
+        // Angle Brackets:       ARRAY<INT64>
+        return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
+    }
 }
 exports.StandardSQLDialect = StandardSQLDialect;
 //# sourceMappingURL=standardsql.js.map

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { DuckDBDialect, StandardSQLDialect, PostgresDialect } from './dialect';
 export type { QueryDataRow, Fragment, StructDef, StructRelationship, NamedStructDefs, MalloyQueryData, AtomicFieldType as AtomicFieldTypeInner, DateUnit, ExtractUnit, TimestampUnit, TimeFieldType, QueryData, QueryValue, FieldTypeDef, Expr, DialectFragment, TimeValue, FilterExpression, SQLBlock, FieldAtomicDef, FieldDef, FilteredAliasedName, PipeSegment, QueryFieldDef, TurtleDef, SearchValueMapResult, SearchIndexResult, ModelDef, Query, QueryRunStats, NamedQuery, NamedModelObject, ExpressionType, FunctionDef, FunctionOverloadDef, FunctionParameterDef, ExpressionValueType, TypeDesc, FieldValueType, ExpressionTypeDesc, FunctionParamTypeDesc, DocumentLocation, DocumentRange, DocumentPosition, Annotation, } from './model';
 export { Segment, isFilteredAliasedName, flattenQuery, expressionIsCalculation, } from './model';
 export { HighlightType, MalloyTranslator, } from './lang';

package/dist/index.js

@@ -22,7 +22,11 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tag = exports.toAsyncGenerator = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.MalloyTranslator = exports.HighlightType = exports.expressionIsCalculation = exports.flattenQuery = exports.isFilteredAliasedName = exports.Segment = void 0;
+exports.Tag = exports.toAsyncGenerator = exports.Explore = exports.DataWriter = exports.Parse = exports.JSONWriter = exports.CSVWriter = exports.QueryMaterializer = exports.Result = exports.TimestampTimeframe = exports.DateTimeframe = exports.SourceRelationship = exports.JoinRelationship = exports.MalloyError = exports.FixedConnectionMap = exports.InMemoryURLReader = exports.EmptyURLReader = exports.SingleConnectionRuntime = exports.ConnectionRuntime = exports.AtomicFieldType = exports.Runtime = exports.Malloy = exports.MalloyTranslator = exports.HighlightType = exports.expressionIsCalculation = exports.flattenQuery = exports.isFilteredAliasedName = exports.Segment = exports.PostgresDialect = exports.StandardSQLDialect = exports.DuckDBDialect = void 0;
+var dialect_1 = require("./dialect");
+Object.defineProperty(exports, "DuckDBDialect", { enumerable: true, get: function () { return dialect_1.DuckDBDialect; } });
+Object.defineProperty(exports, "StandardSQLDialect", { enumerable: true, get: function () { return dialect_1.StandardSQLDialect; } });
+Object.defineProperty(exports, "PostgresDialect", { enumerable: true, get: function () { return dialect_1.PostgresDialect; } });
 var model_1 = require("./model");
 // Used in Composer Demo
 Object.defineProperty(exports, "Segment", { enumerable: true, get: function () { return model_1.Segment; } });

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

@@ -1,13 +1,16 @@
+import { CastType } from '../../../model';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
-export type CastType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp';
-export declare function isCastType(t: string): t is CastType;
 export declare class ExprCast extends ExpressionDef {
     readonly expr: ExpressionDef;
-    readonly castType: CastType;
+    readonly castType: CastType | {
+        raw: string;
+    };
     readonly safe: boolean;
     elementType: string;
-    constructor(expr: ExpressionDef, castType: CastType, safe?: boolean);
+    constructor(expr: ExpressionDef, castType: CastType | {
+        raw: string;
+    }, safe?: boolean);
     getExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -22,14 +22,10 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprCast = exports.isCastType = void 0;
+exports.ExprCast = void 0;
 const time_utils_1 = require("../time-utils");
 const expression_def_1 = require("../types/expression-def");
 const utils_1 = require("./utils");
-function isCastType(t) {
-    return ['string', 'number', 'boolean', 'date', 'timestamp'].includes(t);
-}
-exports.isCastType = isCastType;
 class ExprCast extends expression_def_1.ExpressionDef {
     constructor(expr, castType, safe = false) {
         super({ expr: expr });
@@ -39,9 +35,28 @@ class ExprCast extends expression_def_1.ExpressionDef {
         this.elementType = 'cast';
     }
     getExpression(fs) {
+        var _a, _b, _c;
         const expr = this.expr.getExpression(fs);
+        let dataType = 'unsupported';
+        if (typeof this.castType === 'string') {
+            dataType = 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 =
+                        (_c = (_b = (_a = fs.dialectObj()) === null || _a === void 0 ? void 0 : _a.sqlTypeToMalloyType(this.castType.raw)) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : 'unsupported';
+                }
+                else {
+                    this.log(`Cast type \`${this.castType.raw}\` is invalid for ${dialect.name} dialect`);
+                }
+            }
+        }
         return {
-            dataType: this.castType,
+            dataType,
             expressionType: expr.expressionType,
             value: (0, utils_1.compressExpr)((0, time_utils_1.castTo)(this.castType, expr.value, expr.dataType, this.safe)),
             evalSpace: expr.evalSpace,

package/dist/lang/ast/parameters/has-parameter.d.ts

@@ -1,4 +1,4 @@
-import { AtomicFieldType, Parameter } from '../../../model/malloy_types';
+import { Parameter, CastType } from '../../../model/malloy_types';
 import { ConstantSubExpression } from '../expressions/constant-sub-expression';
 import { MalloyElement } from '../types/malloy-element';
 interface HasInit {
@@ -11,7 +11,7 @@ export declare class HasParameter extends MalloyElement {
     elementType: string;
     readonly name: string;
     readonly isCondition: boolean;
-    readonly type?: AtomicFieldType;
+    readonly type?: CastType;
     readonly default?: ConstantSubExpression;
     constructor(init: HasInit);
     parameter(): Parameter;

package/dist/lang/ast/parameters/has-parameter.js

@@ -31,7 +31,7 @@ class HasParameter extends malloy_element_1.MalloyElement {
         this.elementType = 'hasParameter';
         this.name = init.name;
         this.isCondition = init.isCondition;
-        if (init.type && (0, malloy_types_1.isAtomicFieldType)(init.type)) {
+        if (init.type && (0, malloy_types_1.isCastType)(init.type)) {
             this.type = init.type;
         }
         if (init.default) {

package/dist/lang/ast/query-items/field-declaration.js

@@ -76,7 +76,7 @@ class FieldDeclaration extends malloy_element_1.MalloyElement {
         }
         const compressValue = (0, utils_1.compressExpr)(exprValue.value);
         const retType = exprValue.dataType;
-        if ((0, malloy_types_1.isAtomicFieldType)(retType)) {
+        if ((0, malloy_types_1.isAtomicFieldType)(retType) && retType !== 'error') {
             const template = {
                 name: exprName,
                 type: retType,

package/dist/lang/ast/sources/named-source.js

@@ -130,7 +130,7 @@ class NamedSource extends source_1.Source {
                     else {
                         const pVal = pExpr.constantValue();
                         let value = pVal.value;
-                        if (pVal.dataType !== decl.type) {
+                        if (pVal.dataType !== decl.type && (0, malloy_types_1.isCastType)(decl.type)) {
                             value = (0, time_utils_1.castTo)(decl.type, pVal.value, pVal.dataType, true);
                         }
                         decl.value = value;

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

@@ -1,7 +1,9 @@
-import { AtomicFieldType, Expr, Fragment, TimeFieldType, TimestampUnit, FieldValueType } from '../../model/malloy_types';
+import { Expr, Fragment, TimeFieldType, TimestampUnit, FieldValueType, CastType } 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 castTo(castType: AtomicFieldType, from: Expr, fromType: FieldValueType, safe?: boolean): Expr;
+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;
 export declare function resolution(timeframe: string): TimeFieldType;

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

@@ -265,24 +265,25 @@ export declare class MalloyParser extends Parser {
     static readonly RULE_id = 104;
     static readonly RULE_timeframe = 105;
     static readonly RULE_ungroup = 106;
-    static readonly RULE_fieldExpr = 107;
-    static readonly RULE_partialAllowedFieldExpr = 108;
-    static readonly RULE_pickStatement = 109;
-    static readonly RULE_pick = 110;
-    static readonly RULE_argumentList = 111;
-    static readonly RULE_fieldNameList = 112;
-    static readonly RULE_fieldCollection = 113;
-    static readonly RULE_collectionWildCard = 114;
-    static readonly RULE_taggedRef = 115;
-    static readonly RULE_refExpr = 116;
-    static readonly RULE_collectionMember = 117;
-    static readonly RULE_fieldPath = 118;
-    static readonly RULE_joinName = 119;
-    static readonly RULE_fieldName = 120;
-    static readonly RULE_justExpr = 121;
-    static readonly RULE_sqlExploreNameRef = 122;
-    static readonly RULE_nameSQLBlock = 123;
-    static readonly RULE_connectionName = 124;
+    static readonly RULE_malloyOrSQLType = 107;
+    static readonly RULE_fieldExpr = 108;
+    static readonly RULE_partialAllowedFieldExpr = 109;
+    static readonly RULE_pickStatement = 110;
+    static readonly RULE_pick = 111;
+    static readonly RULE_argumentList = 112;
+    static readonly RULE_fieldNameList = 113;
+    static readonly RULE_fieldCollection = 114;
+    static readonly RULE_collectionWildCard = 115;
+    static readonly RULE_taggedRef = 116;
+    static readonly RULE_refExpr = 117;
+    static readonly RULE_collectionMember = 118;
+    static readonly RULE_fieldPath = 119;
+    static readonly RULE_joinName = 120;
+    static readonly RULE_fieldName = 121;
+    static readonly RULE_justExpr = 122;
+    static readonly RULE_sqlExploreNameRef = 123;
+    static readonly RULE_nameSQLBlock = 124;
+    static readonly RULE_connectionName = 125;
     static readonly ruleNames: string[];
     private static readonly _LITERAL_NAMES;
     private static readonly _SYMBOLIC_NAMES;
@@ -400,6 +401,7 @@ export declare class MalloyParser extends Parser {
     id(): IdContext;
     timeframe(): TimeframeContext;
     ungroup(): UngroupContext;
+    malloyOrSQLType(): MalloyOrSQLTypeContext;
     fieldExpr(): FieldExprContext;
     fieldExpr(_p: number): FieldExprContext;
     partialAllowedFieldExpr(): PartialAllowedFieldExprContext;
@@ -1883,6 +1885,15 @@ export declare class UngroupContext extends ParserRuleContext {
     exitRule(listener: MalloyParserListener): void;
     accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
 }
+export declare class MalloyOrSQLTypeContext extends ParserRuleContext {
+    malloyType(): MalloyTypeContext | undefined;
+    string(): StringContext | undefined;
+    constructor(parent: ParserRuleContext | undefined, invokingState: number);
+    get ruleIndex(): number;
+    enterRule(listener: MalloyParserListener): void;
+    exitRule(listener: MalloyParserListener): void;
+    accept<Result>(visitor: MalloyParserVisitor<Result>): Result;
+}
 export declare class FieldExprContext extends ParserRuleContext {
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
@@ -1932,7 +1943,7 @@ export declare class ExprTimeTruncContext extends FieldExprContext {
 export declare class ExprCastContext extends FieldExprContext {
     fieldExpr(): FieldExprContext;
     DOUBLECOLON(): TerminalNode | undefined;
-    malloyType(): MalloyTypeContext;
+    malloyOrSQLType(): MalloyOrSQLTypeContext;
     CAST(): TerminalNode | undefined;
     OPAREN(): TerminalNode | undefined;
     AS(): TerminalNode | undefined;
@@ -1945,7 +1956,7 @@ export declare class ExprCastContext extends FieldExprContext {
 export declare class ExprSafeCastContext extends FieldExprContext {
     fieldExpr(): FieldExprContext;
     TRIPLECOLON(): TerminalNode;
-    malloyType(): MalloyTypeContext;
+    malloyOrSQLType(): MalloyOrSQLTypeContext;
     constructor(ctx: FieldExprContext);
     enterRule(listener: MalloyParserListener): void;
     exitRule(listener: MalloyParserListener): void;