@malloydata/malloy 0.0.1 → 0.0.2

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

@@ -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");
                 }
@@ -1017,7 +1017,7 @@ class FieldName extends MalloyElement {
         return this.refString;
     }
     getField(fs) {
-        return fs.in.lookup([this]);
+        return fs.lookup([this]);
     }
 }
 exports.FieldName = FieldName;
@@ -1100,28 +1100,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 +1154,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 +1176,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 +1199,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 +1232,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 +1258,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 +1275,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 +1376,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 +1715,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 +1760,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 +1772,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 +1784,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

package/dist/lang/field-space.d.ts

@@ -20,7 +20,7 @@ export interface FieldSpace {
     structDef(): model.StructDef;
     emptyStructDef(): model.StructDef;
     lookup(symbol: FieldName[]): LookupResult;
-    getDialect(): Dialect;
+    dialectObj(): Dialect | undefined;
     whenComplete: (step: () => void) => void;
 }
 /**
@@ -32,7 +32,7 @@ export declare class StaticSpace implements FieldSpace {
     protected fromStruct: model.StructDef;
     constructor(sourceStructDef: model.StructDef);
     whenComplete(step: () => void): void;
-    getDialect(): Dialect;
+    dialectObj(): Dialect | undefined;
     fromFieldDef(from: model.FieldDef): SpaceField;
     private get map();
     protected dropEntries(): void;
@@ -85,50 +85,55 @@ export declare class DynamicSpace extends StaticSpace {
     addFieldDef(fd: model.FieldDef): void;
     structDef(): model.StructDef;
 }
-declare type QuerySegType = "reduce" | "project" | "index";
 /**
  * A namespace for Query operations. The have an input and an
- * output set of fields.
+ * output set of fields. The InputSpace is the QueryOperationSpace
+ * which is where all expressions are evaluated, and the output
+ * space is ResultSpace.
+ *
  */
-export declare abstract class QueryOperationSpace extends DynamicSpace {
-    abstract segType: QuerySegType;
-    astEl?: MalloyElement | undefined;
-    readonly queryInput: SourceSpace;
+export declare class QuerySpace extends DynamicSpace {
+    readonly result: ResultSpace;
     nestParent?: QuerySpace;
-    constructor(input: SourceSpec);
-    inputFS(): FieldSpace;
-    structDef(): model.StructDef;
-    abstract getPipeSegment(refineFrom: model.PipeSegment | undefined): model.PipeSegment;
+    extendList: string[];
+    constructor(input: SourceSpec, result: ResultSpace);
+    extendSource(extendField: Join | FieldDeclaration): void;
+}
+export declare abstract class ResultSpace extends DynamicSpace {
+    readonly queryInputSpace: FieldSpace;
+    readonly exprSpace: QuerySpace;
+    astEl?: MalloyElement | undefined;
+    abstract readonly segmentType: "reduce" | "project" | "index";
+    constructor(queryInputSpace: FieldSpace);
+    log(s: string): void;
     addMembers(members: FieldCollectionMember[]): void;
     addReference(ref: FieldReference): void;
     addWild(wild: WildcardFieldReference): void;
-    log(s: string): void;
-}
-/**
- * Reduce and project queries use a "QuerySpace"
- */
-export declare abstract class QuerySpace extends QueryOperationSpace {
-    extendedInput?: DynamicSpace;
-    extendedFields: string[];
-    extendSource(extendField: Join | FieldDeclaration): void;
-    inputFS(): FieldSpace;
-    qfs(): FSPair;
+    /**
+     * Check for the definition of an ungrouping reference in the result space,
+     * or in the case of an exclude reference, if this query is nested
+     * in another query, in the result space of a query that this query
+     * is nested inside of.
+     */
     checkUngroup(fn: FieldName, isExclude: boolean): void;
-    private extendInto;
-    getPipeSegment(refineFrom: model.QuerySegment | undefined): model.QuerySegment;
     addQueryItems(...qiList: QueryItem[]): void;
     canContain(_qd: model.QueryFieldDef): boolean;
     protected queryFieldDefs(): model.QueryFieldDef[];
+    getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
+    getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
 }
-export declare class ReduceFieldSpace extends QuerySpace {
-    segType: QuerySegType;
+/**
+ * Reduce and project queries use a "QuerySpace"
+ */
+export declare class ReduceFieldSpace extends ResultSpace {
+    readonly segmentType = "reduce";
 }
-export declare class ProjectFieldSpace extends QuerySpace {
-    segType: QuerySegType;
+export declare class ProjectFieldSpace extends ResultSpace {
+    readonly segmentType = "project";
     canContain(qd: model.QueryFieldDef): boolean;
 }
-export declare class IndexFieldSpace extends QueryOperationSpace {
-    segType: QuerySegType;
+export declare class IndexFieldSpace extends ResultSpace {
+    readonly segmentType = "index";
     fieldList: Set<string>;
     addReference(ref: FieldReference): void;
     addWild(wild: WildcardFieldReference): void;
@@ -146,12 +151,7 @@ export declare class DefSpace implements FieldSpace {
     structDef(): model.StructDef;
     emptyStructDef(): model.StructDef;
     lookup(symbol: FieldName[]): LookupResult;
-    getDialect(): Dialect;
+    dialectObj(): Dialect | undefined;
     whenComplete(step: () => void): void;
 }
-export interface FSPair {
-    in: FieldSpace;
-    out: FieldSpace;
-}
-export declare function fsPair(inFS: FieldSpace, outFS?: FieldSpace): FSPair;
 export {};