@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/ast/field-space/query-spaces.d.ts

@@ -0,0 +1,50 @@
+import * as model from "../../../model/malloy_types";
+import { FieldDeclaration } from "../query-items/field-declaration";
+import { FieldName, FieldSpace } from "../types/field-space";
+import { MalloyElement } from "../types/malloy-element";
+import { Join } from "../query-properties/joins";
+import { SourceSpec } from "../space-seed";
+import { FieldReference, WildcardFieldReference } from "../query-items/field-references";
+import { FieldCollectionMember } from "../types/field-collection-member";
+import { QueryItem } from "../types/query-item";
+import { RefinedSpace } from "./refined-space";
+/**
+ * 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.
+ */
+export declare class QueryInputSpace extends RefinedSpace {
+    readonly result: QuerySpace;
+    nestParent?: QueryInputSpace;
+    extendList: string[];
+    constructor(input: SourceSpec, result: QuerySpace);
+    extendSource(extendField: Join | FieldDeclaration): void;
+}
+export declare abstract class QuerySpace extends RefinedSpace {
+    readonly queryInputSpace: FieldSpace;
+    readonly exprSpace: QueryInputSpace;
+    astEl?: MalloyElement | undefined;
+    abstract readonly segmentType: "reduce" | "project" | "index";
+    constructor(queryInputSpace: FieldSpace);
+    log(s: string): void;
+    addMembers(members: FieldCollectionMember[]): void;
+    addReference(ref: FieldReference): void;
+    addWild(wild: WildcardFieldReference): void;
+    /**
+     * Check for the definition of an ungrouping reference in the result space,
+     * or in the case of an exclude reference, if this query is nested
+     * in another query, in the result space of a query that this query
+     * is nested inside of.
+     */
+    checkUngroup(fn: FieldName, isExclude: boolean): void;
+    addQueryItems(...qiList: QueryItem[]): void;
+    canContain(_qd: model.QueryFieldDef): boolean;
+    protected queryFieldDefs(): model.QueryFieldDef[];
+    getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
+    getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
+}
+export declare class ReduceFieldSpace extends QuerySpace {
+    readonly segmentType = "reduce";
+}

package/dist/lang/ast/field-space/query-spaces.js

