@malloydata/malloy 0.0.22-dev230119001546 → 0.0.22-dev230119193053

package/dist/lang/field-space.js

@@ -1,641 +0,0 @@
-"use strict";
-/*
- * 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.
- */
-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.DefSpace = exports.IndexFieldSpace = exports.ProjectFieldSpace = exports.ReduceFieldSpace = exports.ResultSpace = exports.QuerySpace = exports.DynamicSpace = exports.StaticSpace = void 0;
-/* eslint-disable no-useless-constructor */
-const lodash_1 = require("lodash");
-const dialect_1 = require("../dialect");
-const model = __importStar(require("../model/malloy_types"));
-const ast_1 = require("./ast");
-const space_field_1 = require("./space-field");
-const field_utils_1 = require("./field-utils");
-/**
- * The father of all FieldSpaces is a wrapper for a StructDef.
- */
-class StaticSpace {
-    constructor(sourceStructDef) {
-        this.type = "fieldSpace";
-        this.fromStruct = sourceStructDef;
-    }
-    whenComplete(step) {
-        step();
-    }
-    dialectObj() {
-        try {
-            return (0, dialect_1.getDialect)(this.fromStruct.dialect);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    fromFieldDef(from) {
-        if (from.type === "struct") {
-            return new space_field_1.StructSpaceField(from);
-        }
-        else if (model.isTurtleDef(from)) {
-            return new space_field_1.QueryFieldStruct(this, from);
-        }
-        // TODO field has a filter and needs to be a filteredalias
-        return new space_field_1.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 space_field_1.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 space_field_1.SpaceField) {
-            /*
-             * TODO cache defs, post the addReference call to whenComplete
-             *
-             * In the cleanup phase of query space construction, it may check
-             * the output space for ungrouping variables. However if an
-             * ungrouping variable is a measure, the field expression value
-             * 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 space_field_1.StructSpaceField
-                        ? "joinReference"
-                        : "fieldReference",
-                    definition,
-                    location: head.location,
-                    text: head.refString,
-                });
-            }
-        }
-        if (rest.length) {
-            if (found instanceof space_field_1.StructSpaceField) {
-                return found.fieldSpace.lookup(rest);
-            }
-            return {
-                error: `'${head}' cannot contain a '${rest[0]}'`,
-                found: undefined,
-            };
-        }
-        return { found, error: undefined };
-    }
-}
-exports.StaticSpace = StaticSpace;
-function isFieldSpace(x) {
-    return x.type == "fieldSpace";
-}
-/**
- * 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;
-    }
-}
-/**
- * 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 space_field_1.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 ast_1.FieldDeclaration) {
-                const exprField = new space_field_1.ExpressionFieldFromAst(this, def);
-                this.newEntry(exprField.name, def, exprField);
-                // querry (turtle) fields
-            }
-            else if (def instanceof ast_1.TurtleDecl) {
-                const name = def.name;
-                this.newEntry(name, def, new space_field_1.QueryFieldAST(this, def, name));
-            }
-            else if (def instanceof ast_1.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 space_field_1.SpaceField) {
-                        this.setEntry(def.newName, new space_field_1.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 ast_1.Join) {
-                this.newEntry(def.name.refString, def, new space_field_1.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 space_field_1.StructSpaceField) {
-                    joins.push([name, spaceEntry]);
-                }
-                else if (spaceEntry instanceof space_field_1.QueryField) {
-                    turtles.push([name, spaceEntry]);
-                }
-                else if (spaceEntry instanceof space_field_1.SpaceField) {
-                    fields.push([name, spaceEntry]);
-                }
-                else if (spaceEntry instanceof space_field_1.SpaceParam) {
-                    parameters[name] = spaceEntry.parameter();
-                }
-            }
-            const reorderFields = [...fields, ...joins, ...turtles];
-            for (const [fieldName, field] of reorderFields) {
-                if (field instanceof space_field_1.JoinSpaceField) {
-                    const joinStruct = field.join.structDef();
-                    if (!ast_1.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;
-/**
- * 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 ast_1.Join) {
-            this.extendList.push(extendField.name.refString);
-        }
-        else {
-            this.extendList.push(extendField.defineName);
-        }
-    }
-}
-exports.QuerySpace = QuerySpace;
-class ResultSpace extends DynamicSpace {
-    constructor(queryInputSpace) {
-        super(queryInputSpace.emptyStructDef());
-        this.queryInputSpace = queryInputSpace;
-        this.exprSpace = new QuerySpace(queryInputSpace, this);
-    }
-    log(s) {
-        if (this.astEl) {
-            this.astEl.log(s);
-        }
-    }
-    addMembers(members) {
-        for (const member of members) {
-            if (member instanceof ast_1.FieldReference) {
-                this.addReference(member);
-            }
-            else if (member instanceof ast_1.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 space_field_1.ReferenceField(ref));
-        }
-    }
-    addWild(wild) {
-        this.setEntry(wild.refString, new space_field_1.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 ast_1.FieldReference || qi instanceof ast_1.NestReference) {
-                this.addReference(qi);
-            }
-            else if (qi instanceof ast_1.FieldDeclaration) {
-                this.addField(qi);
-            }
-            else if ((0, ast_1.isNestedQuery)(qi)) {
-                const qf = new space_field_1.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 space_field_1.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 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;
-/**
- * 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;
-//# sourceMappingURL=field-space.js.map