@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230206094309

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

@@ -1,3672 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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.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
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-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 ast_types_1 = require("./ast-types");
-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
- ** here to help you.
- */
-const theErrorStruct = {
-    type: "struct",
-    name: "~malformed~",
-    dialect: "~malformed~",
-    structSource: { type: "table", tablePath: "//undefined_error_table_path" },
-    structRelationship: {
-        type: "basetable",
-        connectionName: "//undefined_error_connection",
-    },
-    fields: [],
-};
-class ErrorFactory {
-    static get structDef() {
-        return { ...theErrorStruct };
-    }
-    static isErrorStructDef(s) {
-        return s.name.includes(theErrorStruct.name);
-    }
-    static get query() {
-        return {
-            structRef: ErrorFactory.structDef,
-            pipeline: [],
-        };
-    }
-    static get reduceSegment() {
-        return { type: "reduce", fields: [] };
-    }
-    static get projectSegment() {
-        return { type: "project", fields: [] };
-    }
-    static get indexSegment() {
-        return { type: "index", fields: [] };
-    }
-}
-exports.ErrorFactory = ErrorFactory;
-function opOutputStruct(logTo, inputStruct, opDesc) {
-    const badModel = ErrorFactory.isErrorStructDef(inputStruct);
-    // Don't call into the model code with a broken model
-    if (!badModel) {
-        try {
-            return malloy_query_1.Segment.nextStructDef(inputStruct, opDesc);
-        }
-        catch (e) {
-            logTo.log(`INTERNAL ERROR model/Segment.nextStructDef: ${e.message}\n` +
-                `QUERY: ${(0, util_1.inspect)(opDesc, { breakLength: 72, depth: Infinity })}`);
-        }
-    }
-    return { ...ErrorFactory.structDef, dialect: inputStruct.dialect };
-}
-class MalloyElement {
-    /**
-     * @param kids All children passed to the constructor are not optional
-     */
-    constructor(kids) {
-        this.children = {};
-        this.parent = null;
-        this.logged = new Set();
-        if (kids) {
-            this.has(kids);
-        }
-    }
-    /**
-     * Record all elements as children of this element, and mark this
-     * element as their parent.
-     * @param kids Some of these might be undefined, in which case they are ignored
-     */
-    has(kids) {
-        for (const kidName in kids) {
-            const kidValue = kids[kidName];
-            if (kidValue !== undefined) {
-                this.children[kidName] = kidValue;
-                if (kidValue instanceof MalloyElement) {
-                    kidValue.parent = this;
-                }
-                else {
-                    for (const oneKid of kidValue) {
-                        oneKid.parent = this;
-                    }
-                }
-            }
-        }
-    }
-    get location() {
-        if (this.codeLocation) {
-            return this.codeLocation;
-        }
-        if (this.parent) {
-            return this.parent.location;
-        }
-        return {
-            url: this.sourceURL,
-            range: {
-                start: { line: 0, character: 0 },
-                end: { line: 0, character: 0 },
-            },
-        };
-    }
-    set location(loc) {
-        this.codeLocation = loc;
-    }
-    namespace() {
-        if (this instanceof Document) {
-            return this;
-        }
-        else if (this.parent) {
-            return this.parent.namespace();
-        }
-        throw new Error("INTERNAL ERROR: Translation without document scope");
-    }
-    modelEntry(reference) {
-        var _a;
-        const key = reference instanceof ModelEntryReference ? reference.name : reference;
-        const result = (_a = this.namespace()) === null || _a === void 0 ? void 0 : _a.getEntry(key);
-        if (reference instanceof ModelEntryReference) {
-            if ((result === null || result === void 0 ? void 0 : result.entry.type) === "query") {
-                this.addReference({
-                    type: "queryReference",
-                    text: key,
-                    definition: result.entry,
-                    location: reference.location,
-                });
-            }
-            else if ((result === null || result === void 0 ? void 0 : result.entry.type) === "struct") {
-                if (model.isSQLBlock(result.entry)) {
-                    this.addReference({
-                        type: "sqlBlockReference",
-                        text: key,
-                        definition: result.entry,
-                        location: reference.location,
-                    });
-                }
-                else {
-                    this.addReference({
-                        type: "exploreReference",
-                        text: key,
-                        definition: result.entry,
-                        location: reference.location,
-                    });
-                }
-            }
-        }
-        return result;
-    }
-    translator() {
-        if (this.xlate) {
-            return this.xlate;
-        }
-        if (this.parent) {
-            return this.parent.translator();
-        }
-        return undefined;
-    }
-    setTranslator(x) {
-        this.xlate = x;
-    }
-    addReference(reference) {
-        var _a;
-        (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.addReference(reference);
-    }
-    get sourceURL() {
-        const trans = this.translator();
-        return (trans === null || trans === void 0 ? void 0 : trans.sourceURL) || "(missing)";
-    }
-    errorsExist() {
-        var _a;
-        const logger = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.logger;
-        if (logger) {
-            return logger.hasErrors();
-        }
-        return true;
-    }
-    log(message) {
-        if (this.codeLocation) {
-            /*
-             * If this element has a location, then don't report the same
-             * error message at the same location more than once
-             */
-            if (this.logged.has(message)) {
-                return;
-            }
-            this.logged.add(message);
-        }
-        const trans = this.translator();
-        const msg = { at: this.location, message };
-        const logTo = trans === null || trans === void 0 ? void 0 : trans.root.logger;
-        if (logTo) {
-            logTo.log(msg);
-            return;
-        }
-        throw new Error(`Translation error (without error reporter):\n${JSON.stringify(msg, null, 2)}`);
-    }
-    /**
-     * Mostly for debugging / testing. A string-y version of this object which
-     * is used to ask "are these two AST segments equal". Formatted so that
-     * errors would be human readable.
-     * @param indent only used for recursion
-     */
-    toString() {
-        return this.stringify("", 0);
-    }
-    stringify(prefix, indent) {
-        const left = " ".repeat(indent);
-        let asString = `${left}${prefix}<${this.elementType}>${this.varInfo()}`;
-        for (const kidLabel of Object.keys(this.children)) {
-            const kiddle = this.children[kidLabel];
-            if (kiddle instanceof MalloyElement) {
-                asString += "\n" + kiddle.stringify(`${kidLabel}: `, indent + 2);
-            }
-            else {
-                asString += `\n${left}  ${kidLabel}: [`;
-                if (kiddle.length > 0) {
-                    asString +=
-                        "\n" +
-                            kiddle.map((k) => k.stringify("", indent + 4)).join("\n") +
-                            `\n${left}  `;
-                }
-                asString += "]";
-            }
-        }
-        return asString;
-    }
-    walk(callBack) {
-        callBack(this);
-        for (const kidLabel of Object.keys(this.children)) {
-            const kiddle = this.children[kidLabel];
-            if (kiddle instanceof MalloyElement) {
-                kiddle.walk(callBack);
-            }
-            else {
-                for (const k of kiddle) {
-                    k.walk(callBack);
-                }
-            }
-        }
-    }
-    varInfo() {
-        let extra = "";
-        for (const [key, value] of Object.entries(this)) {
-            if (key !== "elementType") {
-                if (typeof value == "boolean") {
-                    extra += value ? ` ${key}` : ` !${key}`;
-                }
-                else if (typeof value === "string" || typeof value === "number") {
-                    extra += ` ${key}=${value}`;
-                }
-            }
-        }
-        return extra;
-    }
-    internalError(msg) {
-        this.log(`INTERNAL ERROR IN TRANSLATION: ${msg}`);
-        return new Error(msg);
-    }
-}
-exports.MalloyElement = MalloyElement;
-class ListOf extends MalloyElement {
-    constructor(listDesc, elements) {
-        super();
-        this.elementType = "genericElementList";
-        this.elements = elements;
-        if (this.elementType === "genericElementList") {
-            this.elementType = listDesc;
-        }
-        this.newContents();
-    }
-    newContents() {
-        this.has({ [this.elementType]: this.elements });
-    }
-    get list() {
-        return this.elements;
-    }
-    empty() {
-        return this.elements.length === 0;
-    }
-    notEmpty() {
-        return this.elements.length > 0;
-    }
-    push(...el) {
-        this.elements.push(...el);
-        this.newContents();
-        return this.elements;
-    }
-}
-exports.ListOf = ListOf;
-class Unimplemented extends MalloyElement {
-    constructor() {
-        super(...arguments);
-        this.elementType = "unimplemented";
-        this.reported = false;
-    }
-}
-exports.Unimplemented = Unimplemented;
-function getStructFieldDef(s, fn) {
-    return s.fields.find((fld) => (fld.as || fld.name) === fn);
-}
-function isFieldDecl(f) {
-    return (f instanceof FieldDeclaration ||
-        f instanceof Join ||
-        f instanceof TurtleDecl ||
-        f instanceof Turtles);
-}
-function isExploreField(f) {
-    return isFieldDecl(f) || f instanceof RenameField;
-}
-exports.isExploreField = isExploreField;
-/**
- * A "Mallobj" is a thing which you can run queries against, it has been called
- * an "exploreable", or a "space".
- */
-class Mallobj extends MalloyElement {
-    structRef() {
-        return this.structDef();
-    }
-    withParameters(pList) {
-        const before = this.structDef();
-        // TODO name collisions are flagged where?
-        if (pList) {
-            const parameters = { ...(before.parameters || {}) };
-            for (const hasP of pList) {
-                const pVal = hasP.parameter();
-                parameters[pVal.name] = pVal;
-            }
-            return {
-                ...before,
-                parameters,
-            };
-        }
-        return before;
-    }
-}
-exports.Mallobj = Mallobj;
-class QueryHeadStruct extends Mallobj {
-    constructor(fromRef) {
-        super();
-        this.fromRef = fromRef;
-        this.elementType = "internalOnlyQueryHead";
-    }
-    structRef() {
-        return this.fromRef;
-    }
-    structDef() {
-        if (model.refIsStructDef(this.fromRef)) {
-            return this.fromRef;
-        }
-        const ns = new NamedSource(this.fromRef);
-        this.has({ exploreReference: ns });
-        return ns.structDef();
-    }
-}
-class RunList extends ListOf {
-    constructor() {
-        super(...arguments);
-        this.execCursor = 0;
-    }
-    executeList(doc) {
-        while (this.execCursor < this.elements.length) {
-            if (doc.errorsExist()) {
-                // This stops cascading errors
-                return;
-            }
-            const el = this.elements[this.execCursor];
-            if (isDocStatement(el)) {
-                const resp = el.execute(doc);
-                if (resp) {
-                    return resp;
-                }
-                this.execCursor += 1;
-            }
-        }
-        return undefined;
-    }
-}
-exports.RunList = RunList;
-function isDocStatement(e) {
-    return e.execute !== undefined;
-}
-exports.isDocStatement = isDocStatement;
-class DefineExplore extends MalloyElement {
-    constructor(name, mallobj, exported, params) {
-        super({ explore: mallobj });
-        this.name = name;
-        this.mallobj = mallobj;
-        this.exported = exported;
-        this.elementType = "defineExplore";
-        if (params) {
-            this.parameters = [];
-            for (const el of params) {
-                if (el instanceof HasParameter) {
-                    this.parameters.push(el);
-                }
-                else {
-                    this.log(`Unexpected element type in define statement: ${el.elementType}`);
-                }
-            }
-            this.has({ parameters: this.parameters });
-        }
-    }
-    execute(doc) {
-        if (doc.modelEntry(this.name)) {
-            this.log(`Cannot redefine '${this.name}'`);
-        }
-        else {
-            const structDef = this.mallobj.withParameters(this.parameters);
-            if (ErrorFactory.isErrorStructDef(structDef)) {
-                return;
-            }
-            doc.setEntry(this.name, {
-                entry: {
-                    ...structDef,
-                    as: this.name,
-                    location: this.location,
-                },
-                exported: this.exported,
-            });
-        }
-    }
-}
-exports.DefineExplore = DefineExplore;
-class DefineSourceList extends RunList {
-    constructor(sourceList) {
-        super("defineSources", sourceList);
-    }
-    execute(doc) {
-        return this.executeList(doc);
-    }
-}
-exports.DefineSourceList = DefineSourceList;
-/**
- * A Mallobj made from a source and a set of refinements
- */
-class RefinedExplore extends Mallobj {
-    constructor(source, refinement) {
-        super({ source, refinement });
-        this.source = source;
-        this.refinement = refinement;
-        this.elementType = "refinedExplore";
-    }
-    structDef() {
-        return this.withParameters([]);
-    }
-    withParameters(pList) {
-        let primaryKey;
-        let fieldListEdit;
-        const fields = [];
-        const filters = [];
-        for (const el of this.refinement.list) {
-            const errTo = el;
-            if (el instanceof PrimaryKey) {
-                if (primaryKey) {
-                    primaryKey.log("Primary key already defined");
-                    el.log("Primary key redefined");
-                }
-                primaryKey = el;
-            }
-            else if (el instanceof FieldListEdit) {
-                if (fieldListEdit) {
-                    fieldListEdit.log("Too many accept/except statements");
-                    el.log("Too many accept/except statements");
-                }
-                fieldListEdit = el;
-            }
-            else if (el instanceof DeclareFields ||
-                el instanceof Joins ||
-                el instanceof Turtles ||
-                el instanceof Renames) {
-                fields.push(...el.list);
-            }
-            else if (el instanceof Filter) {
-                filters.push(el);
-            }
-            else {
-                errTo.log(`Unexpected explore property: '${errTo.elementType}'`);
-            }
-        }
-        const from = (0, lodash_1.cloneDeep)(this.source.structDef());
-        if (primaryKey) {
-            from.primaryKey = primaryKey.field.name;
-        }
-        const fs = DynamicSpace.filteredFrom(from, fieldListEdit);
-        fs.addField(...fields);
-        if (pList) {
-            fs.addParameters(pList);
-        }
-        if (primaryKey) {
-            const keyDef = primaryKey.field.getField(fs);
-            if (keyDef.error) {
-                primaryKey.log(keyDef.error);
-            }
-        }
-        const retStruct = fs.structDef();
-        const filterList = retStruct.filterList || [];
-        let moreFilters = false;
-        for (const filter of filters) {
-            for (const el of filter.list) {
-                const fc = el.filterExpression(fs);
-                if (model.expressionIsCalculation(fc.expressionType)) {
-                    el.log("Can't use aggregate computations in top level filters");
-                }
-                else {
-                    filterList.push(fc);
-                    moreFilters = true;
-                }
-            }
-        }
-        if (moreFilters) {
-            return { ...retStruct, filterList };
-        }
-        return retStruct;
-    }
-}
-exports.RefinedExplore = RefinedExplore;
-class TableSource extends Mallobj {
-    constructor(name) {
-        super();
-        this.name = name;
-        this.elementType = "tableSource";
-    }
-    structDef() {
-        var _a;
-        const tableDefEntry = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.schemaZone.getEntry(this.name);
-        let msg = `Schema read failure for table '${this.name}'`;
-        if (tableDefEntry) {
-            if (tableDefEntry.status == "present") {
-                tableDefEntry.value.location = this.location;
-                tableDefEntry.value.fields.forEach((field) => (field.location = this.location));
-                return {
-                    ...tableDefEntry.value,
-                    fields: tableDefEntry.value.fields.map((field) => ({
-                        ...field,
-                        location: this.location,
-                    })),
-                    location: this.location,
-                };
-            }
-            if (tableDefEntry.status == "error") {
-                msg = tableDefEntry.message;
-            }
-        }
-        this.log(msg);
-        return ErrorFactory.structDef;
-    }
-}
-exports.TableSource = TableSource;
-class IsValueBlock extends MalloyElement {
-    constructor(isMap) {
-        super();
-        this.isMap = isMap;
-        this.elementType = "isValueBlock";
-        this.has(isMap);
-    }
-}
-exports.IsValueBlock = IsValueBlock;
-class ModelEntryReference extends MalloyElement {
-    constructor(name) {
-        super();
-        this.name = name;
-        this.elementType = "modelEntryReference";
-    }
-    get refString() {
-        return this.name;
-    }
-    toString() {
-        return this.refString;
-    }
-}
-exports.ModelEntryReference = ModelEntryReference;
-class NamedSource extends Mallobj {
-    constructor(ref, paramValues = {}) {
-        super();
-        this.ref = ref;
-        this.elementType = "namedSource";
-        if (paramValues && Object.keys(paramValues).length > 0) {
-            this.isBlock = new IsValueBlock(paramValues);
-            this.has({ parameterValues: this.isBlock });
-        }
-        if (ref instanceof ModelEntryReference) {
-            this.has({ ref });
-        }
-    }
-    get refName() {
-        return this.ref instanceof ModelEntryReference ? this.ref.name : this.ref;
-    }
-    structRef() {
-        if (this.isBlock) {
-            return this.structDef();
-        }
-        const modelEnt = this.modelEntry(this.ref);
-        if (modelEnt && !modelEnt.exported) {
-            // If we are not exporting the referenced structdef, don't
-            // use the reference
-            return this.structDef();
-        }
-        return this.refName;
-    }
-    modelStruct() {
-        const modelEnt = this.modelEntry(this.ref);
-        const entry = modelEnt === null || modelEnt === void 0 ? void 0 : modelEnt.entry;
-        if (!entry) {
-            const undefMsg = `Undefined source '${this.refName}'`;
-            (this.ref instanceof ModelEntryReference ? this.ref : this).log(undefMsg);
-            return;
-        }
-        if (entry.type === "query") {
-            this.log(`Must use 'from()' for query source '${this.refName}`);
-            return;
-        }
-        else if (modelEnt.sqlType) {
-            this.log(`Must use 'from_sql()' for sql source '${this.refName}`);
-            return;
-        }
-        return { ...entry };
-    }
-    structDef() {
-        /*
-          Can't really generate the callback list until after all the
-          things before me are translated, and that kinda screws up
-          the translation process, so that might be a better place
-          to start the next step, because how that gets done might
-          make any code I write which ignores the translation problem
-          kind of meaningless.
-    
-          Maybe the output of a translation is something which describes
-          all the missing data, and then there is a "link" step where you
-          can do other translations and link them into a partial translation
-          which might result in a full translation.
-        */
-        var _a;
-        const ret = this.modelStruct();
-        if (!ret) {
-            const notFound = ErrorFactory.structDef;
-            const err = `${this.refName}-undefined`;
-            notFound.name = notFound.name + err;
-            notFound.dialect = notFound.dialect + err;
-            return notFound;
-        }
-        const declared = { ...ret.parameters } || {};
-        const makeWith = ((_a = this.isBlock) === null || _a === void 0 ? void 0 : _a.isMap) || {};
-        for (const [pName, pExpr] of Object.entries(makeWith)) {
-            const decl = declared[pName];
-            // const pVal = pExpr.constantValue();
-            if (!decl) {
-                this.log(`Value given for undeclared parameter '${pName}`);
-            }
-            else {
-                if (model.isValueParameter(decl)) {
-                    if (decl.constant) {
-                        pExpr.log(`Cannot override constant parameter ${pName}`);
-                    }
-                    else {
-                        const pVal = pExpr.constantValue();
-                        let value = pVal.value;
-                        if (pVal.dataType !== decl.type) {
-                            value = (0, time_utils_1.castTo)(decl.type, pVal.value, true);
-                        }
-                        decl.value = value;
-                    }
-                }
-                else {
-                    // TODO type checking here -- except I am still not sure what
-                    // datatype half conditions have ..
-                    decl.condition = pExpr.constantCondition(decl.type).value;
-                }
-            }
-        }
-        for (const checkDef in ret.parameters) {
-            if (!model.paramHasValue(declared[checkDef])) {
-                this.log(`Value not provided for required parameter ${checkDef}`);
-            }
-        }
-        return ret;
-    }
-}
-exports.NamedSource = NamedSource;
-class SQLSource extends NamedSource {
-    constructor() {
-        super(...arguments);
-        this.elementType = "sqlSource";
-    }
-    structRef() {
-        return this.structDef();
-    }
-    modelStruct() {
-        const modelEnt = this.modelEntry(this.ref);
-        const entry = modelEnt === null || modelEnt === void 0 ? void 0 : modelEnt.entry;
-        if (!entry) {
-            this.log(`Undefined from_sql source '${this.refName}'`);
-            return;
-        }
-        if (entry.type === "query") {
-            this.log(`Cannot use 'from_sql()' to explore query '${this.refName}'`);
-            return;
-        }
-        else if (!modelEnt.sqlType) {
-            this.log(`Cannot use 'from_sql()' to explore '${this.refName}'`);
-            return;
-        }
-        return entry;
-    }
-}
-exports.SQLSource = SQLSource;
-class QuerySource extends Mallobj {
-    constructor(query) {
-        super({ query });
-        this.query = query;
-        this.elementType = "querySource";
-    }
-    structDef() {
-        const comp = this.query.queryComp();
-        const queryStruct = comp.outputStruct;
-        queryStruct.structSource = { type: "query", query: comp.query };
-        return queryStruct;
-    }
-}
-exports.QuerySource = QuerySource;
-class Join extends MalloyElement {
-}
-exports.Join = Join;
-class KeyJoin extends Join {
-    constructor(name, source, keyExpr) {
-        super({ name, source, keyExpr });
-        this.name = name;
-        this.source = source;
-        this.keyExpr = keyExpr;
-        this.elementType = "joinOnKey";
-    }
-    structDef() {
-        const sourceDef = this.source.structDef();
-        const joinStruct = {
-            ...sourceDef,
-            structRelationship: {
-                type: "one",
-                onExpression: ["('join fixup'='not done yet')"],
-            },
-            location: this.location,
-        };
-        if (sourceDef.structSource.type === "query") {
-            // the name from query does not need to be preserved
-            joinStruct.name = this.name.refString;
-        }
-        else {
-            joinStruct.as = this.name.refString;
-        }
-        return joinStruct;
-    }
-    fixupJoinOn(outer, inStruct) {
-        const exprX = this.keyExpr.getExpression(outer);
-        if (inStruct.primaryKey) {
-            const pkey = inStruct.fields.find((f) => (f.as || f.name) === inStruct.primaryKey);
-            if (pkey) {
-                if (pkey.type === exprX.dataType) {
-                    inStruct.structRelationship = {
-                        type: "one",
-                        onExpression: [
-                            { type: "field", path: `${this.name}.${inStruct.primaryKey}` },
-                            "=",
-                            ...exprX.value,
-                        ],
-                    };
-                    return;
-                }
-                else {
-                    this.log(`join_one: with type mismatch with primary key: ${exprX.dataType}/${pkey.type}`);
-                }
-            }
-            else {
-                this.log(`join_one: Primary key '${pkey}' not found in source`);
-            }
-        }
-        else {
-            this.log(`join_one: Cannot use with unless source has a primary key`);
-        }
-    }
-}
-exports.KeyJoin = KeyJoin;
-class ExpressionJoin extends Join {
-    constructor(name, source) {
-        super({ name, source });
-        this.name = name;
-        this.source = source;
-        this.elementType = "joinOnExpr";
-        this.joinType = "one";
-    }
-    set joinOn(joinExpr) {
-        this.expr = joinExpr;
-        this.has({ on: joinExpr });
-    }
-    get joinOn() {
-        return this.expr;
-    }
-    fixupJoinOn(outer, inStruct) {
-        if (this.expr == undefined) {
-            return;
-        }
-        const exprX = this.expr.getExpression(outer);
-        if (exprX.dataType !== "boolean") {
-            this.log("join conditions must be boolean expressions");
-            return;
-        }
-        const joinRel = inStruct.structRelationship;
-        if (model.isJoinOn(joinRel)) {
-            joinRel.onExpression = (0, ast_types_1.compressExpr)(exprX.value);
-        }
-    }
-    structDef() {
-        const sourceDef = this.source.structDef();
-        const joinStruct = {
-            ...sourceDef,
-            structRelationship: { type: this.joinType },
-            location: this.location,
-        };
-        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;
-        }
-        return joinStruct;
-    }
-}
-exports.ExpressionJoin = ExpressionJoin;
-class Joins extends ListOf {
-    constructor(joins) {
-        super("joinList", joins);
-    }
-}
-exports.Joins = Joins;
-function isQueryProperty(q) {
-    return (q instanceof Ordering ||
-        q instanceof Top ||
-        q instanceof Limit ||
-        q instanceof Filter ||
-        q instanceof Index ||
-        q instanceof SampleProperty ||
-        q instanceof Joins ||
-        q instanceof DeclareFields ||
-        q instanceof ProjectStatement ||
-        q instanceof Aggregate ||
-        q instanceof Nests ||
-        isNestedQuery(q) ||
-        q instanceof GroupBy);
-}
-exports.isQueryProperty = isQueryProperty;
-function isExploreProperty(p) {
-    return (p instanceof Filter ||
-        p instanceof Joins ||
-        p instanceof DeclareFields ||
-        p instanceof FieldListEdit ||
-        p instanceof Renames ||
-        p instanceof PrimaryKey ||
-        p instanceof Turtles);
-}
-exports.isExploreProperty = isExploreProperty;
-class ExploreDesc extends ListOf {
-    constructor(props) {
-        super("exploreDesc", props);
-    }
-}
-exports.ExploreDesc = ExploreDesc;
-class FilterElement extends MalloyElement {
-    constructor(expr, exprSrc) {
-        super({ expr });
-        this.expr = expr;
-        this.exprSrc = exprSrc;
-        this.elementType = "filterElement";
-    }
-    filterExpression(fs) {
-        const exprVal = this.expr.getExpression(fs);
-        if (exprVal.dataType !== "boolean") {
-            this.expr.log("Filter expression must have boolean value");
-            return {
-                code: this.exprSrc,
-                expression: ["_FILTER_MUST_RETURN_BOOLEAN_"],
-                expressionType: "scalar",
-            };
-        }
-        const exprCond = {
-            code: this.exprSrc,
-            expression: (0, ast_types_1.compressExpr)(exprVal.value),
-            expressionType: exprVal.expressionType,
-        };
-        return exprCond;
-    }
-}
-exports.FilterElement = FilterElement;
-class Filter extends ListOf {
-    constructor(elements = []) {
-        super("filterElements", elements);
-        this.elementType = "filter";
-    }
-    set having(isHaving) {
-        this.elementType = isHaving ? "having" : "where";
-    }
-    getFilterList(fs) {
-        const checked = [];
-        for (const oneElement of this.list) {
-            const fExpr = oneElement.filterExpression(fs);
-            // Aggregates are ALSO checked at SQL generation time, but checking
-            // here allows better reflection of errors back to user.
-            if (this.havingClause !== undefined) {
-                if (this.havingClause) {
-                    if (model.expressionIsCalculation(fExpr.expressionType)) {
-                        oneElement.log("Aggregate or Analytical expression expected in HAVING filter");
-                        continue;
-                    }
-                }
-                else {
-                    if (fExpr.expressionType !== "scalar") {
-                        oneElement.log("Aggregate or Analytical expressions not allowed in WHERE");
-                        continue;
-                    }
-                }
-            }
-            checked.push(fExpr);
-        }
-        return checked;
-    }
-}
-exports.Filter = Filter;
-class DeclareFields extends ListOf {
-    constructor(fields, fieldType = "declare") {
-        super(fieldType, fields);
-    }
-}
-exports.DeclareFields = DeclareFields;
-class Measures extends DeclareFields {
-    constructor(measures) {
-        super(measures, "measure");
-        for (const dim of measures) {
-            dim.isMeasure = true;
-        }
-    }
-}
-exports.Measures = Measures;
-class Dimensions extends DeclareFields {
-    constructor(dimensions) {
-        super(dimensions, "dimension");
-        for (const dim of dimensions) {
-            dim.isMeasure = false;
-        }
-    }
-}
-exports.Dimensions = Dimensions;
-class Renames extends ListOf {
-    constructor(renames) {
-        super("renameField", renames);
-    }
-}
-exports.Renames = Renames;
-class FieldName extends MalloyElement {
-    constructor(name) {
-        super();
-        this.name = name;
-        this.elementType = "fieldName";
-    }
-    get refString() {
-        return this.name;
-    }
-    toString() {
-        return this.refString;
-    }
-    getField(fs) {
-        return fs.lookup([this]);
-    }
-}
-exports.FieldName = FieldName;
-class FieldReference extends ListOf {
-    constructor(names) {
-        super("fieldReference", names);
-        this.elementType = "fieldReference";
-    }
-    get refString() {
-        return this.list.map((n) => n.refString).join(".");
-    }
-    get outputName() {
-        const last = this.list[this.list.length - 1];
-        return last.refString;
-    }
-    get sourceString() {
-        if (this.list.length > 1) {
-            return this.list
-                .slice(0, -1)
-                .map((n) => n.refString)
-                .join(".");
-        }
-        return undefined;
-    }
-    get nameString() {
-        return this.list[this.list.length - 1].refString;
-    }
-    getField(fs) {
-        return fs.lookup(this.list);
-    }
-}
-exports.FieldReference = FieldReference;
-class FieldReferences extends ListOf {
-    constructor(members) {
-        super("fieldReferenceList", members);
-    }
-}
-exports.FieldReferences = FieldReferences;
-function isFieldCollectionMember(el) {
-    return (el instanceof FieldReference ||
-        el instanceof WildcardFieldReference ||
-        el instanceof FieldDeclaration);
-}
-exports.isFieldCollectionMember = isFieldCollectionMember;
-class ProjectStatement extends ListOf {
-    constructor(members) {
-        super("fieldCollection", members);
-    }
-}
-exports.ProjectStatement = ProjectStatement;
-class FieldListEdit extends MalloyElement {
-    constructor(edit, refs) {
-        super({ refs });
-        this.edit = edit;
-        this.refs = refs;
-        this.elementType = "fieldListEdit";
-    }
-}
-exports.FieldListEdit = FieldListEdit;
-class GroupBy extends ListOf {
-    constructor(members) {
-        super("groupBy", members);
-        for (const el of members) {
-            if (el instanceof FieldDeclaration) {
-                el.isMeasure = false;
-            }
-        }
-    }
-}
-exports.GroupBy = GroupBy;
-class Aggregate extends ListOf {
-    constructor(members) {
-        super("aggregate", members);
-        for (const el of members) {
-            if (el instanceof FieldDeclaration) {
-                el.isMeasure = true;
-            }
-        }
-    }
-}
-exports.Aggregate = Aggregate;
-class ReduceExecutor {
-    constructor(baseFS) {
-        this.filters = [];
-        this.resultFS = this.getResultSpace(baseFS);
-        this.inputFS = this.resultFS.exprSpace;
-    }
-    getResultSpace(fs) {
-        return new ReduceFieldSpace(fs);
-    }
-    execute(qp) {
-        if (qp instanceof GroupBy ||
-            qp instanceof Aggregate ||
-            qp instanceof Nests) {
-            this.resultFS.addQueryItems(...qp.list);
-        }
-        else if (isNestedQuery(qp)) {
-            this.resultFS.addQueryItems(qp);
-        }
-        else if (qp instanceof Filter) {
-            this.filters.push(...qp.getFilterList(this.inputFS));
-        }
-        else if (qp instanceof Top) {
-            if (this.limit) {
-                qp.log("Query operation already limited");
-            }
-            else {
-                this.limit = qp.limit;
-            }
-            if (qp.by) {
-                if (this.order) {
-                    qp.log("Query operation is already sorted");
-                }
-                else {
-                    this.order = qp;
-                }
-            }
-        }
-        else if (qp instanceof Limit) {
-            if (this.limit) {
-                qp.log("Query operation already limited");
-            }
-            else {
-                this.limit = qp.limit;
-            }
-        }
-        else if (qp instanceof Ordering) {
-            if (this.order) {
-                qp.log("Query operation already sorted");
-            }
-            else {
-                this.order = qp;
-            }
-        }
-        else if (qp instanceof Joins || qp instanceof DeclareFields) {
-            for (const qel of qp.list) {
-                this.inputFS.extendSource(qel);
-            }
-        }
-    }
-    refineFrom(from, to) {
-        if (from && from.type !== "index") {
-            if (!this.order) {
-                if (from.orderBy) {
-                    to.orderBy = from.orderBy;
-                }
-                else if (from.by) {
-                    to.by = from.by;
-                }
-            }
-            if (!this.limit && from.limit) {
-                to.limit = from.limit;
-            }
-        }
-        if (this.limit) {
-            to.limit = this.limit;
-        }
-        if (this.order instanceof Top) {
-            const topBy = this.order.getBy(this.inputFS);
-            if (topBy) {
-                to.by = topBy;
-            }
-        }
-        if (this.order instanceof Ordering) {
-            to.orderBy = this.order.getOrderBy(this.inputFS);
-        }
-        const oldFilters = (from === null || from === void 0 ? void 0 : from.filterList) || [];
-        if (this.filters.length > 0 && !oldFilters) {
-            to.filterList = this.filters;
-        }
-        else if (oldFilters) {
-            to.filterList = [...oldFilters, ...this.filters];
-        }
-    }
-    finalize(fromSeg) {
-        let from;
-        if (fromSeg) {
-            if (model.isReduceSegment(fromSeg)) {
-                from = fromSeg;
-            }
-            else {
-                this.inputFS.result.log(`Can't refine reduce with ${fromSeg.type}`);
-                return ErrorFactory.reduceSegment;
-            }
-        }
-        const reduceSegment = this.resultFS.getQuerySegment(from);
-        this.refineFrom(from, reduceSegment);
-        return reduceSegment;
-    }
-}
-class ProjectExecutor extends ReduceExecutor {
-    getResultSpace(fs) {
-        return new ProjectFieldSpace(fs);
-    }
-    execute(qp) {
-        if (qp instanceof ProjectStatement) {
-            this.resultFS.addMembers(qp.list);
-        }
-        else if ((qp instanceof Filter && qp.elementType === "having") ||
-            qp instanceof Measures ||
-            qp instanceof GroupBy) {
-            qp.log("Illegal statement in a project query operation");
-        }
-        else {
-            super.execute(qp);
-        }
-    }
-    finalize(fromSeg) {
-        let from;
-        if (fromSeg) {
-            if (model.isProjectSegment(fromSeg)) {
-                from = fromSeg;
-            }
-            else {
-                this.resultFS.log(`Can't refine project with ${fromSeg.type}`);
-                return ErrorFactory.projectSegment;
-            }
-        }
-        const projectSegment = this.resultFS.getQuerySegment(from);
-        this.refineFrom(from, projectSegment);
-        return projectSegment;
-    }
-}
-class IndexExecutor {
-    constructor(inputFS) {
-        this.filters = [];
-        this.resultFS = new IndexFieldSpace(inputFS);
-        this.inputFS = this.resultFS.exprSpace;
-    }
-    execute(qp) {
-        if (qp instanceof Filter) {
-            this.filters.push(...qp.getFilterList(this.inputFS));
-        }
-        else if (qp instanceof Limit) {
-            if (this.limit) {
-                this.limit.log("Ignored, too many limit: statements");
-            }
-            this.limit = qp;
-        }
-        else if (qp instanceof Index) {
-            this.resultFS.addMembers(qp.fields.list);
-            if (qp.weightBy) {
-                if (this.indexOn) {
-                    this.indexOn.log("Ignoring previous BY");
-                }
-                this.indexOn = qp.weightBy;
-            }
-        }
-        else if (qp instanceof SampleProperty) {
-            this.sample = qp.sampling();
-        }
-        else {
-            qp.log("Not legal in an index query operation");
-        }
-    }
-    finalize(from) {
-        if (from && from.type !== "index") {
-            this.resultFS.log(`Can't refine index with ${from.type}`);
-            return ErrorFactory.indexSegment;
-        }
-        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;
-        }
-        else if (oldFilters) {
-            indexSegment.filterList = [...oldFilters, ...this.filters];
-        }
-        if (from === null || from === void 0 ? void 0 : from.limit) {
-            indexSegment.limit = from.limit;
-        }
-        if (this.limit) {
-            indexSegment.limit = this.limit.limit;
-        }
-        if (this.indexOn) {
-            indexSegment.weightMeasure = this.indexOn.refString;
-        }
-        if (from === null || from === void 0 ? void 0 : from.sample) {
-            indexSegment.sample = from.sample;
-        }
-        if (this.sample) {
-            indexSegment.sample = this.sample;
-        }
-        return indexSegment;
-    }
-}
-class QOPDesc extends ListOf {
-    constructor(props) {
-        super("queryOperator", props);
-        this.opType = "grouping";
-    }
-    computeType() {
-        let firstGuess;
-        if (this.refineThis) {
-            if (this.refineThis.type == "reduce") {
-                firstGuess = "grouping";
-            }
-            else {
-                firstGuess = this.refineThis.type;
-            }
-        }
-        let anyGrouping = false;
-        for (const el of this.list) {
-            if (el instanceof Index) {
-                firstGuess || (firstGuess = "index");
-                if (firstGuess !== "index") {
-                    el.log(`index: not legal in ${firstGuess} query`);
-                }
-            }
-            else if (el instanceof Nests ||
-                isNestedQuery(el) ||
-                el instanceof GroupBy) {
-                firstGuess || (firstGuess = "grouping");
-                anyGrouping = true;
-                if (firstGuess === "project" || firstGuess === "index") {
-                    el.log(`group_by: not legal in ${firstGuess} query`);
-                }
-            }
-            else if (el instanceof Aggregate) {
-                firstGuess || (firstGuess = "aggregate");
-                if (firstGuess === "project" || firstGuess === "index") {
-                    el.log(`aggregate: not legal in ${firstGuess} query`);
-                }
-            }
-            else if (el instanceof ProjectStatement) {
-                firstGuess || (firstGuess = "project");
-                if (firstGuess !== "project") {
-                    el.log(`project: not legal in ${firstGuess} query`);
-                }
-            }
-        }
-        if (firstGuess === "aggregate" && anyGrouping) {
-            firstGuess = "grouping";
-        }
-        if (!firstGuess) {
-            this.log("Can't determine query type (group_by/aggregate/nest,project,index)");
-        }
-        const guessType = firstGuess || "grouping";
-        this.opType = guessType;
-        return guessType;
-    }
-    refineFrom(existing) {
-        this.refineThis = existing;
-    }
-    getExecutor(baseFS) {
-        switch (this.computeType()) {
-            case "aggregate":
-            case "grouping":
-                return new ReduceExecutor(baseFS);
-            case "project":
-                return new ProjectExecutor(baseFS);
-            case "index":
-                return new IndexExecutor(baseFS);
-        }
-    }
-    getOp(inputFS, forPipeline) {
-        const qex = this.getExecutor(inputFS);
-        if (forPipeline === null || forPipeline === void 0 ? void 0 : forPipeline.nestedInQuerySpace) {
-            qex.inputFS.nestParent = forPipeline.nestedInQuerySpace;
-        }
-        qex.resultFS.astEl = this;
-        for (const qp of this.list) {
-            qex.execute(qp);
-        }
-        const segment = qex.finalize(this.refineThis);
-        return {
-            segment,
-            outputSpace: () => new DynamicSpace(opOutputStruct(this, inputFS.structDef(), segment)),
-        };
-    }
-}
-exports.QOPDesc = QOPDesc;
-/**
- * The Document class is a little weird because we might need to bounce back
- * to the requestor, which might be on the other side of a wire, to get
- * back some schema information. The intended translation of a Document
- * is to call initModelDef(), and then to call modelDataRequest() until it
- * returns undefined. At any time you can call modelDef to get the model
- * as it exists so far, but the translation is not complete until
- * modelDataRequest() returns undefined;
- *
- * TODO probably modelRequest should be the method and you call it
- * until it returns a model with no additional data needed ...
- * that can be tomorrow
- */
-class Document extends MalloyElement {
-    constructor(statements) {
-        super();
-        this.elementType = "document";
-        this.documentModel = {};
-        this.queryList = [];
-        this.sqlBlocks = [];
-        this.didInitModel = false;
-        this.statements = new RunList("topLevelStatements", statements);
-        this.has({ statements });
-    }
-    initModelDef(extendingModelDef) {
-        if (this.didInitModel) {
-            return;
-        }
-        this.documentModel = {};
-        this.queryList = [];
-        this.sqlBlocks = [];
-        if (extendingModelDef) {
-            for (const inName in extendingModelDef.contents) {
-                const struct = extendingModelDef.contents[inName];
-                if (struct.type == "struct") {
-                    const exported = extendingModelDef.exports.includes(inName);
-                    this.setEntry(inName, { entry: struct, exported });
-                }
-            }
-        }
-        this.didInitModel = true;
-    }
-    compile() {
-        const needs = this.statements.executeList(this);
-        const ret = {
-            modelDef: this.modelDef(),
-            queryList: this.queryList,
-            sqlBlocks: this.sqlBlocks,
-            needs,
-        };
-        return ret;
-    }
-    modelDef() {
-        const def = { name: "", exports: [], contents: {} };
-        for (const entry in this.documentModel) {
-            const entryDef = this.documentModel[entry].entry;
-            if (entryDef.type === "struct" || entryDef.type === "query") {
-                if (this.documentModel[entry].exported) {
-                    def.exports.push(entry);
-                }
-                def.contents[entry] = (0, lodash_1.cloneDeep)(entryDef);
-            }
-        }
-        return def;
-    }
-    defineSQL(sql, name) {
-        const ret = { ...sql, as: `$${this.sqlBlocks.length}` };
-        if (name) {
-            if (this.getEntry(name)) {
-                return false;
-            }
-            ret.as = name;
-            this.setEntry(name, { entry: ret, sqlType: true });
-        }
-        this.sqlBlocks.push(ret);
-        return true;
-    }
-    getEntry(str) {
-        return this.documentModel[str];
-    }
-    setEntry(str, ent) {
-        this.documentModel[str] = ent;
-    }
-}
-exports.Document = Document;
-class PrimaryKey extends MalloyElement {
-    constructor(field) {
-        super({ field });
-        this.field = field;
-        this.elementType = "primary key";
-    }
-}
-exports.PrimaryKey = PrimaryKey;
-class RenameField extends MalloyElement {
-    constructor(newName, oldName) {
-        super();
-        this.newName = newName;
-        this.oldName = oldName;
-        this.elementType = "renameField";
-        this.has({ oldName });
-    }
-}
-exports.RenameField = RenameField;
-class WildcardFieldReference extends MalloyElement {
-    constructor(joinPath, star) {
-        super();
-        this.joinPath = joinPath;
-        this.star = star;
-        this.elementType = "wildcardFieldReference";
-        this.has({ joinPath });
-    }
-    getFieldDef() {
-        throw this.internalError("fielddef request from wildcard reference");
-    }
-    get refString() {
-        return this.joinPath
-            ? `${this.joinPath.refString}.${this.star}`
-            : this.star;
-    }
-}
-exports.WildcardFieldReference = WildcardFieldReference;
-class OrderBy extends MalloyElement {
-    constructor(field, dir) {
-        super();
-        this.field = field;
-        this.dir = dir;
-        this.elementType = "orderBy";
-        if (field instanceof FieldName) {
-            this.has({ field });
-        }
-    }
-    get modelField() {
-        return typeof this.field === "number" ? this.field : this.field.refString;
-    }
-    getOrderBy(_fs) {
-        // TODO jump-to-definition `fs` cannot currently `lookup` fields in the output space
-        // if (this.field instanceof FieldName) {
-        //   const entry = this.field.getField(_fs);
-        //   if (entry.error) {
-        //     this.field.log(entry.error);
-        //   }
-        // }
-        const orderElement = { field: this.modelField };
-        if (this.dir) {
-            orderElement.dir = this.dir;
-        }
-        return orderElement;
-    }
-}
-exports.OrderBy = OrderBy;
-class Ordering extends ListOf {
-    constructor(list) {
-        super("ordering", list);
-    }
-    getOrderBy(fs) {
-        return this.list.map((el) => el.getOrderBy(fs));
-    }
-}
-exports.Ordering = Ordering;
-class Limit extends MalloyElement {
-    constructor(limit) {
-        super();
-        this.limit = limit;
-        this.elementType = "limit";
-    }
-}
-exports.Limit = Limit;
-class Turtles extends ListOf {
-    constructor(turtles) {
-        super("turtleDeclarationList", turtles);
-    }
-}
-exports.Turtles = Turtles;
-class Index extends MalloyElement {
-    constructor(fields) {
-        super({ fields });
-        this.fields = fields;
-        this.elementType = "index";
-    }
-    useWeight(fn) {
-        this.has({ weightBy: fn });
-        this.weightBy = fn;
-    }
-}
-exports.Index = Index;
-function isTurtle(fd) {
-    const ret = fd && typeof fd !== "string" && fd.type === "turtle";
-    return !!ret;
-}
-/**
- * Generic abstract for all pipelines, the first segment might be a reference
- * to an existing pipeline (query or turtle), and if there is a refinement it
- * is refers to the first segment of the composed pipeline.
- */
-class PipelineDesc extends MalloyElement {
-    constructor() {
-        super(...arguments);
-        this.elementType = "pipelineDesc";
-        this.qops = [];
-    }
-    refineHead(refinement) {
-        this.headRefinement = refinement;
-        this.has({ headRefinement: refinement });
-    }
-    addSegments(...segDesc) {
-        this.qops.push(...segDesc);
-        this.has({ segments: this.qops });
-    }
-    appendOps(modelPipe, existingEndSpace) {
-        let nextFS = existingEndSpace;
-        let returnPipe;
-        for (const qop of this.qops) {
-            const qopIsNested = modelPipe.length == 0;
-            const next = qop.getOp(nextFS, qopIsNested ? this : null);
-            if (returnPipe == undefined) {
-                returnPipe = [...modelPipe];
-            }
-            returnPipe.push(next.segment);
-            nextFS = next.outputSpace();
-        }
-        return {
-            opList: returnPipe || modelPipe,
-            structDef: nextFS.structDef(),
-        };
-    }
-    refinePipeline(fs, modelPipe) {
-        if (!this.headRefinement) {
-            return modelPipe;
-        }
-        const pipeline = [];
-        if (modelPipe.pipeHead) {
-            const { pipeline: turtlePipe } = this.expandTurtle(modelPipe.pipeHead.name, fs.structDef());
-            pipeline.push(...turtlePipe);
-        }
-        pipeline.push(...modelPipe.pipeline);
-        const firstSeg = pipeline[0];
-        if (firstSeg) {
-            this.headRefinement.refineFrom(firstSeg);
-        }
-        pipeline[0] = this.headRefinement.getOp(fs, this).segment;
-        return { pipeline };
-    }
-    expandTurtle(turtleName, fromStruct) {
-        const turtle = getStructFieldDef(fromStruct, turtleName);
-        if (!turtle) {
-            this.log(`Query '${turtleName}' is not defined in source`);
-        }
-        else if (turtle.type !== "turtle") {
-            this.log(`'${turtleName}' is not a query`);
-        }
-        else {
-            return { pipeline: turtle.pipeline, location: turtle.location };
-        }
-        return { pipeline: [], location: undefined };
-    }
-    getOutputStruct(walkStruct, pipeline) {
-        for (const modelQop of pipeline) {
-            walkStruct = opOutputStruct(this, walkStruct, modelQop);
-        }
-        return walkStruct;
-    }
-}
-class ExistingQuery extends PipelineDesc {
-    set head(head) {
-        this._head = head;
-        this.has({ head });
-    }
-    get head() {
-        return this._head;
-    }
-    queryComp() {
-        if (!this.head) {
-            throw this.internalError("can't make query from nameless query");
-        }
-        const queryEntry = this.modelEntry(this.head);
-        const seedQuery = queryEntry === null || queryEntry === void 0 ? void 0 : queryEntry.entry;
-        const oops = function () {
-            return {
-                outputStruct: ErrorFactory.structDef,
-                query: ErrorFactory.query,
-            };
-        };
-        if (!seedQuery) {
-            this.log(`Reference to undefined query '${this.head}'`);
-            return oops();
-        }
-        if (seedQuery.type !== "query") {
-            this.log(`Illegal reference to '${this.head}', query expected`);
-            return oops();
-        }
-        const queryHead = new QueryHeadStruct(seedQuery.structRef);
-        this.has({ queryHead });
-        const exploreStruct = queryHead.structDef();
-        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 DynamicSpace(walkStruct));
-        const destPipe = { ...sourcePipe, pipeline: appended.opList };
-        const query = {
-            type: "query",
-            ...destPipe,
-            structRef: queryHead.structRef(),
-            location: this.location,
-        };
-        return { outputStruct: appended.structDef, query };
-    }
-    query() {
-        return this.queryComp().query;
-    }
-}
-exports.ExistingQuery = ExistingQuery;
-class TurtleHeadedPipe extends PipelineDesc {
-    set turtleName(turtleName) {
-        this._turtleName = turtleName;
-        this.has({ turtleName });
-    }
-    get turtleName() {
-        return this._turtleName;
-    }
-}
-exports.TurtleHeadedPipe = TurtleHeadedPipe;
-class FullQuery extends TurtleHeadedPipe {
-    constructor(explore) {
-        super({ explore });
-        this.explore = explore;
-    }
-    queryComp() {
-        const structRef = this.explore.structRef();
-        const destQuery = {
-            type: "query",
-            structRef,
-            pipeline: [],
-            location: this.location,
-        };
-        const structDef = model.refIsStructDef(structRef)
-            ? structRef
-            : this.explore.structDef();
-        let pipeFs = new DynamicSpace(structDef);
-        if (ErrorFactory.isErrorStructDef(structDef)) {
-            return {
-                outputStruct: structDef,
-                query: {
-                    structRef: structRef,
-                    pipeline: [],
-                },
-            };
-        }
-        if (this.turtleName) {
-            const { error } = this.turtleName.getField(pipeFs);
-            if (error)
-                this.log(error);
-            const name = this.turtleName.refString;
-            const { pipeline, location } = this.expandTurtle(name, structDef);
-            destQuery.location = location;
-            const refined = this.refinePipeline(pipeFs, { pipeline }).pipeline;
-            if (this.headRefinement) {
-                // TODO there is an issue with losing the name of the turtle
-                // which we need to fix, possibly adding a "name:" field to a segment
-                // TODO there was mention of promoting filters to the query
-                destQuery.pipeline = refined;
-            }
-            else {
-                destQuery.pipeHead = { name };
-            }
-            const pipeStruct = this.getOutputStruct(structDef, refined);
-            pipeFs = new DynamicSpace(pipeStruct);
-        }
-        const appended = this.appendOps(destQuery.pipeline, pipeFs);
-        destQuery.pipeline = appended.opList;
-        return { outputStruct: appended.structDef, query: destQuery };
-    }
-    query() {
-        return this.queryComp().query;
-    }
-}
-exports.FullQuery = FullQuery;
-class TurtleDecl extends TurtleHeadedPipe {
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    getPipeline(fs) {
-        const modelPipe = { pipeline: [] };
-        if (this.turtleName) {
-            const headEnt = this.turtleName.getField(fs);
-            let reportWrongType = true;
-            if (headEnt.error) {
-                this.log(headEnt.error);
-                reportWrongType = false;
-            }
-            else if (headEnt.found instanceof QueryField) {
-                const headDef = headEnt.found.getQueryFieldDef(fs);
-                if (isTurtle(headDef)) {
-                    const newPipe = this.refinePipeline(fs, headDef);
-                    modelPipe.pipeline = [...newPipe.pipeline];
-                    reportWrongType = false;
-                }
-            }
-            if (reportWrongType) {
-                this.log(`Expected '${this.turtleName}' to be a query`);
-            }
-        }
-        else if (this.headRefinement) {
-            throw this.internalError("Can't refine the head of a turtle in its definition");
-        }
-        let appendInput = fs;
-        if (modelPipe.pipeline.length > 0) {
-            let endStruct = appendInput.structDef();
-            for (const existingSeg of modelPipe.pipeline) {
-                endStruct = opOutputStruct(this, endStruct, existingSeg);
-            }
-            appendInput = new DynamicSpace(endStruct);
-        }
-        const appended = this.appendOps(modelPipe.pipeline, appendInput);
-        modelPipe.pipeline = appended.opList;
-        return modelPipe;
-    }
-    getFieldDef(fs, nestParent) {
-        if (nestParent) {
-            this.nestedInQuerySpace = nestParent;
-        }
-        const pipe = this.getPipeline(fs);
-        return {
-            type: "turtle",
-            name: this.name,
-            ...pipe,
-            location: this.location,
-        };
-    }
-}
-exports.TurtleDecl = TurtleDecl;
-class NestReference extends FieldReference {
-    constructor(name) {
-        super([name]);
-        this.name = name;
-        this.elementType = "nestReference";
-    }
-}
-exports.NestReference = NestReference;
-class NestRefinement extends TurtleDecl {
-    constructor(turtleName) {
-        super(turtleName.refString);
-        this.elementType = "nestRefinement";
-        this.turtleName = turtleName;
-    }
-}
-exports.NestRefinement = NestRefinement;
-class NestDefinition extends TurtleDecl {
-    constructor(name) {
-        super(name);
-        this.elementType = "nestDefinition";
-    }
-}
-exports.NestDefinition = NestDefinition;
-function isNestedQuery(me) {
-    return (me instanceof NestRefinement ||
-        me instanceof NestReference ||
-        me instanceof NestDefinition);
-}
-exports.isNestedQuery = isNestedQuery;
-class Nests extends ListOf {
-    constructor(nests) {
-        super("nestedQueries", nests);
-    }
-}
-exports.Nests = Nests;
-function isQueryElement(e) {
-    return e instanceof FullQuery || e instanceof ExistingQuery;
-}
-exports.isQueryElement = isQueryElement;
-class DefineQueryList extends RunList {
-    constructor(queryList) {
-        super("defineQueries", queryList);
-    }
-    execute(doc) {
-        return this.executeList(doc);
-    }
-}
-exports.DefineQueryList = DefineQueryList;
-class DefineQuery extends MalloyElement {
-    constructor(name, queryDetails) {
-        super({ queryDetails });
-        this.name = name;
-        this.queryDetails = queryDetails;
-        this.elementType = "defineQuery";
-    }
-    execute(doc) {
-        const entry = {
-            ...this.queryDetails.query(),
-            type: "query",
-            name: this.name,
-            location: this.location,
-        };
-        const exported = false;
-        doc.setEntry(this.name, { entry, exported });
-        return undefined;
-    }
-}
-exports.DefineQuery = DefineQuery;
-class AnonymousQuery extends MalloyElement {
-    constructor(theQuery) {
-        super();
-        this.theQuery = theQuery;
-        this.elementType = "anonymousQuery";
-        this.has({ query: theQuery });
-    }
-    execute(doc) {
-        const modelQuery = this.theQuery.query();
-        doc.queryList.push(modelQuery);
-        return undefined;
-    }
-}
-exports.AnonymousQuery = AnonymousQuery;
-class Top extends MalloyElement {
-    constructor(limit, by) {
-        super();
-        this.limit = limit;
-        this.by = by;
-        this.elementType = "top";
-        this.has({ by });
-    }
-    getBy(fs) {
-        if (this.by) {
-            if (this.by instanceof FieldName) {
-                // TODO jump-to-definition `fs` cannot currently `lookup` fields in the output space
-                // const entry = this.by.getField(fs);
-                // if (entry.error) {
-                //   this.by.log(entry.error);
-                // }
-                return { by: "name", name: this.by.refString };
-            }
-            else {
-                const byExpr = this.by.getExpression(fs);
-                if (model.expressionIsAggregate(byExpr.expressionType)) {
-                    this.log("top by expression must be an aggregate");
-                }
-                return { by: "expression", e: (0, ast_types_1.compressExpr)(byExpr.value) };
-            }
-        }
-        return undefined;
-    }
-}
-exports.Top = Top;
-class JSONElement extends MalloyElement {
-    constructor(jsonSrc) {
-        super();
-        this.elementType = "jsonElement";
-        try {
-            this.value = JSON.parse(jsonSrc);
-        }
-        catch (SyntaxError) {
-            this.log("JSON syntax error");
-            this.value = undefined;
-        }
-    }
-}
-exports.JSONElement = JSONElement;
-class JSONStructDef extends Mallobj {
-    constructor(struct) {
-        super();
-        this.struct = struct;
-        this.elementType = "jsonStructDef";
-    }
-    static fromJSON(jsonObj) {
-        const obj = jsonObj.value;
-        if (obj &&
-            obj.type === "struct" &&
-            obj.structRelationship &&
-            obj.structSource) {
-            return new JSONStructDef(obj);
-        }
-        return undefined;
-    }
-    structDef() {
-        return this.struct;
-    }
-}
-exports.JSONStructDef = JSONStructDef;
-class ImportStatement extends MalloyElement {
-    /*
-     * At the time of writng this comment, it is guaranteed that if an AST
-     * node for an import statement is created, the translator has already
-     * succesfully fetched the URL referred to in the statement.
-     *
-     * Error checking code in here is future proofing against a day when
-     * there are other ways to contruct an AST.
-     */
-    constructor(url, baseURL) {
-        super();
-        this.url = url;
-        this.elementType = "import statement";
-        try {
-            this.fullURL = decodeURI(new URL(url, baseURL).toString());
-        }
-        catch (e) {
-            this.log("Invalid URI in import statement");
-        }
-    }
-    execute(doc) {
-        const trans = this.translator();
-        if (!trans) {
-            this.log("Cannot import without translation context");
-        }
-        else if (this.fullURL) {
-            const src = trans.root.importZone.getEntry(this.fullURL);
-            if (src.status === "present") {
-                const childNeeds = trans.childRequest(this.fullURL);
-                if (childNeeds) {
-                    return childNeeds;
-                }
-                const importStructs = trans.getChildExports(this.fullURL);
-                for (const importing in importStructs) {
-                    doc.setEntry(importing, {
-                        entry: importStructs[importing],
-                        exported: false,
-                    });
-                }
-            }
-            else if (src.status === "error") {
-                this.log(`import failed: '${src.message}'`);
-            }
-            else {
-                this.log(`import failed with status: '${src.status}'`);
-            }
-        }
-        return undefined;
-    }
-}
-exports.ImportStatement = ImportStatement;
-class HasParameter extends MalloyElement {
-    constructor(init) {
-        super();
-        this.elementType = "hasParameter";
-        this.name = init.name;
-        this.isCondition = init.isCondition;
-        if (init.type && model.isAtomicFieldType(init.type)) {
-            this.type = init.type;
-        }
-        if (init.default) {
-            this.default = init.default;
-            this.has({ default: this.default });
-        }
-    }
-    parameter() {
-        var _a, _b;
-        const name = this.name;
-        const type = this.type || "string";
-        if (this.isCondition) {
-            const cCond = ((_a = this.default) === null || _a === void 0 ? void 0 : _a.constantCondition(type).value) || null;
-            return {
-                type,
-                name,
-                condition: cCond,
-            };
-        }
-        const cVal = ((_b = this.default) === null || _b === void 0 ? void 0 : _b.constantValue().value) || null;
-        return {
-            value: cVal,
-            type,
-            name: this.name,
-            constant: false,
-        };
-    }
-}
-exports.HasParameter = HasParameter;
-class ConstantParameter extends HasParameter {
-    constructor(name, value) {
-        super({ name, isCondition: false });
-        this.value = value;
-        this.has({ value });
-    }
-    parameter() {
-        const cVal = this.value.constantValue();
-        if (!model.isAtomicFieldType(cVal.dataType)) {
-            this.log(`Unexpected expression type '${cVal.dataType}'`);
-            return {
-                value: ["XXX-type-mismatch-error-XXX"],
-                type: "string",
-                name: this.name,
-                constant: true,
-            };
-        }
-        return {
-            value: cVal.value,
-            type: cVal.dataType,
-            name: this.name,
-            constant: true,
-        };
-    }
-}
-exports.ConstantParameter = ConstantParameter;
-class SQLString extends MalloyElement {
-    constructor() {
-        super(...arguments);
-        this.elementType = "sqlString";
-        this.elements = [];
-        this.containsQueries = false;
-    }
-    push(el) {
-        if (typeof el == "string") {
-            if (el.length > 0) {
-                this.elements.push(el);
-            }
-        }
-        else if (isQueryElement(el)) {
-            this.elements.push(el);
-            this.containsQueries = true;
-            el.parent = this;
-        }
-        else {
-            el.log("This element is not legal inside an SQL string");
-        }
-    }
-    sqlPhrases() {
-        return this.elements.map((el) => {
-            if (typeof el == "string") {
-                return { sql: el };
-            }
-            return el.query();
-        });
-    }
-}
-exports.SQLString = SQLString;
-class SQLStatement extends MalloyElement {
-    constructor(select) {
-        super();
-        this.select = select;
-        this.elementType = "sqlStatement";
-        this.has({ select });
-    }
-    sqlBlock() {
-        if (!this.requestBlock) {
-            this.requestBlock = (0, sql_block_1.makeSQLBlock)(this.select.sqlPhrases(), this.connection);
-        }
-        return this.requestBlock;
-    }
-    /**
-     * This is the one statement which pauses execution. First time through
-     * it will generate a schema request, next time through it will either
-     * record the error or record the schema.
-     */
-    execute(doc) {
-        var _a;
-        const sqlDefEntry = (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.sqlQueryZone;
-        if (!sqlDefEntry) {
-            this.log("Cant't look up schema for sql block");
-            return;
-        }
-        const sql = this.sqlBlock();
-        sqlDefEntry.reference(sql.name, this.location);
-        const lookup = sqlDefEntry.getEntry(sql.name);
-        if (lookup.status == "error") {
-            const msgLines = lookup.message.split(/\r?\n/);
-            this.select.log("Invalid SQL, " + msgLines.join("\n    "));
-            return undefined;
-        }
-        if (lookup.status == "present") {
-            const location = this.select.location;
-            const locStruct = {
-                ...lookup.value,
-                fields: lookup.value.fields.map((f) => ({ ...f, location })),
-                location: this.location,
-            };
-            if (this.is && !doc.defineSQL(locStruct, this.is)) {
-                this.log(`'${this.is}' already defined`);
-            }
-            return undefined;
-        }
-        return {
-            compileSQL: sql,
-            partialModel: this.select.containsQueries ? doc.modelDef() : undefined,
-        };
-    }
-}
-exports.SQLStatement = SQLStatement;
-class SampleProperty extends MalloyElement {
-    constructor(sample) {
-        super();
-        this.sample = sample;
-        this.elementType = "sampleProperty";
-    }
-    sampling() {
-        return this.sample;
-    }
-}
-exports.SampleProperty = SampleProperty;
-/**
- * Root node for any element in an expression. These essentially
- * create a sub-tree in the larger AST. Expression nodes know
- * how to write themselves as SQL (or rather, generate the
- * template for SQL required by the query writer)
- */
-class ExpressionDef extends MalloyElement {
-    constructor() {
-        super(...arguments);
-        this.legalChildTypes = ast_types_1.FT.anyAtomicT;
-    }
-    granular() {
-        return false;
-    }
-    /**
-     * Some operators want to give the right hand value a chance to
-     * rewrite itself. This requests a translation for a rewrite,
-     * or returns undefined if that request should be denied.
-     * @param fs FieldSpace
-     * @returns Translated expression or undefined
-     */
-    requestExpression(fs) {
-        return this.getExpression(fs);
-    }
-    defaultFieldName() {
-        return undefined;
-    }
-    /**
-     * Check an expression for type compatibility
-     * @param _eNode currently unused, will be used to get error location
-     * @param eVal ...list of expressions that must match legalChildTypes
-     */
-    typeCheck(eNode, eVal) {
-        if (!ast_types_1.FT.in(eVal, this.legalChildTypes)) {
-            eNode.log(`'${this.elementType}' Can't use type ${ast_types_1.FT.inspect(eVal)}`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * This is the operation which makes partial comparison and value trees work
-     * The default implemention merely constructs LEFT OP RIGHT, but specialized
-     * nodes like alternation trees or or partial comparison can control how
-     * the appplication gets generated
-     * @param fs The symbol table
-     * @param op The operator being applied
-     * @param expr The "other" (besdies 'this') value
-     * @returns The translated expression
-     */
-    apply(fs, op, left) {
-        return applyBinary(fs, left, op, this);
-    }
-}
-exports.ExpressionDef = ExpressionDef;
-class ConstantSubExpression extends ExpressionDef {
-    constructor(expr) {
-        super({ expr });
-        this.expr = expr;
-        this.elementType = "constantExpression";
-    }
-    getExpression(_fs) {
-        return this.constantValue();
-    }
-    get constantFs() {
-        if (!this.cfs) {
-            this.cfs = new ConstantFieldSpace();
-        }
-        return this.cfs;
-    }
-    constantValue() {
-        return this.expr.getExpression(this.constantFs);
-    }
-    constantCondition(type) {
-        const compareAndContrast = new ExprCompare(new DollarReference(type), "=", this.expr);
-        const application = compareAndContrast.getExpression(this.constantFs);
-        return { ...application, value: (0, ast_types_1.compressExpr)(application.value) };
-    }
-    apply(fs, op, expr) {
-        return this.expr.apply(fs, op, expr);
-    }
-    requestExpression(fs) {
-        return this.expr.requestExpression(fs);
-    }
-}
-exports.ConstantSubExpression = ConstantSubExpression;
-class DollarReference extends ExpressionDef {
-    constructor(refType) {
-        super();
-        this.refType = refType;
-        this.elementType = "$";
-    }
-    getExpression(_fs) {
-        return {
-            dataType: this.refType,
-            value: [{ type: "applyVal" }],
-            expressionType: "scalar",
-        };
-    }
-}
-class ConstantFieldSpace {
-    constructor() {
-        this.type = "fieldSpace";
-    }
-    structDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
-    }
-    emptyStructDef() {
-        throw new Error("ConstantFieldSpace cannot generate a structDef");
-    }
-    lookup(_name) {
-        return {
-            error: "Only constants allowed in parameter expressions",
-            found: undefined,
-        };
-    }
-    dialectObj() {
-        return undefined;
-    }
-    whenComplete(step) {
-        step();
-    }
-}
-class FieldDeclaration extends MalloyElement {
-    constructor(expr, defineName, exprSrc) {
-        super({ expr });
-        this.expr = expr;
-        this.defineName = defineName;
-        this.exprSrc = exprSrc;
-        this.elementType = "fieldDeclaration";
-    }
-    fieldDef(fs, exprName) {
-        /*
-         * In an explore we cannot reference the thing we are defining, you need
-         * to use rename. In a query, the output space is a new thing, and expressions
-         * can reference the outer value in order to make a value with the new name,
-         * and it feels wrong that this is HERE and not somehow in the QueryOperation.
-         * For now, this stops the stack overflow, and passes all tests, but I think
-         * a refactor of QueryFieldSpace might someday be the place where this should
-         * happen.
-         */
-        return this.queryFieldDef(new DefSpace(fs, this), exprName);
-    }
-    queryFieldDef(exprFS, exprName) {
-        let exprValue;
-        try {
-            exprValue = this.expr.getExpression(exprFS);
-        }
-        catch (error) {
-            this.log(`Cannot define '${exprName}', ${error.message}`);
-            return {
-                name: `error_defining_${exprName}`,
-                type: "string",
-            };
-        }
-        const compressValue = (0, ast_types_1.compressExpr)(exprValue.value);
-        const retType = exprValue.dataType;
-        if ((0, malloy_types_1.isAtomicFieldType)(retType)) {
-            const template = {
-                name: exprName,
-                type: retType,
-                location: this.location,
-            };
-            if (compressValue.length > 0) {
-                template.e = compressValue;
-            }
-            if (exprValue.expressionType) {
-                template.expressionType = exprValue.expressionType;
-            }
-            if (this.exprSrc) {
-                template.code = this.exprSrc;
-            }
-            // TODO this should work for dates too
-            if ((0, ast_types_1.isGranularResult)(exprValue) && template.type === "timestamp") {
-                template.timeframe = exprValue.timeframe;
-            }
-            return template;
-        }
-        const circularDef = exprFS instanceof DefSpace && exprFS.foundCircle;
-        if (!circularDef) {
-            if (exprValue.dataType == "unknown") {
-                this.log(`Cannot define '${exprName}', value has unknown type`);
-            }
-            else {
-                const badType = ast_types_1.FT.inspect(exprValue);
-                this.log(`Cannot define '${exprName}', unexpected type: ${badType}`);
-            }
-        }
-        return {
-            name: `error_defining_${exprName}`,
-            type: "string",
-        };
-    }
-}
-exports.FieldDeclaration = FieldDeclaration;
-/**
- * All of the magic of malloy expressions eventually flows to here,
- * where an operator is applied to two values. Depending on the
- * operator and value types this may involve transformations of
- * the values or even the operator.
- * @param fs FieldSpace for the symbols
- * @param left Left value
- * @param op The operator
- * @param right Right Value
- * @returns ExprValue of the expression
- */
-function applyBinary(fs, left, op, right) {
-    if ((0, ast_types_1.isEquality)(op)) {
-        return equality(fs, left, op, right);
-    }
-    if ((0, ast_types_1.isComparison)(op)) {
-        return compare(fs, left, op, right);
-    }
-    if (oneOf(op, "+", "-")) {
-        return delta(fs, left, op, right);
-    }
-    if (oneOf(op, "*", "%")) {
-        return numeric(fs, left, op, right);
-    }
-    if (oneOf(op, "/")) {
-        const num = left.getExpression(fs);
-        const denom = right.getExpression(fs);
-        if (num.dataType != "number") {
-            left.log("Numerator for division must be a number");
-        }
-        else if (denom.dataType != "number") {
-            right.log("Denominator for division must be a number");
-        }
-        else {
-            const div = {
-                type: "dialect",
-                function: "div",
-                numerator: num.value,
-                denominator: denom.value,
-            };
-            return {
-                dataType: "number",
-                expressionType: (0, malloy_types_1.maxExpressionType)(num.expressionType, denom.expressionType),
-                value: [div],
-            };
-        }
-        return (0, ast_types_1.errorFor)("divide type mismatch");
-    }
-    left.log(`Canot use ${op} operator here`);
-    return (0, ast_types_1.errorFor)("applybinary bad operator");
-}
-exports.applyBinary = applyBinary;
-class BinaryBoolean extends ExpressionDef {
-    constructor(left, op, right) {
-        super({ left, right });
-        this.left = left;
-        this.op = op;
-        this.right = right;
-        this.elementType = "abstract boolean binary";
-        this.legalChildTypes = [ast_types_1.FT.boolT];
-    }
-    getExpression(fs) {
-        const left = this.left.getExpression(fs);
-        const right = this.right.getExpression(fs);
-        if (this.typeCheck(this.left, left) && this.typeCheck(this.right, right)) {
-            return {
-                dataType: "boolean",
-                expressionType: (0, malloy_types_1.maxExpressionType)(left.expressionType, right.expressionType),
-                value: (0, ast_types_1.compose)(left.value, this.op, right.value),
-            };
-        }
-        return (0, ast_types_1.errorFor)("logial required boolean");
-    }
-}
-exports.BinaryBoolean = BinaryBoolean;
-class ExprCompare extends BinaryBoolean {
-    constructor(left, op, right) {
-        super(left, op, right);
-        this.elementType = "a<=>b";
-        this.legalChildTypes = compareTypes[op];
-    }
-    getExpression(fs) {
-        if (!this.right.granular()) {
-            const rhs = this.right.requestExpression(fs);
-            if (rhs && (0, ast_types_1.isGranularResult)(rhs)) {
-                const newRight = new ExprGranularTime(this.right, rhs.timeframe, false);
-                return newRight.apply(fs, this.op, this.left);
-            }
-        }
-        return this.right.apply(fs, this.op, this.left);
-    }
-}
-exports.ExprCompare = ExprCompare;
-function equality(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    let value = timeCompare(lhs, op, rhs) || (0, ast_types_1.compose)(lhs.value, op, rhs.value);
-    if (lhs.dataType != "unknown" && rhs.dataType != "unknown") {
-        switch (op) {
-            case "~":
-            case "!~": {
-                if (lhs.dataType === "string" && rhs.dataType === "string") {
-                    value = (0, ast_types_1.compose)(lhs.value, "LIKE", rhs.value);
-                }
-                else {
-                    const regexCmp = regexEqual(lhs, rhs);
-                    if (regexCmp === undefined) {
-                        throw new TypeMistmatch("Incompatible types for match('~') operator");
-                    }
-                    value = regexCmp;
-                }
-                value = (0, apply_expr_1.nullsafeNot)(value, op);
-                break;
-            }
-            case "=":
-            case "!=": {
-                const nullCmp = nullCompare(lhs, op, rhs);
-                if (nullCmp) {
-                    value = nullCmp;
-                }
-                else {
-                    value = (0, apply_expr_1.nullsafeNot)(regexEqual(lhs, rhs) || (0, ast_types_1.compose)(lhs.value, "=", rhs.value), op);
-                }
-                break;
-            }
-        }
-    }
-    return {
-        dataType: "boolean",
-        expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType),
-        value,
-    };
-}
-function compare(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
-    const value = timeCompare(lhs, op, rhs) || (0, ast_types_1.compose)(lhs.value, op, rhs.value);
-    return {
-        dataType: "boolean",
-        expressionType,
-        value: value,
-    };
-}
-function oneOf(op, ...operators) {
-    return operators.includes(op);
-}
-function delta(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType)) {
-        let duration = right;
-        if (rhs.dataType !== "duration") {
-            if ((0, ast_types_1.isGranularResult)(lhs)) {
-                duration = new ExprDuration(right, lhs.timeframe);
-            }
-            else if (lhs.dataType === "date") {
-                duration = new ExprDuration(right, "day");
-            }
-            else {
-                left.log(`Can not offset time by '${rhs.dataType}'`);
-                return (0, ast_types_1.errorFor)(`time plus ${rhs.dataType}`);
-            }
-        }
-        return duration.apply(fs, op, left);
-    }
-    return numeric(fs, left, op, right);
-}
-function numeric(fs, left, op, right) {
-    const lhs = left.getExpression(fs);
-    const rhs = right.getExpression(fs);
-    const expressionType = (0, malloy_types_1.maxExpressionType)(lhs.expressionType, rhs.expressionType);
-    if (allAre("number", lhs, rhs)) {
-        return {
-            dataType: "number",
-            expressionType,
-            value: (0, ast_types_1.compose)(lhs.value, op, rhs.value),
-        };
-    }
-    left.log(`Non numeric('${lhs.dataType},${rhs.dataType}') value with '${op}'`);
-    return (0, ast_types_1.errorFor)("numbers required");
-}
-const compareTypes = {
-    "~": [ast_types_1.FT.stringT],
-    "!~": [ast_types_1.FT.stringT],
-    "<": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
-    "<=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
-    "=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
-    "!=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
-    ">=": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
-    ">": [ast_types_1.FT.numberT, ast_types_1.FT.stringT, ast_types_1.FT.dateT, ast_types_1.FT.timestampT],
-};
-/**
- * GranularTime is a moment in time which ALSO has a "granularity"
- * commonly this are created by applying ".datePart" to an expression
- * 1) They have a value, which is the moment in time
- * 2) When used in a comparison, they act like a range, for the
- *    duration of 1 unit of granularity
- */
-class ExprGranularTime extends ExpressionDef {
-    constructor(expr, units, truncate) {
-        super({ expr });
-        this.expr = expr;
-        this.units = units;
-        this.truncate = truncate;
-        this.elementType = "granularTime";
-        this.legalChildTypes = [ast_types_1.FT.timestampT, ast_types_1.FT.dateT];
-    }
-    granular() {
-        return true;
-    }
-    getExpression(fs) {
-        const timeframe = this.units;
-        const exprVal = this.expr.getExpression(fs);
-        if ((0, malloy_types_1.isTimeFieldType)(exprVal.dataType)) {
-            const tsVal = {
-                ...exprVal,
-                dataType: exprVal.dataType,
-                timeframe: timeframe,
-            };
-            if (this.truncate) {
-                tsVal.value = [
-                    {
-                        type: "dialect",
-                        function: "trunc",
-                        expr: { value: exprVal.value, valueType: exprVal.dataType },
-                        units: timeframe,
-                    },
-                ];
-            }
-            return tsVal;
-        }
-        this.log(`Cannot do time truncation on type '${exprVal.dataType}'`);
-        return (0, ast_types_1.errorFor)(`granularity typecheck`);
-    }
-    apply(fs, op, left) {
-        const rangeType = this.getExpression(fs).dataType;
-        const _valueType = left.getExpression(fs).dataType;
-        const granularityType = (0, malloy_types_1.isDateUnit)(this.units) ? "date" : "timestamp";
-        if (rangeType == "date" && granularityType == "date") {
-            return this.dateRange(fs, op, left);
-        }
-        return this.timestampRange(fs, op, left);
-        /*
-          write tests for each of these cases ....
-    
-          vt  rt  gt  use
-          dt  dt  dt  dateRange
-          dt  dt  ts  == or timeStampRange
-          dt  ts  dt  timestampRange
-          dt  ts  ts  timeStampRange
-    
-          ts  ts  ts  timestampRange
-          ts  ts  dt  timestampRange
-          ts  dt  ts  timestampRange
-          ts  dt  dt  either
-    
-        */
-    }
-    timestampRange(fs, op, expr) {
-        const begin = this.getExpression(fs);
-        const beginTime = ExprTime.fromValue("timestamp", begin);
-        const endTime = new ExprTime("timestamp", (0, time_utils_1.timeOffset)("timestamp", begin.value, "+", (0, malloy_types_1.mkExpr) `1`, this.units), begin.expressionType);
-        const range = new Range(beginTime, endTime);
-        return range.apply(fs, op, expr);
-    }
-    dateRange(fs, op, expr) {
-        const begin = this.getExpression(fs);
-        const beginTime = new ExprTime("date", begin.value, begin.expressionType);
-        const endAt = (0, time_utils_1.timeOffset)("date", begin.value, "+", ["1"], this.units);
-        const end = new ExprTime("date", endAt, begin.expressionType);
-        const range = new Range(beginTime, end);
-        return range.apply(fs, op, expr);
-    }
-}
-exports.ExprGranularTime = ExprGranularTime;
-function timeCompare(lhs, op, rhs) {
-    if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (0, malloy_types_1.isTimeFieldType)(rhs.dataType)) {
-        if (lhs.dataType !== rhs.dataType) {
-            let lval = lhs.value;
-            let rval = rhs.value;
-            if (lhs.dataType === "timestamp") {
-                lval = (0, time_utils_1.castTimestampToDate)(lval);
-            }
-            else {
-                rval = (0, time_utils_1.castTimestampToDate)(rval);
-            }
-            return (0, ast_types_1.compose)(lval, op, rval);
-        }
-    }
-    return undefined;
-}
-function regexEqual(left, right) {
-    if (left.dataType === "string") {
-        if (right.dataType === "regular expression") {
-            return [
-                {
-                    type: "dialect",
-                    function: "regexpMatch",
-                    expr: left.value,
-                    regexp: right.value[0].replace(/^r'/, "'"),
-                },
-            ];
-        }
-    }
-    else if (right.dataType === "string") {
-        if (left.dataType === "regular expression") {
-            return [
-                {
-                    type: "dialect",
-                    function: "regexpMatch",
-                    expr: right.value,
-                    regexp: left.value[0].replace(/^r'/, "'"),
-                },
-            ];
-        }
-    }
-    return undefined;
-}
-class TypeMistmatch extends Error {
-}
-exports.TypeMistmatch = TypeMistmatch;
-function nullCompare(left, op, right) {
-    const not = op === "!=" || op === "!~";
-    if (left.dataType === "null" || right.dataType === "null") {
-        const maybeNot = not ? " NOT" : "";
-        if (left.dataType !== "null") {
-            return [...left.value, ` IS${maybeNot} NULL`];
-        }
-        if (right.dataType !== "null") {
-            return [...right.value, `IS${maybeNot} NULL`];
-        }
-        return [not ? "false" : "true"];
-    }
-    return undefined;
-}
-class ExprDuration extends ExpressionDef {
-    constructor(n, timeframe) {
-        super({ n });
-        this.n = n;
-        this.timeframe = timeframe;
-        this.elementType = "duration";
-        this.legalChildTypes = [ast_types_1.FT.timestampT, ast_types_1.FT.dateT];
-    }
-    apply(fs, op, left) {
-        const lhs = left.getExpression(fs);
-        this.typeCheck(this, lhs);
-        if ((0, malloy_types_1.isTimeFieldType)(lhs.dataType) && (op === "+" || op === "-")) {
-            const num = this.n.getExpression(fs);
-            if (!ast_types_1.FT.typeEq(num, ast_types_1.FT.numberT)) {
-                this.log(`Duration units needs number not '${num.dataType}`);
-                return (0, ast_types_1.errorFor)("illegal unit expression");
-            }
-            let resultGranularity;
-            // Only allow the output of this to be granular if the
-            // granularities match, this is still an area where
-            // more thought is required.
-            if ((0, ast_types_1.isGranularResult)(lhs) && lhs.timeframe == this.timeframe) {
-                resultGranularity = lhs.timeframe;
-            }
-            if (lhs.dataType === "timestamp") {
-                const result = (0, time_utils_1.timeOffset)("timestamp", lhs.value, op, num.value, this.timeframe);
-                return (0, time_utils_1.timeResult)({
-                    dataType: "timestamp",
-                    expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                    value: result,
-                }, resultGranularity);
-            }
-            return (0, time_utils_1.timeResult)({
-                dataType: "date",
-                expressionType: (0, malloy_types_1.maxExpressionType)(lhs.expressionType, num.expressionType),
-                value: (0, time_utils_1.timeOffset)("date", lhs.value, op, num.value, this.timeframe),
-            }, resultGranularity);
-        }
-        return super.apply(fs, op, left);
-    }
-    getExpression(_fs) {
-        return {
-            dataType: "duration",
-            expressionType: "scalar",
-            value: ["__ERROR_DURATION_IS_NOT_A_VALUE__"],
-        };
-    }
-}
-exports.ExprDuration = ExprDuration;
-function allAre(oneType, ...values) {
-    for (const v of values) {
-        if (v.dataType !== oneType) {
-            return false;
-        }
-    }
-    return true;
-}
-class ExprTime extends ExpressionDef {
-    constructor(timeType, value, expressionType = "scalar") {
-        super();
-        this.elementType = "timestampOrDate";
-        this.elementType = timeType;
-        this.translationValue = {
-            dataType: timeType,
-            expressionType,
-            value: typeof value === "string" ? [value] : value,
-        };
-    }
-    getExpression(_fs) {
-        return this.translationValue;
-    }
-    static fromValue(timeType, expr) {
-        let value = expr.value;
-        if (timeType != expr.dataType) {
-            const toTs = {
-                type: "dialect",
-                function: "cast",
-                safe: false,
-                dstType: timeType,
-                expr: expr.value,
-            };
-            if ((0, malloy_types_1.isTimeFieldType)(expr.dataType)) {
-                toTs.srcType = expr.dataType;
-            }
-            value = (0, ast_types_1.compressExpr)([toTs]);
-        }
-        return new ExprTime(timeType, value, expr.expressionType);
-    }
-}
-exports.ExprTime = ExprTime;
-class Range extends ExpressionDef {
-    constructor(first, last) {
-        super({ first, last });
-        this.first = first;
-        this.last = last;
-        this.elementType = "range";
-    }
-    apply(fs, op, expr) {
-        switch (op) {
-            case "=":
-            case "!=": {
-                const op1 = op === "=" ? ">=" : "<";
-                const op2 = op === "=" ? "and" : "or";
-                const op3 = op === "=" ? "<" : ">=";
-                const fromValue = this.first.apply(fs, op1, expr);
-                const toValue = this.last.apply(fs, op3, expr);
-                return {
-                    dataType: "boolean",
-                    expressionType: (0, malloy_types_1.maxExpressionType)(fromValue.expressionType, toValue.expressionType),
-                    value: (0, ast_types_1.compose)(fromValue.value, op2, toValue.value),
-                };
-            }
-            /**
-             * This is a little surprising, but is actually how you comapre a
-             * value to a range ...
-             *
-             * val > begin to end     val >= end
-             * val >= begin to end    val >= begin
-             * val < begin to end     val < begin
-             * val <= begin to end    val < end
-             */
-            case ">":
-                return this.last.apply(fs, ">=", expr);
-            case ">=":
-                return this.first.apply(fs, ">=", expr);
-            case "<":
-                return this.first.apply(fs, "<", expr);
-            case "<=":
-                return this.last.apply(fs, "<", expr);
-        }
-        throw new Error("mysterious error in range computation");
-    }
-    requestExpression(_fs) {
-        return undefined;
-    }
-    getExpression(_fs) {
-        return (0, ast_types_1.errorFor)("a range is not a value");
-    }
-}
-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