@malloydata/malloy 0.0.203-dev241021134413 → 0.0.203-dev241022191525

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

@@ -24,6 +24,8 @@ import { TableMethodContext } from "./MalloyParser";
 import { NestDefContext } from "./MalloyParser";
 import { ExprFieldPathContext } from "./MalloyParser";
 import { ExprLiteralContext } from "./MalloyParser";
+import { ExprArrayLiteralContext } from "./MalloyParser";
+import { ExprLiteralRecordContext } from "./MalloyParser";
 import { ExprFieldPropsContext } from "./MalloyParser";
 import { ExprDurationContext } from "./MalloyParser";
 import { ExprTimeTruncContext } from "./MalloyParser";
@@ -215,10 +217,11 @@ import { CollectionMemberContext } from "./MalloyParser";
 import { FieldPathContext } from "./MalloyParser";
 import { JoinNameContext } from "./MalloyParser";
 import { FieldNameContext } from "./MalloyParser";
-import { JustExprContext } from "./MalloyParser";
 import { SqlExploreNameRefContext } from "./MalloyParser";
 import { NameSQLBlockContext } from "./MalloyParser";
 import { ConnectionNameContext } from "./MalloyParser";
+import { DebugExprContext } from "./MalloyParser";
+import { DebugPartialContext } from "./MalloyParser";
 import { ExperimentalStatementForTestingContext } from "./MalloyParser";
 /**
  * This interface defines a complete listener for a parse tree produced by
@@ -525,6 +528,30 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitExprLiteral?: (ctx: ExprLiteralContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprArrayLiteral`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprArrayLiteral?: (ctx: ExprArrayLiteralContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprArrayLiteral`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprArrayLiteral?: (ctx: ExprArrayLiteralContext) => void;
+    /**
+     * Enter a parse tree produced by the `exprLiteralRecord`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    enterExprLiteralRecord?: (ctx: ExprLiteralRecordContext) => void;
+    /**
+     * Exit a parse tree produced by the `exprLiteralRecord`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     */
+    exitExprLiteralRecord?: (ctx: ExprLiteralRecordContext) => void;
     /**
      * Enter a parse tree produced by the `exprFieldProps`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -2549,16 +2576,6 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitFieldName?: (ctx: FieldNameContext) => void;
-    /**
-     * Enter a parse tree produced by `MalloyParser.justExpr`.
-     * @param ctx the parse tree
-     */
-    enterJustExpr?: (ctx: JustExprContext) => void;
-    /**
-     * Exit a parse tree produced by `MalloyParser.justExpr`.
-     * @param ctx the parse tree
-     */
-    exitJustExpr?: (ctx: JustExprContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.sqlExploreNameRef`.
      * @param ctx the parse tree
@@ -2589,6 +2606,26 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitConnectionName?: (ctx: ConnectionNameContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.debugExpr`.
+     * @param ctx the parse tree
+     */
+    enterDebugExpr?: (ctx: DebugExprContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.debugExpr`.
+     * @param ctx the parse tree
+     */
+    exitDebugExpr?: (ctx: DebugExprContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.debugPartial`.
+     * @param ctx the parse tree
+     */
+    enterDebugPartial?: (ctx: DebugPartialContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.debugPartial`.
+     * @param ctx the parse tree
+     */
+    exitDebugPartial?: (ctx: DebugPartialContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.experimentalStatementForTesting`.
      * @param ctx the parse tree

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

@@ -24,6 +24,8 @@ import { TableMethodContext } from "./MalloyParser";
 import { NestDefContext } from "./MalloyParser";
 import { ExprFieldPathContext } from "./MalloyParser";
 import { ExprLiteralContext } from "./MalloyParser";
+import { ExprArrayLiteralContext } from "./MalloyParser";
+import { ExprLiteralRecordContext } from "./MalloyParser";
 import { ExprFieldPropsContext } from "./MalloyParser";
 import { ExprDurationContext } from "./MalloyParser";
 import { ExprTimeTruncContext } from "./MalloyParser";
@@ -215,10 +217,11 @@ import { CollectionMemberContext } from "./MalloyParser";
 import { FieldPathContext } from "./MalloyParser";
 import { JoinNameContext } from "./MalloyParser";
 import { FieldNameContext } from "./MalloyParser";
-import { JustExprContext } from "./MalloyParser";
 import { SqlExploreNameRefContext } from "./MalloyParser";
 import { NameSQLBlockContext } from "./MalloyParser";
 import { ConnectionNameContext } from "./MalloyParser";
+import { DebugExprContext } from "./MalloyParser";
+import { DebugPartialContext } from "./MalloyParser";
 import { ExperimentalStatementForTestingContext } from "./MalloyParser";
 /**
  * This interface defines a complete generic visitor for a parse tree produced
@@ -403,6 +406,20 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitExprLiteral?: (ctx: ExprLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprArrayLiteral`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprArrayLiteral?: (ctx: ExprArrayLiteralContext) => Result;
+    /**
+     * Visit a parse tree produced by the `exprLiteralRecord`
+     * labeled alternative in `MalloyParser.fieldExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExprLiteralRecord?: (ctx: ExprLiteralRecordContext) => Result;
     /**
      * Visit a parse tree produced by the `exprFieldProps`
      * labeled alternative in `MalloyParser.fieldExpr`.
@@ -1606,12 +1623,6 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitFieldName?: (ctx: FieldNameContext) => Result;
-    /**
-     * Visit a parse tree produced by `MalloyParser.justExpr`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitJustExpr?: (ctx: JustExprContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.sqlExploreNameRef`.
      * @param ctx the parse tree
@@ -1630,6 +1641,18 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitConnectionName?: (ctx: ConnectionNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.debugExpr`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitDebugExpr?: (ctx: DebugExprContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.debugPartial`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitDebugPartial?: (ctx: DebugPartialContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.experimentalStatementForTesting`.
      * @param ctx the parse tree

package/dist/lang/malloy-to-ast.d.ts

@@ -200,7 +200,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitLiteralQuarter(pcx: parse.LiteralQuarterContext): ast.ExpressionDef;
     visitLiteralYear(pcx: parse.LiteralYearContext): ast.ExpressionDef;
     visitImportStatement(pcx: parse.ImportStatementContext): ast.ImportStatement;
-    visitJustExpr(pcx: parse.JustExprContext): ast.ExpressionDef;
+    visitDebugExpr(pcx: parse.DebugExprContext): ast.ExpressionDef;
     visitSampleStatement(pcx: parse.SampleStatementContext): ast.SampleProperty;
     visitDocAnnotations(pcx: parse.DocAnnotationsContext): ast.ModelAnnotation;
     visitIgnoredObjectAnnotations(pcx: parse.IgnoredObjectAnnotationsContext): IgnoredElement;
@@ -224,6 +224,9 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitSQTable(pcx: parse.SQTableContext): ast.SQSource | ErrorNode;
     visitSQSQL(pcx: parse.SQSQLContext): ast.SQSource;
     visitExperimentalStatementForTesting(pcx: parse.ExperimentalStatementForTestingContext): ast.ExperimentalExperiment;
+    visitRecordRef(pcx: parse.RecordRefContext): ast.RecordElement;
+    visitRecordExpr(pcx: parse.RecordExprContext): ast.RecordElement;
+    visitExprLiteralRecord(pcx: parse.ExprLiteralRecordContext): ast.RecordLiteral;
     visitExprWarnLike(pcx: parse.ExprWarnLikeContext): ast.ExprCompare;
     visitExprWarnNullCmp(pcx: parse.ExprWarnNullCmpContext): ast.ExprCompare;
     visitExprWarnIn(pcx: parse.ExprWarnInContext): ast.ExprLegacyIn;

package/dist/lang/malloy-to-ast.js

@@ -419,9 +419,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return { joinAs, joinFrom: new ast.SQReference(joinAs), notes: [] };
     }
     visitQueryJoinStatement(pcx) {
-        const result = this.astAt(this.visit(pcx.joinStatement()), pcx);
-        this.m4advisory(pcx, 'join-statement-in-view', 'Joins in queries are deprecated, move into an `extend:` block.');
-        return result;
+        return this.astAt(this.visit(pcx.joinStatement()), pcx);
     }
     visitJoinOn(pcx) {
         var _a;
@@ -1203,7 +1201,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         }
         return importStmt;
     }
-    visitJustExpr(pcx) {
+    visitDebugExpr(pcx) {
         return this.getFieldExpr(pcx.fieldExpr());
     }
     visitSampleStatement(pcx) {
@@ -1336,34 +1334,25 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         this.inExperiment('compilerTestExperimentParse', pcx);
         return this.astAt(new ast.ExperimentalExperiment('compilerTestExperimentTranslate'), pcx);
     }
-    // visitRecordRef(pcx: parse.RecordRefContext) {
-    //   const pathCx = pcx.fieldPath();
-    //   const tailEl = pathCx.fieldName().at(-1);
-    //   if (tailEl) {
-    //     const elementKey = getId(tailEl);
-    //     const idRef = new ast.ExprIdReference(
-    //       this.getFieldPath(pathCx, ast.ExpressionFieldReference)
-    //     );
-    //     return new ast.RecordElement(elementKey, idRef);
-    //   }
-    //   throw this.internalError(
-    //     pathCx,
-    //     'IMPOSSIBLY A PATH CONTAINED ZERO ELEMENTS'
-    //   );
-    // }
-    // visitRecordExpr(pcx: parse.RecordExprContext) {
-    //   const elementKey = getId(pcx.recordKey());
-    //   const elementVal = this.getFieldExpr(pcx.fieldExpr());
-    //   return new ast.RecordElement(elementKey, elementVal);
-    // }
-    // visitExprLiteralRecord(pcx: parse.ExprLiteralRecordContext) {
-    //   const els = this.only<ast.RecordElement>(
-    //     pcx.recordElement().map(elCx => this.astAt(this.visit(elCx), elCx)),
-    //     visited => visited instanceof ast.RecordElement && visited,
-    //     'a key value pair'
-    //   );
-    //   return new ast.RecordLiteral(els);
-    // }
+    visitRecordRef(pcx) {
+        const pathCx = pcx.fieldPath();
+        const tailEl = pathCx.fieldName().at(-1);
+        if (tailEl) {
+            const elementKey = (0, parse_utils_1.getId)(tailEl);
+            const idRef = new ast.ExprIdReference(this.getFieldPath(pathCx, ast.ExpressionFieldReference));
+            return new ast.RecordElement(elementKey, idRef);
+        }
+        throw this.internalError(pathCx, 'IMPOSSIBLY A PATH CONTAINED ZERO ELEMENTS');
+    }
+    visitRecordExpr(pcx) {
+        const elementKey = (0, parse_utils_1.getId)(pcx.recordKey());
+        const elementVal = this.getFieldExpr(pcx.fieldExpr());
+        return new ast.RecordElement(elementKey, elementVal);
+    }
+    visitExprLiteralRecord(pcx) {
+        const els = this.only(pcx.recordElement().map(elCx => this.astAt(this.visit(elCx), elCx)), visited => visited instanceof ast.RecordElement && visited, 'a key value pair');
+        return new ast.RecordLiteral(els);
+    }
     visitExprWarnLike(pcx) {
         let op = '~';
         const left = pcx.fieldExpr(0);

package/dist/lang/test/query.spec.js

@@ -923,8 +923,13 @@ describe('query:', () => {
           source: a2 is a extend { ${'declare: x is 1'} }`).toLog((0, test_translator_1.warningMessage)('`declare:` is deprecated; use `dimension:` or `measure:` inside a source or `extend:` block'));
             });
             test('joins in query', () => {
-                expect((0, test_translator_1.markSource) `##! m4warnings=warn
-          run: a -> { ${'join_one: b on true'}; ${'join_many: c is b on true'}; ${'join_cross: d is b on true'}; group_by: b.astr }`).toLog((0, test_translator_1.warningMessage)('Joins in queries are deprecated, move into an `extend:` block.'), (0, test_translator_1.warningMessage)('Joins in queries are deprecated, move into an `extend:` block.'), (0, test_translator_1.warningMessage)('Joins in queries are deprecated, move into an `extend:` block.'));
+                expect((0, test_translator_1.markSource) `
+          run: a -> {
+            join_one: b on true
+            join_many: c is b on true
+            join_cross: d is b on true
+            group_by: b.astr
+          }`).toTranslate();
             });
         });
         test('refine query with extended source', () => {

package/dist/lang/test/test-translator.js

@@ -387,7 +387,7 @@ exports.TestTranslator = TestTranslator;
 TestTranslator.inspectCompile = false;
 class BetaExpression extends TestTranslator {
     constructor(src) {
-        super(src, null, null, 'justExpr');
+        super(src, null, null, 'debugExpr');
     }
     testFS() {
         const aStruct = this.internalModel.contents['ab'];

package/dist/model/malloy_query.d.ts

@@ -264,6 +264,7 @@ declare class QueryQuery extends QueryField {
     expandFilters(resultStruct: FieldInstanceResult): void;
     generateSQLFilters(resultStruct: FieldInstanceResult, which: 'where' | 'having'): AndChain;
     prepare(_stageWriter: StageWriter | undefined): void;
+    addAlwaysJoins(rootResult: FieldInstanceResultRoot): void;
     getResultMetadata(fi: FieldInstance): ResultStructMetadataDef | ResultMetadataDef | undefined;
     /**  returns a fields and primary key of a struct for this query */
     getResultStructDef(resultStruct?: FieldInstanceResult, isRoot?: boolean): SourceDef;

package/dist/model/malloy_query.js

@@ -965,7 +965,7 @@ class QueryFieldDate extends QueryAtomicField {
         else {
             const truncated = {
                 node: 'trunc',
-                e: { ...this.getExpr(), dataType: 'date' },
+                e: (0, malloy_types_1.mkTemporal)(this.getExpr(), 'date'),
                 units: fd.timeframe,
             };
             return this.exprToSQL(resultSet, this.parent, truncated);
@@ -1802,10 +1802,24 @@ class QueryQuery extends QueryField {
             this.expandFields(this.rootResult);
             this.rootResult.addStructToJoin(this.parent, this, undefined, []);
             this.rootResult.findJoins(this);
+            this.addAlwaysJoins(this.rootResult);
             this.rootResult.calculateSymmetricAggregates();
             this.prepared = true;
         }
     }
+    addAlwaysJoins(rootResult) {
+        var _a;
+        const stage = this.fieldDef.pipeline[0];
+        if (stage.type !== 'raw') {
+            const alwaysJoins = (_a = stage.alwaysJoins) !== null && _a !== void 0 ? _a : [];
+            for (const joinName of alwaysJoins) {
+                const qs = this.parent.getChildByName(joinName);
+                if (qs instanceof QueryStruct) {
+                    rootResult.addStructToJoin(qs, this, undefined, []);
+                }
+            }
+        }
+    }
     // get the source fieldname and filters associated with the field (so we can drill later)
     getResultMetadata(fi) {
         if (fi instanceof FieldInstanceField) {

package/dist/model/malloy_types.d.ts

@@ -8,7 +8,7 @@
  */
 export interface ExprLeaf {
     node: string;
-    dataType?: AtomicFieldType;
+    typeDef?: AtomicTypeDef;
     sql?: string;
 }
 export interface ExprE extends ExprLeaf {
@@ -24,11 +24,11 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeDeltaExpr | TimeTruncExpr | TimeExtractExpr | TypecastExpr | RegexMatchExpr | RegexLiteralNode | TimeLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | ErrorNode;
-interface HasDataType {
-    dataType: AtomicFieldType;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | TimeLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | ErrorNode;
+interface HasTypeDef {
+    typeDef: AtomicTypeDef;
 }
-export type TypedExpr = Expr & HasDataType;
+export type TypedExpr = Expr & HasTypeDef;
 export type BinaryOperator = '+' | '-' | '*' | '%' | '/' | 'and' | 'or' | '=' | '!=' | '>' | '<' | '>=' | '<=' | 'coalesce' | 'like' | '!like';
 export interface BinaryExpr extends ExprWithKids {
     node: BinaryOperator;
@@ -118,9 +118,10 @@ export interface NowNode extends ExprLeaf {
     node: 'now';
 }
 interface HasTimeValue {
-    dataType: TemporalFieldType;
+    typeDef: TemporalTypeDef;
 }
 type TimeExpr = Expr & HasTimeValue;
+export declare function mkTemporal(e: Expr, timeType: TemporalTypeDef | TemporalFieldType): TimeExpr;
 export interface MeasureTimeExpr extends ExprWithKids {
     node: 'timeDiff';
     units: TimestampUnit;
@@ -148,15 +149,22 @@ export interface TimeExtractExpr extends ExprE {
     e: TimeExpr;
     units: ExtractUnit;
 }
-export interface TypecastExpr extends ExprE {
+export interface MalloyTypecastExpr extends ExprE {
     node: 'cast';
     safe: boolean;
     e: Expr;
-    dstType: CastType | {
-        raw: string;
-    };
-    srcType?: AtomicFieldType;
+    dstType: LeafAtomicTypeDef;
+    srcType?: LeafAtomicTypeDef;
+}
+interface RawTypeCastExpr extends ExprE {
+    node: 'cast';
+    safe: boolean;
+    e: Expr;
+    dstSQLType: string;
+    srcType?: LeafAtomicTypeDef;
 }
+export type TypecastExpr = MalloyTypecastExpr | RawTypeCastExpr;
+export declare function isRawCast(te: TypecastExpr): te is RawTypeCastExpr;
 export interface RegexMatchExpr extends ExprWithKids {
     node: 'regexpMatch';
     kids: {
@@ -167,7 +175,7 @@ export interface RegexMatchExpr extends ExprWithKids {
 export interface TimeLiteralNode extends ExprLeaf {
     node: 'timeLiteral';
     literal: string;
-    dataType: TemporalFieldType;
+    typeDef: TemporalTypeDef;
     timezone?: string;
 }
 export interface StringLiteralNode extends ExprLeaf {
@@ -194,7 +202,7 @@ export interface ArrayLiteralNode extends ExprWithKids {
     kids: {
         values: Expr[];
     };
-    dataType: AtomicFieldType;
+    typeDef: ArrayTypeDef;
 }
 export interface ErrorNode extends ExprLeaf {
     node: 'error';
@@ -531,6 +539,7 @@ export interface IndexSegment extends Filtered {
     limit?: number;
     weightMeasure?: string;
     sample?: Sampling;
+    alwaysJoins?: string[];
 }
 export declare function isIndexSegment(pe: PipeSegment): pe is IndexSegment;
 export interface QuerySegment extends Filtered {
@@ -541,6 +550,7 @@ export interface QuerySegment extends Filtered {
     by?: By;
     orderBy?: OrderBy[];
     queryTimezone?: string;
+    alwaysJoins?: string[];
 }
 export interface TurtleDef extends NamedObject, Pipeline {
     type: 'turtle';
@@ -658,7 +668,7 @@ export type LeafAtomicTypeDef = StringTypeDef | TemporalTypeDef | NumberTypeDef
 export type AtomicTypeDef = LeafAtomicTypeDef | ArrayTypeDef | RecordTypeDef;
 export type LeafAtomicDef = LeafAtomicTypeDef & FieldAtomicBase;
 export type AtomicFieldDef = AtomicTypeDef & FieldAtomicBase;
-export declare function isLeafAtomic(fd: FieldDef | QueryFieldDef): fd is LeafAtomicDef;
+export declare function isLeafAtomic(fd: FieldDef | QueryFieldDef | AtomicTypeDef): fd is LeafAtomicDef;
 export type FieldDef = AtomicFieldDef | JoinFieldDef | TurtleDef;
 export interface RefToField {
     type: 'fieldref';
@@ -779,4 +789,23 @@ export interface PrepareResultOptions {
     replaceMaterializedReferences?: boolean;
     materializedTablePrefix?: string;
 }
+type UTD = AtomicTypeDef | undefined;
+export declare const TD: {
+    isA: (td: UTD, ...tList: string[]) => boolean | undefined;
+    notA: (td: UTD, ...tList: string[]) => boolean | undefined;
+    isString: (td: UTD) => td is StringTypeDef;
+    isNumber: (td: UTD) => td is NumberTypeDef;
+    isBoolean: (td: UTD) => td is BooleanTypeDef;
+    isJSON: (td: UTD) => td is JSONTypeDef;
+    isSQL: (td: UTD) => td is NativeUnsupportedTypeDef;
+    isDate: (td: UTD) => td is DateTypeDef;
+    isTimestamp: (td: UTD) => td is TimestampTypeDef;
+    isError: (td: UTD) => td is ErrorTypeDef;
+    eq: (x: UTD, y: UTD) => boolean;
+    timestamp: () => TimestampTypeDef;
+    date: () => DateTypeDef;
+    string: () => StringTypeDef;
+    number: () => NumberTypeDef;
+    error: () => ErrorTypeDef;
+};
 export {};

package/dist/model/malloy_types.js

@@ -22,8 +22,8 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeEvalSpaces = exports.isLiteral = exports.isScalarArray = exports.isBaseTable = exports.isSourceDef = exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isRepeatedRecord = exports.arrayEachFields = exports.fieldIsIntrinsic = exports.isCastType = exports.isAtomicFieldType = exports.isTemporalField = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
-exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.getAtomicFields = exports.isAtomic = exports.isTurtleDef = exports.getIdentifier = exports.isLeafAtomic = void 0;
+exports.isScalarArray = exports.isBaseTable = exports.isSourceDef = exports.sourceBase = exports.isSegmentSQL = exports.isIndexSegment = exports.isRawSegment = exports.isSamplingEnable = exports.isSamplingPercent = exports.isSamplingRows = exports.isQuerySegment = exports.isProjectSegment = exports.isPartialSegment = exports.isReduceSegment = exports.structHasErrors = exports.segmentHasErrors = exports.refIsStructDef = exports.isByExpression = exports.isByName = exports.ValueType = exports.isExtractUnit = exports.isTimestampUnit = exports.isDateUnit = exports.isJoinedSource = exports.isJoined = exports.isJoinable = exports.isMatrixOperation = exports.isRepeatedRecord = exports.arrayEachFields = exports.fieldIsIntrinsic = exports.isCastType = exports.isAtomicFieldType = exports.isTemporalField = exports.hasExpression = exports.maxOfExpressionTypes = exports.maxExpressionType = exports.isExpressionTypeLEQ = exports.expressionIsAnalytic = exports.expressionIsCalculation = exports.expressionInvolvesAggregate = exports.expressionIsUngroupedAggregate = exports.expressionIsAggregate = exports.expressionIsScalar = exports.paramHasValue = exports.isRawCast = exports.mkTemporal = exports.isAsymmetricExpr = exports.exprIsLeaf = exports.exprHasE = exports.exprHasKids = void 0;
+exports.TD = exports.isValueDate = exports.isValueTimestamp = exports.isValueBoolean = exports.isValueNumber = exports.isValueString = exports.getAtomicFields = exports.isAtomic = exports.isTurtleDef = exports.getIdentifier = exports.isLeafAtomic = exports.mergeEvalSpaces = exports.isLiteral = void 0;
 function exprHasKids(e) {
     return 'kids' in e;
 }
@@ -41,6 +41,33 @@ function isAsymmetricExpr(f) {
         ['sum', 'avg', 'count', 'distinct'].includes(f.function));
 }
 exports.isAsymmetricExpr = isAsymmetricExpr;
+/**
+ * Return true if this node can be turned into a temporal node by simply
+ * appending a time type to the typedef. The type systsem makes this hard
+ * because while it is theoretically possible to pass an array typed Expr,
+ * the reality is that type checking will stop this from ever happening.
+ *
+ * The list here is the list of Expr types which have a fixed typeDef,
+ * which are not of time type.
+ *
+ * If !canMakeTemporal then mkTemporal is going to return something
+ * which will probably error at SQL generation time, so don't do that.
+ */
+function canMakeTemporal(e) {
+    return e.node !== 'arrayLiteral' && e.node !== 'recordLiteral';
+}
+function mkTemporal(e, timeType) {
+    const ttd = typeof timeType === 'string' ? { type: timeType } : timeType;
+    if (canMakeTemporal(e)) {
+        return { ...e, typeDef: { ...ttd } };
+    }
+    return e;
+}
+exports.mkTemporal = mkTemporal;
+function isRawCast(te) {
+    return 'dstSQLType' in te;
+}
+exports.isRawCast = isRawCast;
 function paramHasValue(p) {
     return p.value !== null;
 }
@@ -369,5 +396,59 @@ function isValueDate(value, field) {
     return field.type === 'date';
 }
 exports.isValueDate = isValueDate;
+exports.TD = {
+    isA: (td, ...tList) => td && tList.includes(td.type),
+    notA: (td, ...tList) => td && !tList.includes(td.type),
+    isString: (td) => td !== undefined && td.type === 'string',
+    isNumber: (td) => td !== undefined && td.type === 'number',
+    isBoolean: (td) => td !== undefined && td.type === 'boolean',
+    isJSON: (td) => td !== undefined && td.type === 'json',
+    isSQL: (td) => td !== undefined && td.type === 'sql native',
+    isDate: (td) => td !== undefined && td.type === 'date',
+    isTimestamp: (td) => td !== undefined && td.type === 'timestamp',
+    isError: (td) => td !== undefined && td.type === 'error',
+    eq: function (x, y) {
+        if (x === undefined || y === undefined) {
+            return false;
+        }
+        function checkFields(a, b) {
+            const aSchema = {};
+            for (const aEnt of a['fields'] || []) {
+                if (aEnt.name) {
+                    aSchema[aEnt.name] = aEnt;
+                }
+                else {
+                    return false;
+                }
+            }
+            for (const bEnt of b['fields'] || []) {
+                if (!exports.TD.eq(aSchema[bEnt.name], bEnt)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (x.type === 'array' && y.type === 'array') {
+            if (x.elementTypeDef.type !== y.elementTypeDef.type) {
+                return false;
+            }
+            if (x.elementTypeDef.type !== 'record_element' && // Both are equal, but to make this
+                y.elementTypeDef.type !== 'record_element' //    typecheck, we need the && clause.
+            ) {
+                return exports.TD.eq(x.elementTypeDef, y.elementTypeDef);
+            }
+            return checkFields(x, y);
+        }
+        else if (x.type === 'record' && y.type === 'record') {
+            return checkFields(x, y);
+        }
+        return x.type === y.type;
+    },
+    timestamp: () => ({ type: 'timestamp' }),
+    date: () => ({ type: 'date' }),
+    string: () => ({ type: 'string' }),
+    number: () => ({ type: 'number', numberType: 'float' }),
+    error: () => ({ type: 'error' }),
+};
 // clang-format on
 //# sourceMappingURL=malloy_types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.203-dev241021134413",
+  "version": "0.0.203-dev241022191525",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",