@malloydata/malloy 0.0.22-dev230207144036 → 0.0.22-dev230207180844

package/dist/lang/ast/elements/import-statement.d.ts

@@ -0,0 +1,9 @@
+import { ModelDataRequest } from "../../translate-response";
+import { DocStatement, Document, MalloyElement } from "../types/malloy-element";
+export declare class ImportStatement extends MalloyElement implements DocStatement {
+    readonly url: string;
+    elementType: string;
+    fullURL?: string;
+    constructor(url: string, baseURL: string);
+    execute(doc: Document): ModelDataRequest;
+}

package/dist/lang/ast/elements/import-statement.js

@@ -0,0 +1,78 @@
+"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.ImportStatement = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class ImportStatement extends malloy_element_1.MalloyElement {
+    /*
+     * At the time of writng this comment, it is guaranteed that if an AST
+     * node for an import statement is created, the translator has already
+     * succesfully fetched the URL referred to in the statement.
+     *
+     * Error checking code in here is future proofing against a day when
+     * there are other ways to contruct an AST.
+     */
+    constructor(url, baseURL) {
+        super();
+        this.url = url;
+        this.elementType = "import statement";
+        try {
+            this.fullURL = decodeURI(new URL(url, baseURL).toString());
+        }
+        catch (e) {
+            this.log("Invalid URI in import statement");
+        }
+    }
+    execute(doc) {
+        const trans = this.translator();
+        if (!trans) {
+            this.log("Cannot import without translation context");
+        }
+        else if (this.fullURL) {
+            const src = trans.root.importZone.getEntry(this.fullURL);
+            if (src.status === "present") {
+                const childNeeds = trans.childRequest(this.fullURL);
+                if (childNeeds) {
+                    return childNeeds;
+                }
+                const importStructs = trans.getChildExports(this.fullURL);
+                for (const importing in importStructs) {
+                    doc.setEntry(importing, {
+                        entry: importStructs[importing],
+                        exported: false,
+                    });
+                }
+            }
+            else if (src.status === "error") {
+                this.log(`import failed: '${src.message}'`);
+            }
+            else {
+                this.log(`import failed with status: '${src.status}'`);
+            }
+        }
+        return undefined;
+    }
+}
+exports.ImportStatement = ImportStatement;
+//# sourceMappingURL=import-statement.js.map

package/dist/lang/ast/elements/pipeline-desc.d.ts

@@ -0,0 +1,30 @@
+import { DocumentLocation, Pipeline, PipeSegment, StructDef } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { MalloyElement } from "../types/malloy-element";
+import { QOPDesc } from "../query-properties/qop-desc";
+import { QueryInputSpace } from "../field-space/query-spaces";
+interface AppendResult {
+    opList: PipeSegment[];
+    structDef: StructDef;
+}
+/**
+ * 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.
+ */
+export declare abstract class PipelineDesc extends MalloyElement {
+    elementType: string;
+    protected headRefinement?: QOPDesc;
+    protected qops: QOPDesc[];
+    nestedInQuerySpace?: QueryInputSpace;
+    refineHead(refinement: QOPDesc): void;
+    addSegments(...segDesc: QOPDesc[]): void;
+    protected appendOps(modelPipe: PipeSegment[], existingEndSpace: FieldSpace): AppendResult;
+    protected refinePipeline(fs: FieldSpace, modelPipe: Pipeline): Pipeline;
+    protected expandTurtle(turtleName: string, fromStruct: StructDef): {
+        pipeline: PipeSegment[];
+        location: DocumentLocation | undefined;
+    };
+    protected getOutputStruct(walkStruct: StructDef, pipeline: PipeSegment[]): StructDef;
+}
+export {};

package/dist/lang/ast/elements/pipeline-desc.js

