@malloydata/malloy 0.0.1 → 0.0.3

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

@@ -96,20 +96,10 @@ class ConstantFieldSpace {
         this.type = "fieldSpace";
     }
     structDef() {
-        return {
-            type: "struct",
-            name: "empty structdef",
-            structSource: { type: "table" },
-            structRelationship: {
-                type: "basetable",
-                connectionName: "noConnection",
-            },
-            fields: [],
-            dialect: "noDialect",
-        };
+        throw new Error("ConstantFieldSpace cannot generate a structDef");
     }
     emptyStructDef() {
-        return { ...this.structDef(), fields: [] };
+        throw new Error("ConstantFieldSpace cannot generate a structDef");
     }
     lookup(_name) {
         return {
@@ -117,11 +107,8 @@ class ConstantFieldSpace {
             found: undefined,
         };
     }
-    getDialect() {
-        // well dialects totally make this wrong and broken and stupid and useless
-        // but since this is only used for parameters which are also wrong and
-        // broken and stupid and useless, this will do for now
-        throw new Error("I just put this line of code here to make things compile");
+    dialectObj() {
+        return undefined;
     }
     whenComplete(step) {
         step();
@@ -140,10 +127,7 @@ class ConstantSubExpression extends ExpressionDef {
         if (!this.cfs) {
             this.cfs = new ConstantFieldSpace();
         }
-        return {
-            in: this.cfs,
-            out: this.cfs,
-        };
+        return this.cfs;
     }
     constantValue() {
         return this.expr.getExpression(this.constantFs);
@@ -179,11 +163,7 @@ class FieldDeclaration extends index_1.MalloyElement {
          * a refactor of QueryFieldSpace might someday be the place where this should
          * happen.
          */
-        const defPair = {
-            in: new field_space_1.DefSpace(fs, this),
-            out: fs,
-        };
-        return this.queryFieldDef(defPair, exprName);
+        return this.queryFieldDef(new field_space_1.DefSpace(fs, this), exprName);
     }
     queryFieldDef(exprFS, exprName) {
         let exprValue;
@@ -391,7 +371,7 @@ class ExprIdReference extends ExpressionDef {
         return this.fieldReference.refString;
     }
     getExpression(fs) {
-        const def = this.fieldReference.getField(fs.in);
+        const def = this.fieldReference.getField(fs);
         if (def.found) {
             // TODO if type is a query or a struct this should fail nicely
             const typeMixin = def.found.type();
@@ -404,7 +384,7 @@ class ExprIdReference extends ExpressionDef {
         return (0, index_1.errorFor)(def.error);
     }
     apply(fs, op, expr) {
-        const entry = this.fieldReference.getField(fs.in).found;
+        const entry = this.fieldReference.getField(fs).found;
         if (entry instanceof space_field_1.SpaceParam) {
             const cParam = entry.parameter();
             if ((0, malloy_types_1.isConditionParameter)(cParam)) {
@@ -548,7 +528,7 @@ class ExprAggregateFunction extends ExpressionDef {
         let exprVal = (_a = this.expr) === null || _a === void 0 ? void 0 : _a.getExpression(fs);
         let structPath = (_b = this.source) === null || _b === void 0 ? void 0 : _b.refString;
         if (this.source) {
-            const sourceFoot = this.source.getField(fs.in).found;
+            const sourceFoot = this.source.getField(fs).found;
             if (sourceFoot) {
                 const footType = sourceFoot.type();
                 if ((0, malloy_types_1.isAtomicFieldType)(footType.type)) {
@@ -705,19 +685,24 @@ class ExprUngroup extends ExpressionDef {
         }
         const ungroup = { type: this.control, e: exprVal.value };
         if (this.typeCheck(this.expr, { ...exprVal, aggregate: false })) {
-            const dstFields = [];
-            for (const mustBeInOutput of this.fields) {
-                const name = mustBeInOutput.refString;
+            if (this.fields.length > 0) {
+                let qs = fs;
+                if (fs instanceof field_space_1.DefSpace) {
+                    qs = fs.realFS;
+                }
+                if (!(qs instanceof field_space_1.QuerySpace)) {
+                    this.log(`${this.control}() must be in a query -- weird internal error`);
+                    return (0, index_1.errorFor)("ungroup query check");
+                }
+                const output = qs.result;
+                const dstFields = [];
                 const isExclude = this.control == "exclude";
-                const resultSpace = fs.out;
-                if (resultSpace instanceof field_space_1.QuerySpace) {
-                    resultSpace.whenComplete(() => {
-                        resultSpace.checkUngroup(mustBeInOutput, isExclude);
+                for (const mustBeInOutput of this.fields) {
+                    output.whenComplete(() => {
+                        output.checkUngroup(mustBeInOutput, isExclude);
                     });
-                    dstFields.push(name);
+                    dstFields.push(mustBeInOutput.refString);
                 }
-            }
-            if (dstFields.length > 0) {
                 ungroup.fields = dstFields;
             }
             return {

package/dist/lang/ast/ast-main.d.ts

@@ -1,5 +1,5 @@
 import * as model from "../../model/malloy_types";
-import { FieldSpace, FSPair, QuerySpace, LookupResult } from "../field-space";
+import { FieldSpace, QuerySpace, LookupResult } from "../field-space";
 import { MalloyTranslation } from "../parse-malloy";
 import { ConstantSubExpression, ExpressionDef, FieldDeclaration } from "./index";
 import { SQLBlockRequest } from "../../model/sql_block";
@@ -149,7 +149,7 @@ export declare class QuerySource extends Mallobj {
 export declare abstract class Join extends MalloyElement {
     abstract name: ModelEntryReference;
     abstract structDef(): model.StructDef;
-    abstract fixupJoinOn(outer: FSPair, inStruct: model.StructDef): void;
+    abstract fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): void;
 }
 export declare class KeyJoin extends Join {
     readonly name: ModelEntryReference;
@@ -158,7 +158,7 @@ export declare class KeyJoin extends Join {
     elementType: string;
     constructor(name: ModelEntryReference, source: Mallobj, keyExpr: ExpressionDef);
     structDef(): model.StructDef;
-    fixupJoinOn(outer: FSPair, inStruct: model.StructDef): void;
+    fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): void;
 }
 declare type ExpressionJoinType = "many" | "one" | "cross";
 export declare class ExpressionJoin extends Join {
@@ -170,7 +170,7 @@ export declare class ExpressionJoin extends Join {
     constructor(name: ModelEntryReference, source: Mallobj);
     set joinOn(joinExpr: ExpressionDef | undefined);
     get joinOn(): ExpressionDef | undefined;
-    fixupJoinOn(outer: FSPair, inStruct: model.StructDef): model.Expr | undefined;
+    fixupJoinOn(outer: FieldSpace, inStruct: model.StructDef): model.Expr | undefined;
     structDef(): model.StructDef;
 }
 export declare class Joins extends ListOf<Join> {
@@ -188,14 +188,14 @@ export declare class FilterElement extends MalloyElement {
     readonly exprSrc: string;
     elementType: string;
     constructor(expr: ExpressionDef, exprSrc: string);
-    filterExpression(fs: FSPair): model.FilterExpression;
+    filterExpression(fs: FieldSpace): model.FilterExpression;
 }
 export declare class Filter extends ListOf<FilterElement> {
     elementType: string;
     private havingClause?;
     constructor(elements?: FilterElement[]);
     set having(isHaving: boolean);
-    getFilterList(fs: FSPair): model.FilterExpression[];
+    getFilterList(fs: FieldSpace): model.FilterExpression[];
 }
 export declare class DeclareFields extends ListOf<FieldDeclaration> {
     constructor(fields: FieldDeclaration[], fieldType?: string);
@@ -215,7 +215,7 @@ export declare class FieldName extends MalloyElement {
     constructor(name: string);
     get refString(): string;
     toString(): string;
-    getField(fs: FSPair): LookupResult;
+    getField(fs: FieldSpace): LookupResult;
 }
 export declare class FieldReference extends ListOf<FieldName> {
     elementType: string;
@@ -303,15 +303,15 @@ export declare class WildcardFieldReference extends MalloyElement {
 }
 export declare class OrderBy extends MalloyElement {
     readonly field: number | FieldName;
-    readonly dir?: "asc" | "desc" | undefined;
+    readonly dir?: "desc" | "asc" | undefined;
     elementType: string;
-    constructor(field: number | FieldName, dir?: "asc" | "desc" | undefined);
+    constructor(field: number | FieldName, dir?: "desc" | "asc" | undefined);
     get modelField(): string | number;
-    getOrderBy(_fs: FSPair): model.OrderBy;
+    getOrderBy(_fs: FieldSpace): model.OrderBy;
 }
 export declare class Ordering extends ListOf<OrderBy> {
     constructor(list: OrderBy[]);
-    getOrderBy(fs: FSPair): model.OrderBy[];
+    getOrderBy(fs: FieldSpace): model.OrderBy[];
 }
 export declare class Limit extends MalloyElement {
     readonly limit: number;
@@ -376,8 +376,8 @@ export declare class FullQuery extends TurtleHeadedPipe {
 export declare class TurtleDecl extends TurtleHeadedPipe {
     readonly name: string;
     constructor(name: string);
-    getPipeline(fs: FSPair): model.Pipeline;
-    getFieldDef(inSpace: FieldSpace, nestParent: QuerySpace | undefined): model.TurtleDef;
+    getPipeline(fs: FieldSpace): model.Pipeline;
+    getFieldDef(fs: FieldSpace, nestParent: QuerySpace | undefined): model.TurtleDef;
 }
 export declare class NestReference extends FieldReference {
     readonly name: FieldName;
@@ -422,7 +422,7 @@ export declare class Top extends MalloyElement {
     readonly by?: TopInit | undefined;
     elementType: string;
     constructor(limit: number, by?: TopInit | undefined);
-    getBy(fs: FSPair): model.By | undefined;
+    getBy(fs: FieldSpace): model.By | undefined;
 }
 export declare class JSONElement extends MalloyElement {
     elementType: string;

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

@@ -55,7 +55,7 @@ const theErrorStruct = {
     type: "struct",
     name: "~malformed~",
     dialect: "~malformed~",
-    structSource: { type: "table" },
+    structSource: { type: "table", tablePath: "//undefined_error_table_path" },
     structRelationship: {
         type: "basetable",
         connectionName: "//undefined_error_connection",
@@ -512,7 +512,7 @@ class RefinedExplore extends Mallobj {
             fs.addParameters(pList);
         }
         if (primaryKey) {
-            const keyDef = primaryKey.field.getField({ in: fs, out: fs });
+            const keyDef = primaryKey.field.getField(fs);
             if (keyDef.error) {
                 primaryKey.log(keyDef.error);
             }
@@ -522,7 +522,7 @@ class RefinedExplore extends Mallobj {
         let moreFilters = false;
         for (const filter of filters) {
             for (const el of filter.list) {
-                const fc = el.filterExpression({ in: fs, out: fs });
+                const fc = el.filterExpression(fs);
                 if (fc.aggregate) {
                     el.log("Can't use aggregate computations in top level filters");
                 }
@@ -867,6 +867,7 @@ class ExpressionJoin extends Join {
         if (sourceDef.structSource.type === "query") {
             // the name from query does not need to be preserved
             joinStruct.name = this.name.refString;
+            delete joinStruct.as;
         }
         else {
             joinStruct.as = this.name.refString;
@@ -1017,7 +1018,7 @@ class FieldName extends MalloyElement {
         return this.refString;
     }
     getField(fs) {
-        return fs.in.lookup([this]);
+        return fs.lookup([this]);
     }
 }
 exports.FieldName = FieldName;
@@ -1100,28 +1101,25 @@ class Aggregate extends ListOf {
 }
 exports.Aggregate = Aggregate;
 class ReduceExecutor {
-    constructor(baseFS, out) {
+    constructor(baseFS) {
         this.filters = [];
-        this.inputFS = baseFS;
-        this.queryFS = out || new field_space_1.ReduceFieldSpace(baseFS);
+        this.resultFS = this.getResultSpace(baseFS);
+        this.inputFS = this.resultFS.exprSpace;
     }
-    get qfs() {
-        return {
-            in: this.queryFS.inputFS(),
-            out: this.queryFS,
-        };
+    getResultSpace(fs) {
+        return new field_space_1.ReduceFieldSpace(fs);
     }
     execute(qp) {
         if (qp instanceof GroupBy ||
             qp instanceof Aggregate ||
             qp instanceof Nests) {
-            this.queryFS.addQueryItems(...qp.list);
+            this.resultFS.addQueryItems(...qp.list);
         }
         else if (isNestedQuery(qp)) {
-            this.queryFS.addQueryItems(qp);
+            this.resultFS.addQueryItems(qp);
         }
         else if (qp instanceof Filter) {
-            this.filters.push(...qp.getFilterList(this.qfs));
+            this.filters.push(...qp.getFilterList(this.inputFS));
         }
         else if (qp instanceof Top) {
             if (this.limit) {
@@ -1157,7 +1155,7 @@ class ReduceExecutor {
         }
         else if (qp instanceof Joins || qp instanceof DeclareFields) {
             for (const qel of qp.list) {
-                this.queryFS.extendSource(qel);
+                this.inputFS.extendSource(qel);
             }
         }
     }
@@ -1179,13 +1177,13 @@ class ReduceExecutor {
             to.limit = this.limit;
         }
         if (this.order instanceof Top) {
-            const topBy = this.order.getBy(this.qfs);
+            const topBy = this.order.getBy(this.inputFS);
             if (topBy) {
                 to.by = topBy;
             }
         }
         if (this.order instanceof Ordering) {
-            to.orderBy = this.order.getOrderBy(this.qfs);
+            to.orderBy = this.order.getOrderBy(this.inputFS);
         }
         const oldFilters = (from === null || from === void 0 ? void 0 : from.filterList) || [];
         if (this.filters.length > 0 && !oldFilters) {
@@ -1202,22 +1200,22 @@ class ReduceExecutor {
                 from = fromSeg;
             }
             else {
-                this.queryFS.log(`Can't refine reduce with ${fromSeg.type}`);
+                this.inputFS.result.log(`Can't refine reduce with ${fromSeg.type}`);
                 return ErrorFactory.reduceSegment;
             }
         }
-        const reduceSegment = this.queryFS.getPipeSegment(from);
+        const reduceSegment = this.resultFS.getQuerySegment(from);
         this.refineFrom(from, reduceSegment);
         return reduceSegment;
     }
 }
 class ProjectExecutor extends ReduceExecutor {
-    constructor(baseFS) {
-        super(baseFS, new field_space_1.ProjectFieldSpace(baseFS));
+    getResultSpace(fs) {
+        return new field_space_1.ProjectFieldSpace(fs);
     }
     execute(qp) {
         if (qp instanceof ProjectStatement) {
-            this.queryFS.addMembers(qp.list);
+            this.resultFS.addMembers(qp.list);
         }
         else if ((qp instanceof Filter && qp.elementType === "having") ||
             qp instanceof Measures ||
@@ -1235,30 +1233,24 @@ class ProjectExecutor extends ReduceExecutor {
                 from = fromSeg;
             }
             else {
-                this.queryFS.log(`Can't refine project with ${fromSeg.type}`);
+                this.resultFS.log(`Can't refine project with ${fromSeg.type}`);
                 return ErrorFactory.projectSegment;
             }
         }
-        const projectSegment = this.queryFS.getPipeSegment(from);
+        const projectSegment = this.resultFS.getQuerySegment(from);
         this.refineFrom(from, projectSegment);
         return projectSegment;
     }
 }
 class IndexExecutor {
-    constructor(baseFS) {
+    constructor(inputFS) {
         this.filters = [];
-        this.inputFS = baseFS;
-        this.queryFS = new field_space_1.IndexFieldSpace(baseFS);
-    }
-    get qfs() {
-        return {
-            in: this.queryFS.inputFS(),
-            out: this.queryFS,
-        };
+        this.resultFS = new field_space_1.IndexFieldSpace(inputFS);
+        this.inputFS = this.resultFS.exprSpace;
     }
     execute(qp) {
         if (qp instanceof Filter) {
-            this.filters.push(...qp.getFilterList(this.qfs));
+            this.filters.push(...qp.getFilterList(this.inputFS));
         }
         else if (qp instanceof Limit) {
             if (this.limit) {
@@ -1267,7 +1259,7 @@ class IndexExecutor {
             this.limit = qp;
         }
         else if (qp instanceof Index) {
-            this.queryFS.addMembers(qp.fields.list);
+            this.resultFS.addMembers(qp.fields.list);
             if (qp.weightBy) {
                 if (this.indexOn) {
                     this.indexOn.log("Ignoring previous BY");
@@ -1284,10 +1276,10 @@ class IndexExecutor {
     }
     finalize(from) {
         if (from && from.type !== "index") {
-            this.queryFS.log(`Can't refine index with ${from.type}`);
+            this.resultFS.log(`Can't refine index with ${from.type}`);
             return ErrorFactory.indexSegment;
         }
-        const indexSegment = this.queryFS.getPipeSegment(from);
+        const indexSegment = this.resultFS.getPipeSegment(from);
         const oldFilters = (from === null || from === void 0 ? void 0 : from.filterList) || [];
         if (this.filters.length > 0 && !oldFilters) {
             indexSegment.filterList = this.filters;
@@ -1385,9 +1377,9 @@ class QOPDesc extends ListOf {
     getOp(inputFS, forPipeline) {
         const qex = this.getExecutor(inputFS);
         if (forPipeline === null || forPipeline === void 0 ? void 0 : forPipeline.nestedInQuerySpace) {
-            qex.queryFS.nestParent = forPipeline.nestedInQuerySpace;
+            qex.inputFS.nestParent = forPipeline.nestedInQuerySpace;
         }
-        qex.queryFS.astEl = this;
+        qex.resultFS.astEl = this;
         for (const qp of this.list) {
             qex.execute(qp);
         }
@@ -1724,7 +1716,7 @@ class FullQuery extends TurtleHeadedPipe {
             };
         }
         if (this.turtleName) {
-            const { error } = this.turtleName.getField((0, field_space_1.fsPair)(pipeFs));
+            const { error } = this.turtleName.getField(pipeFs);
             if (error)
                 this.log(error);
             const name = this.turtleName.refString;
@@ -1769,7 +1761,7 @@ class TurtleDecl extends TurtleHeadedPipe {
             else if (headEnt.found instanceof space_field_1.QueryField) {
                 const headDef = headEnt.found.getQueryFieldDef(fs);
                 if (isTurtle(headDef)) {
-                    const newPipe = this.refinePipeline(fs.in, headDef);
+                    const newPipe = this.refinePipeline(fs, headDef);
                     modelPipe.pipeline = [...newPipe.pipeline];
                     reportWrongType = false;
                 }
@@ -1781,7 +1773,7 @@ class TurtleDecl extends TurtleHeadedPipe {
         else if (this.headRefinement) {
             throw this.internalError("Can't refine the head of a turtle in its definition");
         }
-        let appendInput = fs.in;
+        let appendInput = fs;
         if (modelPipe.pipeline.length > 0) {
             let endStruct = appendInput.structDef();
             for (const existingSeg of modelPipe.pipeline) {
@@ -1793,8 +1785,7 @@ class TurtleDecl extends TurtleHeadedPipe {
         modelPipe.pipeline = appended.opList;
         return modelPipe;
     }
-    getFieldDef(inSpace, nestParent) {
-        const fs = (0, field_space_1.fsPair)(inSpace);
+    getFieldDef(fs, nestParent) {
         if (nestParent) {
             this.nestedInQuerySpace = nestParent;
         }

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

@@ -1,5 +1,5 @@
 import { TimestampUnit, ExtractUnit, TimeFieldType } from "../../model/malloy_types";
-import { FSPair } from "../field-space";
+import { FieldSpace } from "../field-space";
 import { ExpressionDef, BinaryBoolean, ExprValue, MalloyElement, Comparison } from "./index";
 export declare class Timeframe extends MalloyElement {
     elementType: string;
@@ -21,10 +21,10 @@ export declare class ExprGranularTime extends ExpressionDef {
     legalChildTypes: import("./ast-types").FragType[];
     constructor(expr: ExpressionDef, units: TimestampUnit, truncate: boolean);
     granular(): boolean;
-    getExpression(fs: FSPair): ExprValue;
-    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
-    protected timestampRange(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    protected dateRange(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    protected timestampRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    protected dateRange(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
 }
 /**
  * GranularTime made from a literal. Funky because it doesn't know if it
@@ -39,12 +39,12 @@ export declare class GranularLiteral extends ExpressionDef {
     constructor(moment: string, until: string, units: TimestampUnit);
     granular(): boolean;
     static parse(possibleLiteral: string): GranularLiteral | undefined;
-    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
-    getExpression(fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprNow extends ExpressionDef {
     elementType: string;
-    getExpression(_fs: FSPair): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprDuration extends ExpressionDef {
     readonly n: ExpressionDef;
@@ -52,13 +52,13 @@ export declare class ExprDuration extends ExpressionDef {
     elementType: string;
     legalChildTypes: import("./ast-types").FragType[];
     constructor(n: ExpressionDef, timeframe: TimestampUnit);
-    apply(fs: FSPair, op: string, left: ExpressionDef): ExprValue;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, left: ExpressionDef): ExprValue;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprCompare extends BinaryBoolean<Comparison> {
     elementType: string;
     constructor(left: ExpressionDef, op: Comparison, right: ExpressionDef);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class Apply extends ExprCompare {
     readonly left: ExpressionDef;
@@ -72,9 +72,9 @@ export declare class PartialCompare extends ExpressionDef {
     elementType: string;
     constructor(op: Comparison, right: ExpressionDef);
     granular(): boolean;
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FSPair): ExprValue | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 /**
  * TODO: This is sort of a hand clone of the "Range" class, they should
@@ -87,9 +87,9 @@ export declare class ForRange extends ExpressionDef {
     elementType: string;
     legalChildTypes: import("./ast-types").FragType[];
     constructor(from: ExpressionDef, duration: ExpressionDef, timeframe: Timeframe);
-    apply(fs: FSPair, op: string, expr: ExpressionDef): ExprValue;
-    requestExpression(_fs: FSPair): ExprValue | undefined;
-    getExpression(_fs: FSPair): ExprValue;
+    apply(fs: FieldSpace, op: string, expr: ExpressionDef): ExprValue;
+    requestExpression(_fs: FieldSpace): ExprValue | undefined;
+    getExpression(_fs: FieldSpace): ExprValue;
 }
 export declare class ExprTimeExtract extends ExpressionDef {
     readonly extractText: string;
@@ -98,12 +98,12 @@ export declare class ExprTimeExtract extends ExpressionDef {
     static pluralMap: Record<string, ExtractUnit>;
     static extractor(funcName: string): ExtractUnit | undefined;
     constructor(extractText: string, args: ExpressionDef[]);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }
 export declare class ExprFunc extends ExpressionDef {
     readonly name: string;
     readonly args: ExpressionDef[];
     elementType: string;
     constructor(name: string, args: ExpressionDef[]);
-    getExpression(fs: FSPair): ExprValue;
+    getExpression(fs: FieldSpace): ExprValue;
 }

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

@@ -197,18 +197,17 @@ class GranularLiteral extends index_1.ExpressionDef {
             if (lhs.dataType === "date" && !this.timeType) {
                 rangeType = "date";
             }
-            const dialect = fs.in.getDialect();
-            const range = new index_1.Range(new index_1.ExprTime(rangeType, dialect.sqlLiteralTime(this.moment, rangeType, "UTC")), new index_1.ExprTime(rangeType, dialect.sqlLiteralTime(this.until, rangeType, "UTC")));
+            const range = new index_1.Range(new index_1.ExprTime(rangeType, (0, index_1.timeLiteral)(this.moment, rangeType, "UTC")), new index_1.ExprTime(rangeType, (0, index_1.timeLiteral)(this.until, rangeType, "UTC")));
             return range.apply(fs, op, left);
         }
         return super.apply(fs, op, left);
     }
-    getExpression(fs) {
+    getExpression(_fs) {
         const dataType = this.timeType || "date";
         const value = {
             dataType,
             aggregate: false,
-            value: [fs.in.getDialect().sqlLiteralTime(this.moment, dataType, "UTC")],
+            value: (0, index_1.timeLiteral)(this.moment, dataType, "UTC"),
         };
         // Literals with date resolution can be used as timestamps or dates,
         // this is the third attempt to make that work. It still feels like
@@ -519,7 +518,7 @@ class ExprFunc extends index_1.ExpressionDef {
         this.elementType = "function call()";
     }
     getExpression(fs) {
-        var _a, _b;
+        var _a, _b, _c;
         let anyAggregate = false;
         let collectType;
         const funcCall = [`${this.name}(`];
@@ -537,8 +536,8 @@ class ExprFunc extends index_1.ExpressionDef {
             funcCall.push(...expr.value);
         }
         funcCall.push(")");
-        const funcInfo = fs.in.getDialect().getFunctionInfo(this.name);
-        const dataType = (_b = (_a = funcInfo === null || funcInfo === void 0 ? void 0 : funcInfo.returnType) !== null && _a !== void 0 ? _a : collectType) !== null && _b !== void 0 ? _b : "number";
+        const dialect = fs.dialectObj();
+        const dataType = (_c = (_b = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.getFunctionInfo(this.name)) === null || _a === void 0 ? void 0 : _a.returnType) !== null && _b !== void 0 ? _b : collectType) !== null && _c !== void 0 ? _c : "number";
         return {
             dataType: dataType,
             aggregate: anyAggregate,

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

@@ -6,3 +6,4 @@ 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;
 export declare function timeResult(t: TimeResult, tt: TimestampUnit | undefined): TimeResult | GranularResult;
+export declare function timeLiteral(literalStr: string, timeType: TimeFieldType, tz: string): Expr;

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

@@ -12,7 +12,7 @@
  * GNU General Public License for more details.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
+exports.timeLiteral = exports.timeResult = exports.resolution = exports.castDateToTimestamp = exports.castTimestampToDate = exports.castTo = exports.timeOffset = void 0;
 function timeOffset(timeType, from, op, n, timeframe) {
     return [
         {
@@ -80,4 +80,15 @@ function timeResult(t, tt) {
     return t;
 }
 exports.timeResult = timeResult;
+function timeLiteral(literalStr, timeType, tz) {
+    const fragment = {
+        type: "dialect",
+        function: "timeLiteral",
+        literal: literalStr,
+        literalType: timeType,
+        timezone: tz,
+    };
+    return [fragment];
+}
+exports.timeLiteral = timeLiteral;
 //# sourceMappingURL=time-utils.js.map