@@ -0,0 +1,233 @@
+"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.ReduceFieldSpace = exports.QuerySpace = exports.QueryInputSpace = void 0;
+const model = __importStar(require("../../../model/malloy_types"));
+const field_utils_1 = require("../../field-utils");
+const field_declaration_1 = require("../query-items/field-declaration");
+const joins_1 = require("../query-properties/joins");
+const space_field_1 = require("../types/space-field");
+const space_seed_1 = require("../space-seed");
+const nest_1 = require("../query-properties/nest");
+const nest_reference_1 = require("../query-properties/nest-reference");
+const field_references_1 = require("../query-items/field-references");
+const reference_field_1 = require("./reference-field");
+const wild_space_field_1 = require("./wild-space-field");
+const refined_space_1 = require("./refined-space");
+/**
+ * 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.
+ */
+class QueryInputSpace extends refined_space_1.RefinedSpace {
+    constructor(input, result) {
+        const inputSpace = new space_seed_1.SpaceSeed(input);
+        super(inputSpace.structDef);
+        this.result = result;
+        this.extendList = [];
+    }
+    extendSource(extendField) {
+        this.addField(extendField);
+        if (extendField instanceof joins_1.Join) {
+            this.extendList.push(extendField.name.refString);
+        }
+        else {
+            this.extendList.push(extendField.defineName);
+        }
+    }
+}
+exports.QueryInputSpace = QueryInputSpace;
+class QuerySpace extends refined_space_1.RefinedSpace {
+    constructor(queryInputSpace) {
+        super(queryInputSpace.emptyStructDef());
+        this.queryInputSpace = queryInputSpace;
+        this.exprSpace = new QueryInputSpace(queryInputSpace, this);
+    }
+    log(s) {
+        if (this.astEl) {
+            this.astEl.log(s);
+        }
+    }
+    addMembers(members) {
+        for (const member of members) {
+            if (member instanceof field_references_1.FieldReference) {
+                this.addReference(member);
+            }
+            else if (member instanceof field_references_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 reference_field_1.ReferenceField(ref));
+        }
+    }
+    addWild(wild) {
+        this.setEntry(wild.refString, new wild_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 field_references_1.FieldReference || qi instanceof nest_reference_1.NestReference) {
+                this.addReference(qi);
+            }
+            else if (qi instanceof field_declaration_1.FieldDeclaration) {
+                this.addField(qi);
+            }
+            else if ((0, nest_1.isNestedQuery)(qi)) {
+                const qf = new nest_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.QuerySpace = QuerySpace;
+class ReduceFieldSpace extends QuerySpace {
+    constructor() {
+        super(...arguments);
+        this.segmentType = "reduce";
+    }
+}
+exports.ReduceFieldSpace = ReduceFieldSpace;
+//# sourceMappingURL=query-spaces.js.map

package/dist/lang/ast/field-space/reference-field.d.ts

@@ -0,0 +1,11 @@
+import { QueryFieldDef } from "../../../model/malloy_types";
+import { FieldReference } from "../query-items/field-references";
+import { FieldSpace } from "../types/field-space";
+import { SpaceField } from "../types/space-field";
+import { TypeDesc } from "../types/type-desc";
+export declare class ReferenceField extends SpaceField {
+    readonly fieldRef: FieldReference;
+    constructor(fieldRef: FieldReference);
+    getQueryFieldDef(fs: FieldSpace): QueryFieldDef | undefined;
+    typeDesc(): TypeDesc;
+}

package/dist/lang/ast/field-space/reference-field.js

@@ -0,0 +1,45 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceField = void 0;
+const space_field_1 = require("../types/space-field");
+class ReferenceField extends space_field_1.SpaceField {
+    constructor(fieldRef) {
+        super();
+        this.fieldRef = fieldRef;
+    }
+    getQueryFieldDef(fs) {
+        // Lookup string and generate error if it isn't defined.
+        const check = this.fieldRef.getField(fs);
+        if (check.error) {
+            this.fieldRef.log(check.error);
+        }
+        return this.fieldRef.refString;
+    }
+    typeDesc() {
+        return { dataType: "unknown", expressionType: "scalar" };
+    }
+}
+exports.ReferenceField = ReferenceField;
+//# sourceMappingURL=reference-field.js.map

package/dist/lang/ast/field-space/refined-space.d.ts

@@ -0,0 +1,13 @@
+import { StructDef } from "../../../model/malloy_types";
+import { FieldListEdit } from "../source-properties/field-list-edit";
+import { DynamicSpace } from "./dynamic-space";
+import { ExploreField } from "../types/explore-field";
+export declare class RefinedSpace extends DynamicSpace {
+    /**
+     * Factory for FieldSpace 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: StructDef, choose?: FieldListEdit): RefinedSpace;
+    addField(...defs: ExploreField[]): void;
+}

package/dist/lang/ast/field-space/refined-space.js

@@ -0,0 +1,100 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefinedSpace = void 0;
+const renames_1 = require("../source-properties/renames");
+const joins_1 = require("../query-properties/joins");
+const dynamic_space_1 = require("./dynamic-space");
+const nest_1 = require("../query-properties/nest");
+const field_definition_value_1 = require("./field-definition-value");
+const join_space_field_1 = require("./join-space-field");
+const rename_space_field_1 = require("./rename-space-field");
+const field_declaration_1 = require("../query-items/field-declaration");
+const space_field_1 = require("../types/space-field");
+class RefinedSpace extends dynamic_space_1.DynamicSpace {
+    /**
+     * Factory for FieldSpace 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 RefinedSpace(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;
+    }
+    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 field_declaration_1.FieldDeclaration) {
+                const exprField = new field_definition_value_1.FieldDefinitionValue(this, def);
+                this.newEntry(exprField.name, def, exprField);
+            }
+            else if (def instanceof nest_1.TurtleDecl) {
+                const name = def.name;
+                this.newEntry(name, def, new nest_1.QueryFieldAST(this, def, name));
+            }
+            else if (def instanceof renames_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 rename_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 joins_1.Join) {
+                this.newEntry(def.name.refString, def, new join_space_field_1.JoinSpaceField(this, def));
+            }
+            else {
+                elseLog(`Internal error: Expected expression, query, or rename, got '${elseType}'`);
+            }
+        }
+    }
+}
+exports.RefinedSpace = RefinedSpace;
+//# sourceMappingURL=refined-space.js.map

package/dist/lang/ast/field-space/rename-space-field.d.ts

@@ -0,0 +1,11 @@
+import { DocumentLocation, FieldDef } from "../../../model/malloy_types";
+import { SpaceField } from "../types/space-field";
+import { TypeDesc } from "../types/type-desc";
+export declare class RenameSpaceField extends SpaceField {
+    private readonly otherField;
+    private readonly newName;
+    private readonly location;
+    constructor(otherField: SpaceField, newName: string, location: DocumentLocation);
+    fieldDef(): FieldDef | undefined;
+    typeDesc(): TypeDesc;
+}

package/dist/lang/ast/field-space/rename-space-field.js

@@ -0,0 +1,50 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenameSpaceField = void 0;
+const space_field_1 = require("../types/space-field");
+class RenameSpaceField extends space_field_1.SpaceField {
+    constructor(otherField, newName, location) {
+        super();
+        this.otherField = otherField;
+        this.newName = newName;
+        this.location = location;
+    }
+    fieldDef() {
+        const renamedFieldRaw = this.otherField.fieldDef();
+        if (renamedFieldRaw === undefined) {
+            return undefined;
+        }
+        return {
+            ...renamedFieldRaw,
+            as: this.newName,
+            location: this.location,
+        };
+    }
+    typeDesc() {
+        return this.otherField.typeDesc();
+    }
+}
+exports.RenameSpaceField = RenameSpaceField;
+//# sourceMappingURL=rename-space-field.js.map

package/dist/lang/ast/field-space/static-space.d.ts

@@ -0,0 +1,29 @@
+import { Dialect } from "../../../dialect/dialect";
+import { FieldDef, StructDef } from "../../../model/malloy_types";
+import { SpaceEntry } from "../types/space-entry";
+import { LookupResult } from "../types/lookup-result";
+import { FieldName, FieldSpace } from "../types/field-space";
+import { SpaceField } from "../types/space-field";
+import { StructSpaceFieldBase } from "./struct-space-field-base";
+export declare class StaticSpace implements FieldSpace {
+    readonly type = "fieldSpace";
+    private memoMap?;
+    protected fromStruct: StructDef;
+    constructor(sourceStructDef: StructDef);
+    whenComplete(step: () => void): void;
+    dialectObj(): Dialect | undefined;
+    defToSpaceField(from: FieldDef): SpaceField;
+    private get map();
+    protected dropEntries(): void;
+    protected dropEntry(name: string): void;
+    protected entry(name: string): SpaceEntry | undefined;
+    protected setEntry(name: string, value: SpaceEntry): void;
+    protected entries(): [string, SpaceEntry][];
+    structDef(): StructDef;
+    emptyStructDef(): StructDef;
+    lookup(path: FieldName[]): LookupResult;
+}
+export declare class StructSpaceField extends StructSpaceFieldBase {
+    constructor(def: StructDef);
+    get fieldSpace(): FieldSpace;
+}