@malloydata/malloy 0.0.3 → 0.0.4

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

@@ -1,2087 +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.FullQuery = 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.Mallobj = exports.isExploreField = exports.Unimplemented = exports.ListOf = exports.MalloyElement = exports.ErrorFactory = void 0;
-exports.SampleProperty = exports.SQLStatement = 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 = void 0;
-/*
- * Copyright 2021 Google LLC
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-const lodash_1 = require("lodash");
-const model = __importStar(require("../../model/malloy_types"));
-const malloy_query_1 = require("../../model/malloy_query");
-const field_space_1 = require("../field-space");
-const index_1 = require("./index");
-const space_field_1 = require("../space-field");
-const sql_block_1 = require("../../model/sql_block");
-const util_1 = require("util");
-const time_utils_1 = require("./time-utils");
-/*
- ** 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") {
-                this.addReference({
-                    type: "exploreReference",
-                    text: key,
-                    definition: result.entry,
-                    location: reference.location,
-                });
-            }
-            else if ((result === null || result === void 0 ? void 0 : result.entry.type) === "sqlBlock") {
-                this.addReference({
-                    type: "sqlBlockReference",
-                    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 index_1.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();
-    }
-}
-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 ListOf {
-    constructor(sourceList) {
-        super("defineSources", sourceList);
-        this.has({ sourceList });
-    }
-    execute(doc) {
-        for (const dq of this.list) {
-            dq.execute(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 = field_space_1.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 (fc.aggregate) {
-                    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.includes(this.name)
-                    ? `'Schema error: ${tableDefEntry.message}`
-                    : `Schema error '${this.name}': ${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();
-        }
-        return this.refName;
-    }
-    modelStruct() {
-        var _a;
-        const modelEnt = (_a = this.modelEntry(this.ref)) === null || _a === void 0 ? void 0 : _a.entry;
-        if (!modelEnt) {
-            const undefMsg = `Undefined source '${this.refName}'`;
-            (this.ref instanceof ModelEntryReference ? this.ref : this).log(undefMsg);
-            return;
-        }
-        if (modelEnt.type === "query") {
-            this.log(`Must use 'from()' to explore query '${this.refName}`);
-            return;
-        }
-        else if (modelEnt.type === "sqlBlock") {
-            this.log(`Must use 'from_sql()' to explore sql query '${this.refName}`);
-            return;
-        }
-        return { ...modelEnt };
-    }
-    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() {
-        var _a, _b;
-        const modelEnt = (_a = this.modelEntry(this.ref)) === null || _a === void 0 ? void 0 : _a.entry;
-        if (!modelEnt) {
-            this.log(`Undefined from_sql source '${this.refName}'`);
-            return;
-        }
-        if (modelEnt.type === "query") {
-            this.log(`Cannot use 'from_sql()' to explore query '${this.refName}'`);
-            return;
-        }
-        else if (modelEnt.type === "struct") {
-            this.log(`Cannot use 'from_sql()' to explore '${this.refName}'`);
-            return;
-        }
-        const sqlDefEntry = (_b = this.translator()) === null || _b === void 0 ? void 0 : _b.root.sqlQueryZone;
-        if (!sqlDefEntry) {
-            this.log(`Cant't look up schema for sql block '${this.refName}'`);
-            return;
-        }
-        if (modelEnt.type == "sqlBlock") {
-            const key = modelEnt.name;
-            const lookup = sqlDefEntry.getEntry(key);
-            let msg = `Schema read failure for sql query '${this.refName}'`;
-            if (lookup) {
-                if (lookup.status == "present") {
-                    const structDef = lookup.value;
-                    return {
-                        ...structDef,
-                        fields: structDef.fields.map((field) => ({
-                            ...field,
-                            location: modelEnt.location,
-                        })),
-                    };
-                }
-                if (lookup.status == "error") {
-                    msg = lookup.message.includes(this.refName)
-                        ? `'Schema error: ${lookup.message}`
-                        : `Schema error '${this.refName}': ${lookup.message}`;
-                }
-                this.log(msg);
-            }
-        }
-        else {
-            this.log(`Mis-typed definition for'${this.refName}'`);
-        }
-    }
-}
-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, index_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_"],
-            };
-        }
-        const exprCond = {
-            code: this.exprSrc,
-            expression: (0, index_1.compressExpr)(exprVal.value),
-        };
-        if (exprVal.aggregate) {
-            exprCond.aggregate = true;
-        }
-        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 (!fExpr.aggregate) {
-                        oneElement.log("Aggregate expression expected in HAVING filter");
-                        continue;
-                    }
-                }
-                else {
-                    if (fExpr.aggregate) {
-                        oneElement.log("Aggregate expression 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 index_1.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 index_1.FieldDeclaration) {
-                el.isMeasure = false;
-            }
-        }
-    }
-}
-exports.GroupBy = GroupBy;
-class Aggregate extends ListOf {
-    constructor(members) {
-        super("aggregate", members);
-        for (const el of members) {
-            if (el instanceof index_1.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 field_space_1.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 field_space_1.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 field_space_1.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 field_space_1.DynamicSpace(opOutputStruct(this, inputFS.structDef(), segment)),
-        };
-    }
-}
-exports.QOPDesc = QOPDesc;
-class Document extends MalloyElement {
-    constructor(statements) {
-        super({ statements });
-        this.statements = statements;
-        this.elementType = "document";
-        this.documentModel = {};
-        this.queryList = [];
-        this.sqlBlocks = [];
-    }
-    getModelDef(extendingModelDef) {
-        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 });
-                }
-            }
-        }
-        for (const stmt of this.statements) {
-            if (this.errorsExist()) {
-                // Once errors appear, don't continue executing statements, stops
-                // a number of cascasding errors.
-                break;
-            }
-            stmt.execute(this);
-        }
-        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 });
-        }
-        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 field_space_1.DynamicSpace(exploreStruct);
-        const sourcePipe = this.refinePipeline(exploreFS, seedQuery);
-        const walkStruct = this.getOutputStruct(exploreStruct, sourcePipe.pipeline);
-        const appended = this.appendOps(sourcePipe.pipeline, new field_space_1.DynamicSpace(walkStruct));
-        const 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 field_space_1.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 field_space_1.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 space_field_1.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 field_space_1.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 ListOf {
-    constructor(queryList) {
-        super("defineQueries", queryList);
-        this.has({ queryList });
-    }
-    execute(doc) {
-        for (const dq of this.list) {
-            dq.execute(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 });
-    }
-}
-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);
-    }
-}
-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 (!byExpr.aggregate) {
-                    this.log("top by expression must be an aggregate");
-                }
-                return { by: "expression", e: (0, index_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 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}'`);
-            }
-        }
-    }
-}
-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 SQLStatement extends MalloyElement {
-    constructor(blockReq) {
-        super();
-        this.blockReq = blockReq;
-        this.elementType = "sqlStatement";
-    }
-    sqlBlock() {
-        const sqlBlock = (0, sql_block_1.makeSQLBlock)(this.blockReq);
-        sqlBlock.location = this.location;
-        return sqlBlock;
-    }
-    execute(doc) {
-        if (!doc.defineSQL(this.sqlBlock(), this.is)) {
-            this.log(`${this.is} already defined`);
-        }
-    }
-}
-exports.SQLStatement = SQLStatement;
-class SampleProperty extends MalloyElement {
-    constructor(sample) {
-        super();
-        this.sample = sample;
-        this.elementType = "sampleProperty";
-    }
-    sampling() {
-        return this.sample;
-    }
-}
-exports.SampleProperty = SampleProperty;
-//# sourceMappingURL=ast-main.js.map