@@ -0,0 +1,102 @@
+"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.PipelineDesc = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+const struct_utils_1 = require("../struct-utils");
+/**
+ * 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 malloy_element_1.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 = (0, struct_utils_1.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 = (0, struct_utils_1.opOutputStruct)(this, walkStruct, modelQop);
+        }
+        return walkStruct;
+    }
+}
+exports.PipelineDesc = PipelineDesc;
+//# sourceMappingURL=pipeline-desc.js.map

package/dist/lang/ast/elements/refined-source.d.ts

@@ -0,0 +1,15 @@
+import { StructDef } from "../../../model/malloy_types";
+import { ExploreDesc } from "../types/explore-desc";
+import { HasParameter } from "../parameters/has-parameter";
+import { Source } from "./source";
+/**
+ * A Source made from a source reference and a set of refinements
+ */
+export declare class RefinedSource extends Source {
+    readonly source: Source;
+    readonly refinement: ExploreDesc;
+    elementType: string;
+    constructor(source: Source, refinement: ExploreDesc);
+    structDef(): StructDef;
+    withParameters(pList: HasParameter[] | undefined): StructDef;
+}

package/dist/lang/ast/elements/refined-source.js

@@ -0,0 +1,121 @@
+"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.RefinedSource = void 0;
+const lodash_1 = require("lodash");
+const malloy_types_1 = require("../../../model/malloy_types");
+const field_list_edit_1 = require("../source-properties/field-list-edit");
+const primary_key_1 = require("../source-properties/primary-key");
+const renames_1 = require("../source-properties/renames");
+const turtles_1 = require("../source-properties/turtles");
+const source_1 = require("./source");
+const declare_fields_1 = require("../query-properties/declare-fields");
+const filters_1 = require("../query-properties/filters");
+const joins_1 = require("../query-properties/joins");
+const refined_space_1 = require("../field-space/refined-space");
+/**
+ * A Source made from a source reference and a set of refinements
+ */
+class RefinedSource extends source_1.Source {
+    constructor(source, refinement) {
+        super({ source, refinement });
+        this.source = source;
+        this.refinement = refinement;
+        this.elementType = "refinedSource";
+    }
+    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 primary_key_1.PrimaryKey) {
+                if (primaryKey) {
+                    primaryKey.log("Primary key already defined");
+                    el.log("Primary key redefined");
+                }
+                primaryKey = el;
+            }
+            else if (el instanceof field_list_edit_1.FieldListEdit) {
+                if (fieldListEdit) {
+                    fieldListEdit.log("Too many accept/except statements");
+                    el.log("Too many accept/except statements");
+                }
+                fieldListEdit = el;
+            }
+            else if (el instanceof declare_fields_1.DeclareFields ||
+                el instanceof joins_1.Joins ||
+                el instanceof turtles_1.Turtles ||
+                el instanceof renames_1.Renames) {
+                fields.push(...el.list);
+            }
+            else if (el instanceof filters_1.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 = refined_space_1.RefinedSpace.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 ((0, malloy_types_1.expressionIsCalculation)(fc.expressionType)) {
+                    el.log("Can't use aggregate computations in top level filters");
+                }
+                else {
+                    filterList.push(fc);
+                    moreFilters = true;
+                }
+            }
+        }
+        if (moreFilters) {
+            return { ...retStruct, filterList };
+        }
+        return retStruct;
+    }
+}
+exports.RefinedSource = RefinedSource;
+//# sourceMappingURL=refined-source.js.map

package/dist/lang/ast/elements/source.d.ts

@@ -0,0 +1,12 @@
+import { StructDef, StructRef } from "../../../model/malloy_types";
+import { MalloyElement } from "../types/malloy-element";
+import { HasParameter } from "../parameters/has-parameter";
+/**
+ * A "Source" is a thing which you can run queries against. The main
+ * function of a source is to represent an eventual StructDef
+ */
+export declare abstract class Source extends MalloyElement {
+    abstract structDef(): StructDef;
+    structRef(): StructRef;
+    withParameters(pList: HasParameter[] | undefined): StructDef;
+}

