@malloydata/malloy 0.0.22-dev230119001546 → 0.0.22-dev230119193053

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

@@ -24,7 +24,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TurtleHeadedPipe = exports.ExistingQuery = exports.Index = exports.Turtles = exports.Limit = exports.Ordering = exports.OrderBy = exports.WildcardFieldReference = exports.RenameField = exports.PrimaryKey = exports.Document = exports.QOPDesc = exports.Aggregate = exports.GroupBy = exports.FieldListEdit = exports.ProjectStatement = exports.isFieldCollectionMember = exports.FieldReferences = exports.FieldReference = exports.FieldName = exports.Renames = exports.Dimensions = exports.Measures = exports.DeclareFields = exports.Filter = exports.FilterElement = exports.ExploreDesc = exports.isExploreProperty = exports.isQueryProperty = exports.Joins = exports.ExpressionJoin = exports.KeyJoin = exports.Join = exports.QuerySource = exports.SQLSource = exports.NamedSource = exports.ModelEntryReference = exports.IsValueBlock = exports.TableSource = exports.RefinedExplore = exports.DefineSourceList = exports.DefineExplore = exports.isDocStatement = exports.RunList = exports.Mallobj = exports.isExploreField = exports.Unimplemented = exports.ListOf = exports.MalloyElement = exports.ErrorFactory = void 0;
-exports.Range = exports.ExprTime = exports.ExprDuration = exports.TypeMistmatch = exports.ExprGranularTime = exports.ExprCompare = exports.BinaryBoolean = exports.applyBinary = exports.FieldDeclaration = exports.ConstantSubExpression = exports.ExpressionDef = exports.SampleProperty = exports.SQLStatement = exports.SQLString = exports.ConstantParameter = exports.HasParameter = exports.ImportStatement = exports.JSONStructDef = exports.JSONElement = exports.Top = exports.AnonymousQuery = exports.DefineQuery = exports.DefineQueryList = exports.isQueryElement = exports.Nests = exports.isNestedQuery = exports.NestDefinition = exports.NestRefinement = exports.NestReference = exports.TurtleDecl = exports.FullQuery = void 0;
+exports.RenameSpaceField = exports.QueryFieldAST = exports.ExpressionFieldFromAst = exports.AbstractParameter = exports.SpaceSeed = exports.DefinedParameter = exports.SpaceParam = exports.ColumnSpaceField = exports.QueryFieldStruct = exports.QueryField = exports.StructSpaceField = exports.SpaceField = exports.SpaceEntry = exports.ProjectFieldSpace = exports.ReduceFieldSpace = exports.ResultSpace = exports.DynamicSpace = exports.StaticSpace = exports.DefSpace = exports.Range = exports.ExprTime = exports.ExprDuration = exports.TypeMistmatch = exports.ExprGranularTime = exports.ExprCompare = exports.BinaryBoolean = exports.applyBinary = exports.FieldDeclaration = exports.ConstantSubExpression = exports.ExpressionDef = exports.SampleProperty = exports.SQLStatement = exports.SQLString = exports.ConstantParameter = exports.HasParameter = exports.ImportStatement = exports.JSONStructDef = exports.JSONElement = exports.Top = exports.AnonymousQuery = exports.DefineQuery = exports.DefineQueryList = exports.isQueryElement = exports.Nests = exports.isNestedQuery = exports.NestDefinition = exports.NestRefinement = exports.NestReference = exports.TurtleDecl = exports.FullQuery = void 0;
+exports.IndexFieldSpace = exports.WildSpaceField = exports.ReferenceField = exports.QuerySpace = exports.JoinSpaceField = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -49,15 +50,15 @@ exports.Range = exports.ExprTime = exports.ExprDuration = exports.TypeMistmatch
  */
 const lodash_1 = require("lodash");
 const model = __importStar(require("../../model/malloy_types"));
+const dialect_map_1 = require("../../dialect/dialect_map");
 const malloy_types_1 = require("../../model/malloy_types");
 const malloy_query_1 = require("../../model/malloy_query");
