@malloydata/malloy 0.0.1 → 0.0.3

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;
@@ -48,10 +48,10 @@ export declare type SourceSpec = model.StructDef | FieldSpace;
 /**
  * Based on how things are constructed, the starting field space
  * can either be another field space or an existing structdef.
- * Using a SourceSpace allows a class to accept either one
+ * Using a SpaceSeed allows a class to accept either one
  * and use either version at some future time.
  */
-declare class SourceSpace {
+declare class SpaceSeed {
     readonly sourceSpec: SourceSpec;
     private spaceSpec;
     private asFS?;
@@ -65,7 +65,7 @@ declare class SourceSpace {
  */
 export declare class DynamicSpace extends StaticSpace {
     protected final: model.StructDef | undefined;
-    protected source: SourceSpace;
+    protected source: SpaceSeed;
     outputFS?: QuerySpace;
     completions: (() => void)[];
     private complete;
@@ -85,50 +85,57 @@ 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.
+ * Unlike a source, which is a refinement of a namespace, a query
+ * is creating a new unrelated namespace. The query starts with a
+ * source, which it might modify. This set of fields used to resolve
+ * expressions in the query is called the "input space". There is a
+ * specialized QuerySpace for each type of query operation.
+ *
+ * The query output is managed by an instance of 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 +153,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 {};

package/dist/lang/field-space.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fsPair = exports.DefSpace = exports.IndexFieldSpace = exports.ProjectFieldSpace = exports.ReduceFieldSpace = exports.QuerySpace = exports.QueryOperationSpace = exports.DynamicSpace = exports.StaticSpace = void 0;
+exports.DefSpace = exports.IndexFieldSpace = exports.ProjectFieldSpace = exports.ReduceFieldSpace = exports.ResultSpace = exports.QuerySpace = exports.DynamicSpace = exports.StaticSpace = void 0;
 /* eslint-disable no-useless-constructor */
 const lodash_1 = require("lodash");
 const dialect_1 = require("../dialect");
@@ -54,8 +54,13 @@ class StaticSpace {
     whenComplete(step) {
         step();
     }
-    getDialect() {
-        return (0, dialect_1.getDialect)(this.fromStruct.dialect);
+    dialectObj() {
+        try {
+            return (0, dialect_1.getDialect)(this.fromStruct.dialect);
+        }
+        catch {
+            return undefined;
+        }
     }
     fromFieldDef(from) {
         if (from.type === "struct") {
@@ -116,6 +121,8 @@ class StaticSpace {
         }
         if (found instanceof space_field_1.SpaceField) {
             /*
+             * TODO cache defs, post the addReference call to whenComplete
+             *
              * In the cleanup phase of query space construction, it may check
              * the output space for ungrouping variables. However if an
              * ungrouping variable is a measure, the field expression value
@@ -129,18 +136,7 @@ class StaticSpace {
              * ... or this check would look at the finalized output of
              * the namespace and not re-compile ...
              */
-            let definition = undefined;
-            if (this instanceof QuerySpace) {
-                const qfd = found.getQueryFieldDef(this.qfs());
-                if (qfd &&
-                    typeof qfd != "string" &&
-                    !model.isFilteredAliasedName(qfd)) {
-                    definition = qfd;
-                }
-            }
-            else {
-                definition = found.fieldDef();
-            }
+            const definition = found.fieldDef();
             if (definition) {
                 head.addReference({
                     type: found instanceof space_field_1.StructSpaceField
@@ -171,10 +167,10 @@ function isFieldSpace(x) {
 /**
  * Based on how things are constructed, the starting field space
  * can either be another field space or an existing structdef.
- * Using a SourceSpace allows a class to accept either one
+ * Using a SpaceSeed allows a class to accept either one
  * and use either version at some future time.
  */
-class SourceSpace {
+class SpaceSeed {
     constructor(sourceSpec) {
         this.sourceSpec = sourceSpec;
         this.spaceSpec = sourceSpec;
@@ -203,7 +199,7 @@ class SourceSpace {
  */
 class DynamicSpace extends StaticSpace {
     constructor(extending) {
-        const source = new SourceSpace(extending);
+        const source = new SpaceSeed(extending);
         super((0, lodash_1.cloneDeep)(source.structDef));
         this.completions = [];
         this.complete = false;
@@ -285,7 +281,7 @@ class DynamicSpace extends StaticSpace {
                     def.log("Can't rename field to itself");
                     continue;
                 }
-                const oldValue = def.oldName.getField(fsPair(this));
+                const oldValue = def.oldName.getField(this);
                 if (oldValue.found) {
                     if (oldValue.found instanceof space_field_1.SpaceField) {
                         this.setEntry(def.newName, new space_field_1.RenameSpaceField(oldValue.found, def.newName, def.location));
@@ -360,7 +356,7 @@ class DynamicSpace extends StaticSpace {
             }
             // If we have join expressions, we need to now go back and fill them in
             for (const [join, missingOn] of fixupJoins) {
-                join.fixupJoinOn(fsPair(this), missingOn);
+                join.fixupJoinOn(this, missingOn);
             }
         }
         this.isComplete();
@@ -369,26 +365,42 @@ class DynamicSpace extends StaticSpace {
 }
 exports.DynamicSpace = DynamicSpace;
 /**
- * A namespace for Query operations. The have an input and an
- * output set of fields.
+ * Unlike a source, which is a refinement of a namespace, a query
+ * is creating a new unrelated namespace. The query starts with a
+ * source, which it might modify. This set of fields used to resolve
+ * expressions in the query is called the "input space". There is a
+ * specialized QuerySpace for each type of query operation.
+ *
+ * The query output is managed by an instance of ResultSpace.
  */
-class QueryOperationSpace extends DynamicSpace {
-    constructor(input) {
-        const inputSpace = new SourceSpace(input);
-        super({ ...inputSpace.structDef, fields: [] });
-        this.queryInput = inputSpace;
+class QuerySpace extends DynamicSpace {
+    constructor(input, result) {
+        const inputSpace = new SpaceSeed(input);
+        super(inputSpace.structDef);
+        this.result = result;
+        this.extendList = [];
     }
-    inputFS() {
-        return this.queryInput.fieldSpace;
+    extendSource(extendField) {
+        this.addField(extendField);
+        if (extendField instanceof ast_1.Join) {
+            this.extendList.push(extendField.name.refString);
+        }
+        else {
+            this.extendList.push(extendField.defineName);
+        }
     }
-    structDef() {
-        // Actually since we have the input structdef and the fields, this feels
-        // like it could return the output structdef of the query op ... except
-        // the pipeline code merges refinements in before asking for the output
-        // struct, and that would require a call back here somehow to get the
-        // pre-refinement fields ... I think possibly this is always a
-        // runtime error
-        throw new Error("StructDef requested from QueryOperationSpace");
+}
+exports.QuerySpace = QuerySpace;
+class ResultSpace extends DynamicSpace {
+    constructor(queryInputSpace) {
+        super(queryInputSpace.emptyStructDef());
+        this.queryInputSpace = queryInputSpace;
+        this.exprSpace = new QuerySpace(queryInputSpace, this);
+    }
+    log(s) {
+        if (this.astEl) {
+            this.astEl.log(s);
+        }
     }
     addMembers(members) {
         for (const member of members) {
@@ -415,45 +427,18 @@ class QueryOperationSpace extends DynamicSpace {
     addWild(wild) {
         this.setEntry(wild.refString, new space_field_1.WildSpaceField(wild.refString));
     }
-    log(s) {
-        if (this.astEl) {
-            this.astEl.log(s);
-        }
-    }
-}
-exports.QueryOperationSpace = QueryOperationSpace;
-/**
- * Reduce and project queries use a "QuerySpace"
- */
-class QuerySpace extends QueryOperationSpace {
-    constructor() {
-        super(...arguments);
-        this.extendedFields = [];
-    }
-    extendSource(extendField) {
-        this.extendedFields.push(extendField instanceof ast_1.Join
-            ? extendField.name.refString
-            : extendField.defineName);
-        this.extendInto().addField(extendField);
-    }
-    inputFS() {
-        if (this.extendedInput) {
-            return this.extendedInput;
-        }
-        return this.queryInput.fieldSpace;
-    }
-    qfs() {
-        return {
-            in: this.inputFS(),
-            out: this,
-        };
-    }
+    /**
+     * 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, isExclude) {
-        if (this.lookup([fn]).error) {
-            if (isExclude && this.nestParent) {
-                const parent = this.nestParent;
+        if (!this.entry(fn.refString)) {
+            if (isExclude && this.exprSpace.nestParent) {
+                const parent = this.exprSpace.nestParent;
                 parent.whenComplete(() => {
-                    parent.checkUngroup(fn, isExclude);
+                    parent.result.checkUngroup(fn, isExclude);
                 });
             }
             else {
@@ -462,46 +447,6 @@ class QuerySpace extends QueryOperationSpace {
             }
         }
     }
-    extendInto() {
-        if (!this.extendedInput) {
-            this.extendedInput = new DynamicSpace(this.queryInput.sourceSpec);
-        }
-        return this.extendedInput;
-    }
-    getPipeSegment(refineFrom) {
-        const reduceOrProject = this.segType;
-        if (reduceOrProject === "index") {
-            throw new Error("IndexSegment getPipeSegment should not call super");
-        }
-        if (refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.extendSource) {
-            for (const xField of refineFrom.extendSource) {
-                this.extendInto().addFieldDef(xField);
-            }
-        }
-        const segment = {
-            type: reduceOrProject,
-            fields: this.queryFieldDefs(),
-        };
-        segment.fields = (0, field_utils_1.mergeFields)(refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.fields, segment.fields);
-        if (refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.extendSource) {
-            segment.extendSource = refineFrom.extendSource;
-        }
-        if (this.extendedInput) {
-            const newExtends = [];
-            // have to get the whole structdef because we need all the join
-            // resolution to happen and that only happens at the completion
-            // of the structdef generation.
-            const extendedStruct = this.extendedInput.structDef();
-            for (const extendName of this.extendedFields) {
-                const extendEnt = extendedStruct.fields.find((f) => (0, field_utils_1.nameOf)(f) == extendName);
-                if (extendEnt) {
-                    newExtends.push(extendEnt);
-                }
-            }
-            segment.extendSource = (0, field_utils_1.mergeFields)(segment.extendSource, newExtends);
-        }
-        return segment;
-    }
     addQueryItems(...qiList) {
         for (const qi of qiList) {
             if (qi instanceof ast_1.FieldReference || qi instanceof ast_1.NestReference) {
@@ -511,8 +456,8 @@ class QuerySpace extends QueryOperationSpace {
                 this.addField(qi);
             }
             else if ((0, ast_1.isNestedQuery)(qi)) {
-                const qf = new space_field_1.QueryFieldAST(this.inputFS(), qi, qi.name);
-                qf.nestParent = this;
+                const qf = new space_field_1.QueryFieldAST(this, qi, qi.name);
+                qf.nestParent = this.exprSpace;
                 this.setEntry(qi.name, qf);
             }
             else {
@@ -528,13 +473,13 @@ class QuerySpace extends QueryOperationSpace {
         const fields = [];
         for (const [name, field] of this.entries()) {
             if (field instanceof space_field_1.SpaceField) {
-                const fieldQueryDef = field.getQueryFieldDef(this.qfs());
+                const fieldQueryDef = field.getQueryFieldDef(this.exprSpace);
                 if (fieldQueryDef) {
                     if (this.canContain(fieldQueryDef)) {
                         fields.push(fieldQueryDef);
                     }
                     else {
-                        this.log(`'${name}' not legal in ${this.segType}`);
+                        this.log(`'${name}' not legal in ${this.segmentType}`);
                     }
                 }
                 else {
@@ -545,19 +490,61 @@ class QuerySpace extends QueryOperationSpace {
         this.isComplete();
         return fields;
     }
+    getQuerySegment(rf) {
+        const p = this.getPipeSegment(rf);
+        if (model.isQuerySegment(p)) {
+            return p;
+        }
+        throw new Error("TODO NOT POSSIBLE");
+    }
+    getPipeSegment(refineFrom) {
+        if (this.segmentType == "index") {
+            // TODO ... should make this go away
+            throw new Error("INDEX FIELD PIPE SEGMENT MIS HANDLED");
+        }
+        if (refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.extendSource) {
+            for (const xField of refineFrom.extendSource) {
+                this.exprSpace.addFieldDef(xField);
+            }
+        }
+        const segment = {
+            type: this.segmentType,
+            fields: this.queryFieldDefs(),
+        };
+        segment.fields = (0, field_utils_1.mergeFields)(refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.fields, segment.fields);
+        if (refineFrom === null || refineFrom === void 0 ? void 0 : refineFrom.extendSource) {
+            segment.extendSource = refineFrom.extendSource;
+        }
+        if (this.exprSpace.extendList.length > 0) {
+            const newExtends = [];
+            const extendedStruct = this.exprSpace.structDef();
+            for (const extendName of this.exprSpace.extendList) {
+                const extendEnt = extendedStruct.fields.find((f) => (0, field_utils_1.nameOf)(f) == extendName);
+                if (extendEnt) {
+                    newExtends.push(extendEnt);
+                }
+            }
+            segment.extendSource = (0, field_utils_1.mergeFields)(segment.extendSource, newExtends);
+        }
+        this.isComplete();
+        return segment;
+    }
 }
-exports.QuerySpace = QuerySpace;
-class ReduceFieldSpace extends QuerySpace {
+exports.ResultSpace = ResultSpace;
+/**
+ * Reduce and project queries use a "QuerySpace"
+ */
+class ReduceFieldSpace extends ResultSpace {
     constructor() {
         super(...arguments);
-        this.segType = "reduce";
+        this.segmentType = "reduce";
     }
 }
 exports.ReduceFieldSpace = ReduceFieldSpace;
-class ProjectFieldSpace extends QuerySpace {
+class ProjectFieldSpace extends ResultSpace {
     constructor() {
         super(...arguments);
-        this.segType = "project";
+        this.segmentType = "project";
     }
     canContain(qd) {
         if (typeof qd !== "string") {
@@ -577,14 +564,14 @@ class ProjectFieldSpace extends QuerySpace {
     }
 }
 exports.ProjectFieldSpace = ProjectFieldSpace;
-class IndexFieldSpace extends QueryOperationSpace {
+class IndexFieldSpace extends ResultSpace {
     constructor() {
         super(...arguments);
-        this.segType = "index";
+        this.segmentType = "index";
         this.fieldList = new Set();
     }
     addReference(ref) {
-        if (ref.getField(this.inputFS()).found) {
+        if (ref.getField(this.exprSpace).found) {
             this.fieldList.add(ref.refString);
         }
     }
@@ -633,19 +620,12 @@ class DefSpace {
         }
         return this.realFS.lookup(symbol);
     }
-    getDialect() {
-        return this.realFS.getDialect();
+    dialectObj() {
+        return this.realFS.dialectObj();
     }
     whenComplete(step) {
         this.realFS.whenComplete(step);
     }
 }
 exports.DefSpace = DefSpace;
-function fsPair(inFS, outFS) {
-    return {
-        in: inFS,
-        out: outFS || inFS,
-    };
-}
-exports.fsPair = fsPair;
 //# sourceMappingURL=field-space.js.map