package/dist/lang/ast/elements/source.js

@@ -0,0 +1,53 @@
+"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.Source = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+/**
+ * A "Source" is a thing which you can run queries against. The main
+ * function of a source is to represent an eventual StructDef
+ */
+class Source extends malloy_element_1.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.Source = Source;
+//# sourceMappingURL=source.js.map

package/dist/lang/ast/error-factory.d.ts

@@ -0,0 +1,9 @@
+import { IndexSegment, ProjectSegment, Query, ReduceSegment, StructDef } from "../../model/malloy_types";
+export declare class ErrorFactory {
+    static get structDef(): StructDef;
+    static isErrorStructDef(s: StructDef): boolean;
+    static get query(): Query;
+    static get reduceSegment(): ReduceSegment;
+    static get projectSegment(): ProjectSegment;
+    static get indexSegment(): IndexSegment;
+}

package/dist/lang/ast/error-factory.js

@@ -0,0 +1,61 @@
+"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.ErrorFactory = void 0;
+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;
+//# sourceMappingURL=error-factory.js.map

package/dist/lang/ast/executors/index-executor.d.ts

@@ -0,0 +1,18 @@
+import { FilterExpression, PipeSegment, Sampling } from "../../../model/malloy_types";
+import { FieldName, FieldSpace } from "../types/field-space";
+import { Limit } from "../query-properties/limit";
+import { IndexFieldSpace } from "../field-space/index-field-space";
+import { QueryProperty } from "../types/query-property";
+import { Executor } from "../types/executor";
+import { QueryInputSpace } from "../field-space/query-spaces";
+export declare class IndexExecutor implements Executor {
+    filters: FilterExpression[];
+    limit?: Limit;
+    indexOn?: FieldName;
+    sample?: Sampling;
+    resultFS: IndexFieldSpace;
+    inputFS: QueryInputSpace;
+    constructor(inputFS: FieldSpace);
+    execute(qp: QueryProperty): void;
+    finalize(from: PipeSegment | undefined): PipeSegment;
+}

package/dist/lang/ast/executors/index-executor.js

@@ -0,0 +1,96 @@
+"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.IndexExecutor = void 0;
+const error_factory_1 = require("../error-factory");
+const filters_1 = require("../query-properties/filters");
+const indexing_1 = require("../query-properties/indexing");
+const limit_1 = require("../query-properties/limit");
+const sampling_1 = require("../query-properties/sampling");
+const index_field_space_1 = require("../field-space/index-field-space");
+class IndexExecutor {
+    constructor(inputFS) {
+        this.filters = [];
+        this.resultFS = new index_field_space_1.IndexFieldSpace(inputFS);
+        this.inputFS = this.resultFS.exprSpace;
+    }
+    execute(qp) {
+        if (qp instanceof filters_1.Filter) {
+            this.filters.push(...qp.getFilterList(this.inputFS));
+        }
+        else if (qp instanceof limit_1.Limit) {
+            if (this.limit) {
+                this.limit.log("Ignored, too many limit: statements");
+            }
+            this.limit = qp;
+        }
+        else if (qp instanceof indexing_1.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 sampling_1.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 error_factory_1.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;
+    }
+}
+exports.IndexExecutor = IndexExecutor;
+//# sourceMappingURL=index-executor.js.map

package/dist/lang/ast/executors/project-executor.d.ts

@@ -0,0 +1,10 @@
+import { PipeSegment } from "../../../model/malloy_types";
+import { FieldSpace } from "../types/field-space";
+import { ProjectFieldSpace } from "../field-space/project-field-space";
+import { QueryProperty } from "../types/query-property";
+import { ReduceExecutor } from "./reduce-executor";
+export declare class ProjectExecutor extends ReduceExecutor {
+    getResultSpace(fs: FieldSpace): ProjectFieldSpace;
+    execute(qp: QueryProperty): void;
+    finalize(fromSeg: PipeSegment | undefined): PipeSegment;
+}