-const field_space_1 = require("../field-space");
 const ast_types_1 = require("./ast-types");
-const space_field_1 = require("../space-field");
 const sql_block_1 = require("../../model/sql_block");
 const util_1 = require("util");
 const time_utils_1 = require("./time-utils");
 const apply_expr_1 = require("./apply-expr");
+const field_utils_1 = require("../field-utils");
 /*
  ** For times when there is a code generation error but your function needs
  ** to return some kind of object to type properly, the ErrorFactory is
@@ -541,7 +542,7 @@ class RefinedExplore extends Mallobj {
         if (primaryKey) {
             from.primaryKey = primaryKey.field.name;
         }
-        const fs = field_space_1.DynamicSpace.filteredFrom(from, fieldListEdit);
+        const fs = DynamicSpace.filteredFrom(from, fieldListEdit);
         fs.addField(...fields);
         if (pList) {
             fs.addParameters(pList);
@@ -1115,7 +1116,7 @@ class ReduceExecutor {
         this.inputFS = this.resultFS.exprSpace;
     }
     getResultSpace(fs) {
-        return new field_space_1.ReduceFieldSpace(fs);
+        return new ReduceFieldSpace(fs);
     }
     execute(qp) {
         if (qp instanceof GroupBy ||
@@ -1219,7 +1220,7 @@ class ReduceExecutor {
 }
 class ProjectExecutor extends ReduceExecutor {
     getResultSpace(fs) {
-        return new field_space_1.ProjectFieldSpace(fs);
+        return new ProjectFieldSpace(fs);
     }
     execute(qp) {
         if (qp instanceof ProjectStatement) {
@@ -1253,7 +1254,7 @@ class ProjectExecutor extends ReduceExecutor {
 class IndexExecutor {
     constructor(inputFS) {
         this.filters = [];
-        this.resultFS = new field_space_1.IndexFieldSpace(inputFS);
+        this.resultFS = new IndexFieldSpace(inputFS);
         this.inputFS = this.resultFS.exprSpace;
     }
     execute(qp) {
@@ -1394,7 +1395,7 @@ class QOPDesc extends ListOf {
         const segment = qex.finalize(this.refineThis);
         return {
             segment,
-            outputSpace: () => new field_space_1.DynamicSpace(opOutputStruct(this, inputFS.structDef(), segment)),
+            outputSpace: () => new DynamicSpace(opOutputStruct(this, inputFS.structDef(), segment)),
         };
     }
 }
@@ -1692,10 +1693,10 @@ class ExistingQuery extends PipelineDesc {
         const queryHead = new QueryHeadStruct(seedQuery.structRef);
         this.has({ queryHead });
         const exploreStruct = queryHead.structDef();
-        const exploreFS = new field_space_1.DynamicSpace(exploreStruct);
+        const exploreFS = new DynamicSpace(exploreStruct);
         const sourcePipe = this.refinePipeline(exploreFS, seedQuery);
         const walkStruct = this.getOutputStruct(exploreStruct, sourcePipe.pipeline);
-        const appended = this.appendOps(sourcePipe.pipeline, new field_space_1.DynamicSpace(walkStruct));
+        const appended = this.appendOps(sourcePipe.pipeline, new DynamicSpace(walkStruct));
         const destPipe = { ...sourcePipe, pipeline: appended.opList };
         const query = {
             type: "query",
@@ -1736,7 +1737,7 @@ class FullQuery extends TurtleHeadedPipe {
         const structDef = model.refIsStructDef(structRef)
             ? structRef
             : this.explore.structDef();
-        let pipeFs = new field_space_1.DynamicSpace(structDef);
+        let pipeFs = new DynamicSpace(structDef);
         if (ErrorFactory.isErrorStructDef(structDef)) {
             return {
                 outputStruct: structDef,
@@ -1764,7 +1765,7 @@ class FullQuery extends TurtleHeadedPipe {
                 destQuery.pipeHead = { name };
             }
             const pipeStruct = this.getOutputStruct(structDef, refined);
-            pipeFs = new field_space_1.DynamicSpace(pipeStruct);
+            pipeFs = new DynamicSpace(pipeStruct);
         }
         const appended = this.appendOps(destQuery.pipeline, pipeFs);
         destQuery.pipeline = appended.opList;
@@ -1789,7 +1790,7 @@ class TurtleDecl extends TurtleHeadedPipe {
                 this.log(headEnt.error);
                 reportWrongType = false;
             }
-            else if (headEnt.found instanceof space_field_1.QueryField) {
+            else if (headEnt.found instanceof QueryField) {
                 const headDef = headEnt.found.getQueryFieldDef(fs);
                 if (isTurtle(headDef)) {
                     const newPipe = this.refinePipeline(fs, headDef);
@@ -1810,7 +1811,7 @@ class TurtleDecl extends TurtleHeadedPipe {
             for (const existingSeg of modelPipe.pipeline) {
                 endStruct = opOutputStruct(this, endStruct, existingSeg);
             }
-            appendInput = new field_space_1.DynamicSpace(endStruct);
+            appendInput = new DynamicSpace(endStruct);
         }
         const appended = this.appendOps(modelPipe.pipeline, appendInput);
         modelPipe.pipeline = appended.opList;
@@ -2325,7 +2326,7 @@ class FieldDeclaration extends MalloyElement {
          * a refactor of QueryFieldSpace might someday be the place where this should
          * happen.
          */
-        return this.queryFieldDef(new field_space_1.DefSpace(fs, this), exprName);
+        return this.queryFieldDef(new DefSpace(fs, this), exprName);
     }
     queryFieldDef(exprFS, exprName) {
         let exprValue;
@@ -2362,7 +2363,7 @@ class FieldDeclaration extends MalloyElement {
             }
             return template;
         }
-        const circularDef = exprFS instanceof field_space_1.DefSpace && exprFS.foundCircle;
+        const circularDef = exprFS instanceof DefSpace && exprFS.foundCircle;
         if (!circularDef) {
             if (exprValue.dataType == "unknown") {
                 this.log(`Cannot define '${exprName}', value has unknown type`);
@@ -2855,4 +2856,817 @@ class Range extends ExpressionDef {
     }
 }
 exports.Range = Range;
+/**
+ * Used to detect references to fields in the statement which defines them
+ */
+class DefSpace {
+    constructor(realFS, circular) {
+        this.realFS = realFS;
+        this.circular = circular;
+        this.type = "fieldSpace";
+        this.foundCircle = false;
+    }
+    structDef() {
+        return this.realFS.structDef();
+    }
+    emptyStructDef() {
+        return this.realFS.emptyStructDef();
+    }
+    lookup(symbol) {
+        if (symbol[0] && symbol[0].refString === this.circular.defineName) {
+            this.foundCircle = true;
+            return {
+                error: `Circular reference to '${this.circular.defineName}' in definition`,
+                found: undefined,
+            };
+        }
+        return this.realFS.lookup(symbol);
+    }
+    dialectObj() {
+        return this.realFS.dialectObj();
+    }
+    whenComplete(step) {
+        this.realFS.whenComplete(step);
+    }
+}
+exports.DefSpace = DefSpace;
+class StaticSpace {
+    constructor(sourceStructDef) {
+        this.type = "fieldSpace";
+        this.fromStruct = sourceStructDef;
+    }
+    whenComplete(step) {
+        step();
+    }
+    dialectObj() {
+        try {
+            return (0, dialect_map_1.getDialect)(this.fromStruct.dialect);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    fromFieldDef(from) {
+        if (from.type === "struct") {
+            return new StructSpaceField(from);
+        }
+        else if (model.isTurtleDef(from)) {
+            return new QueryFieldStruct(this, from);
+        }
+        // TODO field has a filter and needs to be a filteredalias
+        return new ColumnSpaceField(from);
+    }
+    get map() {
+        if (this.memoMap === undefined) {
+            this.memoMap = {};
+            for (const f of this.fromStruct.fields) {
+                const name = f.as || f.name;
+                this.memoMap[name] = this.fromFieldDef(f);
+            }
+            if (this.fromStruct.parameters) {
+                for (const [paramName, paramDef] of Object.entries(this.fromStruct.parameters)) {
+                    if (this.memoMap[paramName]) {
+                        throw new Error(`In struct '${this.fromStruct.as || this.fromStruct.name}': ` +
+                            ` : Field and parameter name conflict '${paramName}`);
+                    }
+                    this.memoMap[paramName] = new DefinedParameter(paramDef);
+                }
+            }
+        }
+        return this.memoMap;
+    }
+    dropEntries() {
+        this.memoMap = {};
+    }
+    dropEntry(name) {
+        delete this.map[name];
+    }
+    entry(name) {
+        return this.map[name];
+    }
+    setEntry(name, value) {
+        this.map[name] = value;
+    }
+    entries() {
+        return Object.entries(this.map);
+    }
+    structDef() {
+        return this.fromStruct;
+    }
+    emptyStructDef() {
+        return { ...this.fromStruct, fields: [] };
+    }
+    lookup(path) {
+        const head = path[0];
+        const rest = path.slice(1);
+        const found = this.entry(head.refString);
+        if (!found) {
+            return { error: `'${head}' is not defined`, found };
+        }
+        if (found instanceof 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
+             * needed to get the definition needs to be computed in the
+             * input space of the query. There is a test which failed which
+             * caused this code to be here, but this is really a bandaid.
+             *
+             * Some re-work of how to get the definition of a SpaceField
+             * no matter what it is contained in needs to be thought out.
+             *
+             * ... or this check would look at the finalized output of
+             * the namespace and not re-compile ...
+             */
+            const definition = found.fieldDef();
+            if (definition) {
+                head.addReference({
+                    type: found instanceof StructSpaceField
+                        ? "joinReference"
+                        : "fieldReference",
+                    definition,
+                    location: head.location,
+                    text: head.refString,
+                });
+            }
+        }
+        if (rest.length) {
+            if (found instanceof StructSpaceField) {
+                return found.fieldSpace.lookup(rest);
+            }
+            return {
+                error: `'${head}' cannot contain a '${rest[0]}'`,
+                found: undefined,
+            };
+        }
+        return { found, error: undefined };
+    }
+}
+exports.StaticSpace = StaticSpace;
+/**
+ * A FieldSpace which may undergo modification
+ */
+class DynamicSpace extends StaticSpace {
+    constructor(extending) {
+        const source = new SpaceSeed(extending);
+        super((0, lodash_1.cloneDeep)(source.structDef));
+        this.completions = [];
+        this.complete = false;
+        this.final = undefined;
+        this.source = source;
+    }
+    /**
+     * Factory for DynamicSpace when there are accept/except edits
+     * @param from A structdef which seeds this space
+     * @param choose A accept/except edit of the "from" fields
+     */
+    static filteredFrom(from, choose) {
+        const edited = new DynamicSpace(from);
+        if (choose) {
+            const names = choose.refs.list;
+            const oldMap = edited.entries();
+            edited.dropEntries();
+            for (const [symbol, value] of oldMap) {
+                const included = !!names.find((f) => f.refString === symbol);
+                const accepting = choose.edit === "accept";
+                if (included === accepting) {
+                    edited.setEntry(symbol, value);
+                }
+            }
+        }
+        return edited;
+    }
+    whenComplete(finalizeStep) {
+        if (this.complete) {
+            finalizeStep();
+        }
+        else {
+            this.completions.push(finalizeStep);
+        }
+    }
+    isComplete() {
+        this.complete = true;
+        for (const step of this.completions) {
+            step();
+        }
+        this.completions = [];
+    }
+    setEntry(name, value) {
+        if (this.final) {
+            throw new Error("Space already final");
+        }
+        super.setEntry(name, value);
+    }
+    addParameters(params) {
+        for (const oneP of params) {
+            this.setEntry(oneP.name, new AbstractParameter(oneP));
+        }
+        return this;
+    }
+    newEntry(name, astEl, entry) {
+        if (this.entry(name)) {
+            astEl.log(`Cannot redefine '${name}'`);
+            return;
+        }
+        this.setEntry(name, entry);
+    }
+    addField(...defs) {
+        for (const def of defs) {
+            // TODO express the "three fields kinds" in a typesafe way
+            // one of three kinds of fields are legal in an explore: expressions ...
+            const elseLog = def.log;
+            const elseType = def.elementType;
+            if (def instanceof FieldDeclaration) {
+                const exprField = new ExpressionFieldFromAst(this, def);
+                this.newEntry(exprField.name, def, exprField);
+                // querry (turtle) fields
+            }
+            else if (def instanceof TurtleDecl) {
+                const name = def.name;
+                this.newEntry(name, def, new QueryFieldAST(this, def, name));
+            }
+            else if (def instanceof RenameField) {
+                if (def.oldName.refString === def.newName) {
+                    def.log("Can't rename field to itself");
+                    continue;
+                }
+                const oldValue = def.oldName.getField(this);
+                if (oldValue.found) {
+                    if (oldValue.found instanceof SpaceField) {
+                        this.setEntry(def.newName, new RenameSpaceField(oldValue.found, def.newName, def.location));
+                        this.dropEntry(def.oldName.refString);
+                    }
+                    else {
+                        def.log(`'${def.oldName}' cannot be renamed`);
+                    }
+                }
+                else {
+                    def.log(`Can't rename '${def.oldName}', no such field`);
+                }
+            }
+            else if (def instanceof Join) {
+                this.newEntry(def.name.refString, def, new JoinSpaceField(this, def));
+            }
+            else {
+                elseLog(`Internal error: Expected expression, query, or rename, got '${elseType}'`);
+            }
+        }
+    }
+    addFieldDef(fd) {
+        this.setEntry((0, field_utils_1.nameOf)(fd), this.fromFieldDef(fd));
+    }
+    structDef() {
+        const parameters = this.fromStruct.parameters || {};
+        if (this.final === undefined) {
+            this.final = {
+                ...this.fromStruct,
+                fields: [],
+            };
+            // Need to process the entities in specific order
+            const fields = [];
+            const joins = [];
+            const turtles = [];
+            const fixupJoins = [];
+            for (const [name, spaceEntry] of this.entries()) {
+                if (spaceEntry instanceof StructSpaceField) {
+                    joins.push([name, spaceEntry]);
+                }
+                else if (spaceEntry instanceof QueryField) {
+                    turtles.push([name, spaceEntry]);
+                }
+                else if (spaceEntry instanceof SpaceField) {
+                    fields.push([name, spaceEntry]);
+                }
+                else if (spaceEntry instanceof SpaceParam) {
+                    parameters[name] = spaceEntry.parameter();
+                }
+            }
+            const reorderFields = [...fields, ...joins, ...turtles];
+            for (const [fieldName, field] of reorderFields) {
+                if (field instanceof JoinSpaceField) {
+                    const joinStruct = field.join.structDef();
+                    if (!ErrorFactory.isErrorStructDef(joinStruct)) {
+                        this.final.fields.push(joinStruct);
+                        fixupJoins.push([field.join, joinStruct]);
+                    }
+                }
+                else {
+                    const fieldDef = field.fieldDef();
+                    if (fieldDef) {
+                        this.final.fields.push(fieldDef);
+                    }
+                    else {
+                        throw new Error(`'${fieldName}' doesn't have a FieldDef`);
+                    }
+                }
+            }
+            if (Object.entries(parameters).length > 0) {
+                this.final.parameters = parameters;
+            }
+            // If we have join expressions, we need to now go back and fill them in
+            for (const [join, missingOn] of fixupJoins) {
+                join.fixupJoinOn(this, missingOn);
+            }
+        }
+        this.isComplete();
+        return this.final;
+    }
+}
+exports.DynamicSpace = DynamicSpace;
+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) {
+            if (member instanceof FieldReference) {
+                this.addReference(member);
+            }
+            else if (member instanceof WildcardFieldReference) {
+                this.addWild(member);
+            }
+            else {
+                this.addField(member);
+            }
+        }
+    }
+    addReference(ref) {
+        const refName = ref.outputName;
+        if (this.entry(refName)) {
+            ref.log(`Output already has a field named '${refName}'`);
+        }
+        else {
+            this.setEntry(refName, new ReferenceField(ref));
+        }
+    }
+    addWild(wild) {
+        this.setEntry(wild.refString, new WildSpaceField(wild.refString));
+    }
+    /**
+     * 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.entry(fn.refString)) {
+            if (isExclude && this.exprSpace.nestParent) {
+                const parent = this.exprSpace.nestParent;
+                parent.whenComplete(() => {
+                    parent.result.checkUngroup(fn, isExclude);
+                });
+            }
+            else {
+                const uName = isExclude ? "exclude()" : "all()";
+                fn.log(`${uName} '${fn.refString}' is missing from query output`);
+            }
+        }
+    }
+    addQueryItems(...qiList) {
+        for (const qi of qiList) {
+            if (qi instanceof FieldReference || qi instanceof NestReference) {
+                this.addReference(qi);
+            }
+            else if (qi instanceof FieldDeclaration) {
+                this.addField(qi);
+            }
+            else if (isNestedQuery(qi)) {
+                const qf = new QueryFieldAST(this, qi, qi.name);
+                qf.nestParent = this.exprSpace;
+                this.setEntry(qi.name, qf);
+            }
+            else {
+                // Compiler will error if we don't handle all cases
+                const _itemNotHandled = qi;
+            }
+        }
+    }
+    canContain(_qd) {
+        return true;
+    }
+    queryFieldDefs() {
+        const fields = [];
+        for (const [name, field] of this.entries()) {
+            if (field instanceof SpaceField) {
+                const fieldQueryDef = field.getQueryFieldDef(this.exprSpace);
+                if (fieldQueryDef) {
+                    if (this.canContain(fieldQueryDef)) {
+                        fields.push(fieldQueryDef);
+                    }
+                    else {
+                        this.log(`'${name}' not legal in ${this.segmentType}`);
+                    }
+                }
+                else {
+                    throw new Error(`'${name}' does not have a QueryFieldDef`);
+                }
+            }
+        }
+        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.ResultSpace = ResultSpace;
+/**
+ * Reduce and project queries use a "QuerySpace"
+ */
+class ReduceFieldSpace extends ResultSpace {
+    constructor() {
+        super(...arguments);
+        this.segmentType = "reduce";
+    }
+}
+exports.ReduceFieldSpace = ReduceFieldSpace;
+class ProjectFieldSpace extends ResultSpace {
+    constructor() {
+        super(...arguments);
+        this.segmentType = "project";
+    }
+    canContain(qd) {
+        if (typeof qd !== "string") {
+            if (model.isFilteredAliasedName(qd)) {
+                return true;
+            }
+            if (qd.type === "turtle") {
+                this.log("Cannot nest queries in project");
+                return false;
+            }
+            if (model.expressionIsAggregate(qd.expressionType)) {
+                this.log("Cannot add aggregate measures to project");
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.ProjectFieldSpace = ProjectFieldSpace;
+class SpaceEntry {
+}
+exports.SpaceEntry = SpaceEntry;
+class SpaceField extends SpaceEntry {
+    constructor() {
+        super(...arguments);
+        this.refType = "field";
+    }
+    fieldTypeFromFieldDef(def) {
+        const ref = { type: def.type };
+        if (model.isFieldTypeDef(def) && def.expressionType) {
+            ref.expressionType = def.expressionType;
+        }
+        return ref;
+    }
+    getQueryFieldDef(_fs) {
+        return undefined;
+    }
+    fieldDef() {
+        return undefined;
+    }
+}
+exports.SpaceField = SpaceField;
+class StructSpaceField extends SpaceField {
+    constructor(sourceDef) {
+        super();
+        this.sourceDef = sourceDef;
+    }
+    get fieldSpace() {
+        if (!this.space) {
+            this.space = new StaticSpace(this.sourceDef);
+        }
+        return this.space;
+    }
+    fieldDef() {
+        return this.sourceDef;
+    }
+    type() {
+        return { type: "struct" };
+    }
+}
+exports.StructSpaceField = StructSpaceField;
+class QueryField extends SpaceField {
+    constructor(inSpace) {
+        super();
+        this.inSpace = inSpace;
+    }
+    type() {
+        return { type: "turtle" };
+    }
+}
+exports.QueryField = QueryField;
+class QueryFieldStruct extends QueryField {
+    constructor(fs, turtleDef) {
+        super(fs);
+        this.turtleDef = turtleDef;
+    }
+    rename(name) {
+        this.turtleDef = {
+            ...this.turtleDef,
+            as: name,
+        };
+    }
+    fieldDef() {
+        return this.turtleDef;
+    }
+    getQueryFieldDef(_fs) {
+        return this.fieldDef();
+    }
+}
+exports.QueryFieldStruct = QueryFieldStruct;
+class ColumnSpaceField extends SpaceField {
+    constructor(def) {
+        super();
+        this.def = def;
+    }
+    fieldDef() {
+        return this.def;
+    }
+    type() {
+        return this.fieldTypeFromFieldDef(this.def);
+    }
+}
+exports.ColumnSpaceField = ColumnSpaceField;
+class SpaceParam extends SpaceEntry {
+    constructor() {
+        super(...arguments);
+        this.refType = "parameter";
+    }
+}
+exports.SpaceParam = SpaceParam;
+class DefinedParameter extends SpaceParam {
+    constructor(paramDef) {
+        super();
+        this.paramDef = paramDef;
+    }
+    parameter() {
+        return this.paramDef;
+    }
+    type() {
+        return { type: this.paramDef.type };
+    }
+}
+exports.DefinedParameter = DefinedParameter;
+/**
+ * Based on how things are constructed, the starting field space
+ * can either be another field space or an existing structdef.
+ * Using a SpaceSeed allows a class to accept either one
+ * and use either version at some future time.
+ */
+class SpaceSeed {
+    constructor(sourceSpec) {
+        this.sourceSpec = sourceSpec;
+        this.spaceSpec = sourceSpec;
+    }
+    get structDef() {
+        if (isFieldSpace(this.spaceSpec)) {
+            if (!this.asStruct) {
+                this.asStruct = this.spaceSpec.structDef();
+            }
+            return this.asStruct;
+        }
+        return this.spaceSpec;
+    }
+    get fieldSpace() {
+        if (isFieldSpace(this.spaceSpec)) {
+            return this.spaceSpec;
+        }
+        if (!this.asFS) {
+            this.asFS = new StaticSpace(this.spaceSpec);
+        }
+        return this.asFS;
+    }
+}
+exports.SpaceSeed = SpaceSeed;
+function isFieldSpace(x) {
+    return x.type == "fieldSpace";
+}
+class AbstractParameter extends SpaceParam {
+    constructor(astParam) {
+        super();
+        this.astParam = astParam;
+    }
+    parameter() {
+        return this.astParam.parameter();
+    }
+    type() {
+        const type = this.astParam.type || "unknown";
+        return { type };
+    }
+}
+exports.AbstractParameter = AbstractParameter;
+class ExpressionFieldFromAst extends SpaceField {
+    constructor(space, exprDef) {
+        super();
+        this.space = space;
+        this.exprDef = exprDef;
+        this.fieldName = exprDef.defineName;
+    }
+    get name() {
+        return this.fieldName;
+    }
+    fieldDef() {
+        const def = this.exprDef.fieldDef(this.space, this.name);
+        this.defType = this.fieldTypeFromFieldDef(def);
+        return def;
+    }
+    getQueryFieldDef(fs) {
+        const def = this.exprDef.queryFieldDef(fs, this.name);
+        this.defType = this.fieldTypeFromFieldDef(def);
+        return def;
+    }
+    type() {
+        if (this.defType) {
+            return this.defType;
+        }
+        return this.fieldTypeFromFieldDef(this.fieldDef());
+    }
+}
+exports.ExpressionFieldFromAst = ExpressionFieldFromAst;
+class QueryFieldAST extends QueryField {
+    constructor(fs, turtle, name) {
+        super(fs);
+        this.turtle = turtle;
+        this.name = name;
+    }
+    getQueryFieldDef(fs) {
+        const def = this.turtle.getFieldDef(fs, this.nestParent);
+        if (this.renameAs) {
+            def.as = this.renameAs;
+        }
+        return def;
+    }
+    fieldDef() {
+        const def = this.turtle.getFieldDef(this.inSpace, this.nestParent);
+        if (this.renameAs) {
+            def.as = this.renameAs;
+        }
+        return def;
+    }
+}
+exports.QueryFieldAST = QueryFieldAST;
+class RenameSpaceField extends SpaceField {
+    constructor(otherField, newName, location) {
+        super();
+        this.otherField = otherField;
+        this.newName = newName;
+        this.location = location;
+    }
+    fieldDef() {
+        const renamedFieldRaw = this.otherField.fieldDef();
+        if (renamedFieldRaw === undefined) {
+            return undefined;
+        }
+        return {
+            ...renamedFieldRaw,
+            as: this.newName,
+            location: this.location,
+        };
+    }
+    type() {
+        return this.otherField.type();
+    }
+}
+exports.RenameSpaceField = RenameSpaceField;
+class JoinSpaceField extends StructSpaceField {
+    constructor(intoFS, join) {
+        super(join.structDef());
+        this.intoFS = intoFS;
+        this.join = join;
+    }
+}
+exports.JoinSpaceField = JoinSpaceField;
+/**
+ * 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 QuerySpace extends DynamicSpace {
+    constructor(input, result) {
+        const inputSpace = new SpaceSeed(input);
+        super(inputSpace.structDef);
+        this.result = result;
+        this.extendList = [];
+    }
+    extendSource(extendField) {
+        this.addField(extendField);
+        if (extendField instanceof Join) {
+            this.extendList.push(extendField.name.refString);
+        }
+        else {
+            this.extendList.push(extendField.defineName);
+        }
+    }
+}
+exports.QuerySpace = QuerySpace;
+class ReferenceField extends SpaceField {
+    constructor(fieldRef) {
+        super();
+        this.fieldRef = fieldRef;
+    }
+    getQueryFieldDef(fs) {
+        // Lookup string and generate error if it isn't defined.
+        const check = this.fieldRef.getField(fs);
+        if (check.error) {
+            this.fieldRef.log(check.error);
+        }
+        return this.fieldRef.refString;
+    }
+    type() {
+        return { type: "unknown" };
+    }
+}
+exports.ReferenceField = ReferenceField;
+class WildSpaceField extends SpaceField {
+    constructor(wildText) {
+        super();
+        this.wildText = wildText;
+    }
+    type() {
+        throw new Error("should never ask a wild field for its type");
+    }
+    getQueryFieldDef(_fs) {
+        return this.wildText;
+    }
+}
+exports.WildSpaceField = WildSpaceField;
+class IndexFieldSpace extends ResultSpace {
+    constructor() {
+        super(...arguments);
+        this.segmentType = "index";
+        this.fieldList = new Set();
+    }
+    addReference(ref) {
+        if (ref.getField(this.exprSpace).found) {
+            this.fieldList.add(ref.refString);
+        }
+    }
+    addWild(wild) {
+        this.fieldList.add(wild.refString);
+    }
+    getPipeSegment(refineIndex) {
+        if (refineIndex && refineIndex.fields) {
+            for (const exists of refineIndex.fields) {
+                if (typeof exists == "string") {
+                    this.fieldList.add(exists);
+                }
+            }
+        }
+        this.isComplete();
+        return {
+            type: "index",
+            fields: Array.from(this.fieldList.values()),
+        };
+    }
+}
+exports.IndexFieldSpace = IndexFieldSpace;
 //# sourceMappingURL=ast-main.js.map