@malloydata/malloy 0.0.304 → 0.0.305

package/dist/model/join_instance.d.ts

@@ -0,0 +1,18 @@
+import type { QueryStruct } from './query_node';
+import { QueryFieldBoolean } from './query_node';
+import type { JoinRelationship, UniqueKeyRequirement } from './malloy_types';
+import type { DialectFieldList } from '../dialect';
+export declare class JoinInstance {
+    queryStruct: QueryStruct;
+    alias: string;
+    parent: JoinInstance | undefined;
+    uniqueKeyRequirement?: UniqueKeyRequirement;
+    makeUniqueKey: boolean;
+    leafiest: boolean;
+    joinFilterConditions?: QueryFieldBoolean[];
+    children: JoinInstance[];
+    constructor(queryStruct: QueryStruct, alias: string, parent: JoinInstance | undefined);
+    parentRelationship(): 'root' | JoinRelationship;
+    forceAllSymmetricCalculations(): boolean;
+    getDialectFieldList(): DialectFieldList;
+}

package/dist/model/join_instance.js

@@ -0,0 +1,71 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinInstance = void 0;
+const query_node_1 = require("./query_node");
+const utils_1 = require("./utils");
+const malloy_types_1 = require("./malloy_types");
+class JoinInstance {
+    constructor(queryStruct, alias, parent) {
+        this.queryStruct = queryStruct;
+        this.alias = alias;
+        this.parent = parent;
+        this.makeUniqueKey = false;
+        this.leafiest = false;
+        this.children = [];
+        if (parent) {
+            parent.children.push(this);
+        }
+        // convert the filter list into a list of boolean fields so we can
+        //  generate dependancies and code for them.
+        const sd = this.queryStruct.structDef;
+        if ((0, malloy_types_1.isSourceDef)(sd) && sd.filterList) {
+            this.joinFilterConditions = sd.filterList.map(filter => new query_node_1.QueryFieldBoolean({
+                type: 'boolean',
+                name: 'ignoreme',
+                e: filter.e,
+            }, this.queryStruct));
+        }
+    }
+    parentRelationship() {
+        if (this.queryStruct.parent === undefined) {
+            return 'root';
+        }
+        const thisStruct = this.queryStruct.structDef;
+        if ((0, malloy_types_1.isJoined)(thisStruct)) {
+            switch (thisStruct.join) {
+                case 'one':
+                    return 'many_to_one';
+                case 'cross':
+                    return 'many_to_many';
+                case 'many':
+                    return 'one_to_many';
+            }
+        }
+        throw new Error(`Internal error unknown relationship type to parent for ${this.queryStruct.structDef.name}`);
+    }
+    // For now, we force all symmetric calculations for full and right joins
+    //  because we need distinct keys for COUNT(xx) operations.  Don't really need
+    //  this for sums.  This will produce correct results and we can optimize this
+    //  at some point..
+    forceAllSymmetricCalculations() {
+        if (this.queryStruct.parent === undefined) {
+            return false;
+        }
+        const thisStruct = this.queryStruct.structDef;
+        if ((0, malloy_types_1.isJoined)(thisStruct)) {
+            return (thisStruct.matrixOperation === 'right' ||
+                thisStruct.matrixOperation === 'full');
+        }
+        return false;
+    }
+    // postgres unnest needs to know the names of the physical fields.
+    getDialectFieldList() {
+        return (0, utils_1.getDialectFieldList)(this.queryStruct.structDef);
+    }
+}
+exports.JoinInstance = JoinInstance;
+//# sourceMappingURL=join_instance.js.map

package/dist/model/malloy_types.d.ts

@@ -426,6 +426,12 @@ export interface BasicArrayDef extends BasicArrayTypeDef, StructDefBase, JoinBas
     type: 'array';
     join: 'many';
 }
+/**
+ * Create a clean FieldDef from a TypeDef descendent
+ * @param atd Usually a TypeDesc
+ * @param name
+ * @returns Field with `name` and no type meta data
+ */
 export declare function mkFieldDef(atd: AtomicTypeDef, name: string): AtomicFieldDef;
 export declare function mkArrayDef(ofType: AtomicTypeDef, name: string): ArrayDef;
 export interface RecordTypeDef {
@@ -580,7 +586,24 @@ export interface RawSegment extends Filtered {
 export declare function isRawSegment(pe: PipeSegment): pe is RawSegment;
 export type IndexFieldDef = RefToField;
 export type SegmentFieldDef = IndexFieldDef | QueryFieldDef;
-export interface IndexSegment extends Filtered {
+/**
+ * The compiler needs to know a number of things computed for a query.
+ * We've modified the fieldUsage code from composite sources to collect
+ * the information needed by the compiler and a query is processed
+ * as a final step to append this information.
+ *
+ *   0) An ordered list list of active joins
+ *   1) Each field that is referenced, even indirectly
+ *   2) Each join path ending in a count
+ *   3) Each join path ending in an assymmetric aggregate
+ *   4) Each join path ending in an analytic funtion
+ */
+export interface SegmentUsageSummary {
+    activeJoins?: FieldUsage[];
+    expandedFieldUsage?: FieldUsage[];
+    expandedUngroupings?: AggregateUngrouping[];
+}
+export interface IndexSegment extends Filtered, SegmentUsageSummary {
     type: 'index';
     indexFields: IndexFieldDef[];
     limit?: number;
@@ -595,8 +618,11 @@ export declare function isIndexSegment(pe: PipeSegment): pe is IndexSegment;
 export interface FieldUsage {
     path: string[];
     at?: DocumentLocation;
+    uniqueKeyRequirement?: UniqueKeyRequirement;
+    analyticFunctionUse?: boolean;
 }
-export interface QuerySegment extends Filtered, Ordered {
+export declare function bareFieldUsage(fu: FieldUsage): boolean;
+export interface QuerySegment extends Filtered, Ordered, SegmentUsageSummary {
     type: 'reduce' | 'project' | 'partial';
     queryFields: QueryFieldDef[];
     extendSource?: FieldDef[];
@@ -617,6 +643,8 @@ export interface TurtleDef extends NamedObject, Pipeline {
     fieldUsage?: FieldUsage[];
     requiredGroupBys?: string[][];
 }
+export interface TurtleDefPlusFilters extends TurtleDef, Filtered {
+}
 interface StructDefBase extends HasLocation, NamedObject {
     type: string;
     annotation?: Annotation;
@@ -711,6 +739,9 @@ export interface AggregateUngrouping {
     ungroupedFields: string[][] | '*';
     fieldUsage: FieldUsage[];
     requiresGroupBy?: RequiredGroupBy[];
+    exclude: boolean;
+    path: string[];
+    refFields?: string[];
 }
 export type TypeInfo = {
     expressionType: ExpressionType;
@@ -964,4 +995,19 @@ export declare const TD: {
     isError: (td: UTD) => td is ErrorTypeDef;
     eq(x: UTD, y: UTD): boolean;
 };
+/**
+ * Aggregate functions carry this meta data. Used to determine if
+ * a function requires the existence of a unique key. This used
+ * be a pair of types: UniqueKeyUse and UniqueKeyPossibleUse.
+ *
+ * The three states are:
+ *
+ * 1. undefined - not recorded, symmetric  MIN/MAX/COUNT_DISTINCT
+ * 2. {isCount: true} - this is a COUNT aggregate
+ * 3. {isCount: false} - this is an asymmetric aggregate, SUM or AVG
+ */
+export type UniqueKeyRequirement = undefined | {
+    isCount: boolean;
+};
+export declare function mergeUniqueKeyRequirement(existing: UniqueKeyRequirement, newInfo: UniqueKeyRequirement): UniqueKeyRequirement;
 export {};

package/dist/model/malloy_types.js

@@ -72,6 +72,7 @@ exports.isSamplingPercent = isSamplingPercent;
 exports.isSamplingEnable = isSamplingEnable;
 exports.isRawSegment = isRawSegment;
 exports.isIndexSegment = isIndexSegment;
+exports.bareFieldUsage = bareFieldUsage;
 exports.isSegmentSQL = isSegmentSQL;
 exports.sourceBase = sourceBase;
 exports.isSourceDef = isSourceDef;
@@ -87,6 +88,7 @@ exports.isValueNumber = isValueNumber;
 exports.isValueBoolean = isValueBoolean;
 exports.isValueTimestamp = isValueTimestamp;
 exports.isValueDate = isValueDate;
+exports.mergeUniqueKeyRequirement = mergeUniqueKeyRequirement;
 function exprHasKids(e) {
     return 'kids' in e;
 }
@@ -236,6 +238,12 @@ function isCastType(s) {
 function fieldIsIntrinsic(f) {
     return isAtomicFieldType(f.type) && !hasExpression(f);
 }
+/**
+ * Create a clean FieldDef from a TypeDef descendent
+ * @param atd Usually a TypeDesc
+ * @param name
+ * @returns Field with `name` and no type meta data
+ */
 function mkFieldDef(atd, name) {
     if (isBasicArray(atd)) {
         return mkArrayDef(atd.elementTypeDef, name);
@@ -248,7 +256,24 @@ function mkFieldDef(atd, name) {
         const { type, fields } = atd;
         return { type, fields, join: 'one', name };
     }
-    return { ...atd, name };
+    const ret = { name, type: atd.type };
+    switch (atd.type) {
+        case 'sql native':
+            return { ...ret, rawType: atd.rawType };
+        case 'number': {
+            const numberType = atd.numberType;
+            return numberType ? { ...ret, numberType } : ret;
+        }
+        case 'date': {
+            const timeframe = atd.timeframe;
+            return timeframe ? { name, type: 'date', timeframe } : ret;
+        }
+        case 'timestamp': {
+            const timeframe = atd.timeframe;
+            return timeframe ? { name, type: 'timestamp', timeframe } : ret;
+        }
+    }
+    return ret;
 }
 function mkArrayDef(ofType, name) {
     if (ofType.type === 'record') {
@@ -365,6 +390,10 @@ function isRawSegment(pe) {
 function isIndexSegment(pe) {
     return pe.type === 'index';
 }
+function bareFieldUsage(fu) {
+    return (fu.uniqueKeyRequirement === undefined &&
+        fu.analyticFunctionUse === undefined);
+}
 function isSegmentSQL(f) {
     return 'sql' in f;
 }
@@ -510,5 +539,14 @@ exports.TD = {
         return x.type === y.type;
     },
 };
+function mergeUniqueKeyRequirement(existing, newInfo) {
+    if (!existing)
+        return newInfo;
+    if (!newInfo)
+        return existing;
+    return {
+        isCount: existing.isCount || newInfo.isCount,
+    };
+}
 // clang-format on
 //# sourceMappingURL=malloy_types.js.map

package/dist/model/query_model.d.ts

@@ -0,0 +1,2 @@
+export type { QueryModel, ParentQueryModel } from './query_model_contract';
+export { makeQueryModel, getResultStructDefForQuery } from './query_model_impl';

package/dist/model/query_model.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResultStructDefForQuery = exports.makeQueryModel = void 0;
+var query_model_impl_1 = require("./query_model_impl");
+Object.defineProperty(exports, "makeQueryModel", { enumerable: true, get: function () { return query_model_impl_1.makeQueryModel; } });
+Object.defineProperty(exports, "getResultStructDefForQuery", { enumerable: true, get: function () { return query_model_impl_1.getResultStructDefForQuery; } });
+//# sourceMappingURL=query_model.js.map

package/dist/model/query_model_contract.d.ts

@@ -0,0 +1,32 @@
+import type { Connection } from '../connection/types';
+import type { Dialect } from '../dialect';
+import type { EventStream } from '../runtime_types';
+import type { SourceDef, ModelDef, StructRef, Argument, PrepareResultOptions, CompiledQuery, SearchIndexResult, Query } from './malloy_types';
+import type { QueryStruct } from './query_node';
+import type { StageWriter } from './stage_writer';
+export interface ParentQueryModel {
+    model: QueryModel;
+}
+export interface QueryResults {
+    lastStageName: string;
+    stageWriter: StageWriter;
+    structs: SourceDef[];
+    malloy: string;
+    connectionName: string;
+}
+export interface QueryModel {
+    dialect: Dialect;
+    modelDef: ModelDef | undefined;
+    structs: Map<string, QueryStruct>;
+    eventStream?: EventStream;
+    loadModelFromDef(modelDef: ModelDef): void;
+    getStructByName(name: string): QueryStruct;
+    getStructFromRef(structRef: StructRef, sourceArguments: Record<string, Argument> | undefined, prepareResultOptions?: PrepareResultOptions | undefined): QueryStruct;
+    loadQuery(query: Query, stageWriter: StageWriter | undefined, prepareResultOptions: PrepareResultOptions | undefined, emitFinalStage: boolean | undefined, isJoinedSubquery: boolean | undefined): QueryResults;
+    addDefaultRowLimit(query: Query, defaultRowLimit?: number): {
+        query: Query;
+        addedDefaultRowLimit?: number;
+    };
+    compileQuery(query: Query, prepareResultOptions: PrepareResultOptions | undefined, finalize: boolean | undefined): CompiledQuery;
+    searchIndex(connection: Connection, explore: string, searchValue: string, limit: number, searchField: string | undefined): Promise<SearchIndexResult[] | undefined>;
+}

package/dist/model/query_model_contract.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=query_model_contract.js.map

package/dist/model/query_model_impl.d.ts

@@ -0,0 +1,30 @@
+import type { ModelDef, StructRef, Argument, PrepareResultOptions, Query, SourceDef, SearchIndexResult, CompiledQuery, TurtleDef } from './malloy_types';
+import { StageWriter } from './stage_writer';
+import { type Dialect } from '../dialect';
+import type { EventStream } from '../runtime_types';
+import type { Connection } from '../connection/types';
+import type { ModelRootInterface } from './query_node';
+import { QueryStruct } from './query_node';
+import type { QueryModel, QueryResults } from './query_model_contract';
+export declare function makeQueryModel(modelDef: ModelDef | undefined, eventStream?: EventStream): QueryModel;
+export declare class QueryModelImpl implements QueryModel, ModelRootInterface {
+    readonly eventStream?: EventStream | undefined;
+    dialect: Dialect;
+    modelDef: ModelDef | undefined;
+    structs: Map<string, QueryStruct>;
+    constructor(modelDef: ModelDef | undefined, eventStream?: EventStream | undefined);
+    getFinalOutputStruct(query: Query, options: PrepareResultOptions | undefined): SourceDef | undefined;
+    loadModelFromDef(modelDef: ModelDef): void;
+    getStructByName(name: string): QueryStruct;
+    getStructFromRef(structRef: StructRef, sourceArguments: Record<string, Argument> | undefined, prepareResultOptions?: PrepareResultOptions): QueryStruct;
+    loadQuery(query: Query, stageWriter: StageWriter | undefined, prepareResultOptions?: PrepareResultOptions, emitFinalStage?: boolean, isJoinedSubquery?: boolean): QueryResults;
+    addDefaultRowLimit(query: Query, defaultRowLimit?: number): {
+        query: Query;
+        addedDefaultRowLimit?: number;
+    };
+    compileQuery(query: Query, prepareResultOptions?: PrepareResultOptions, finalize?: boolean): CompiledQuery;
+    exploreSearchSQLMap: Map<any, any>;
+    searchIndex(connection: Connection, explore: string, searchValue: string, limit?: number, searchField?: string | undefined): Promise<SearchIndexResult[] | undefined>;
+}
+export declare function getResultStructDefForQuery(model: ModelDef, query: Query): SourceDef;
+export declare function getResultStructDefForView(source: SourceDef, view: TurtleDef): SourceDef;

package/dist/model/query_model_impl.js

@@ -0,0 +1,266 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryModelImpl = void 0;
+exports.makeQueryModel = makeQueryModel;
+exports.getResultStructDefForQuery = getResultStructDefForQuery;
+exports.getResultStructDefForView = getResultStructDefForView;
+const query_query_1 = require("./query_query");
+const malloy_types_1 = require("./malloy_types");
+const stage_writer_1 = require("./stage_writer");
+const dialect_1 = require("../dialect");
+const utils_1 = require("./materialization/utils");
+const query_node_1 = require("./query_node");
+function makeQueryModel(modelDef, eventStream) {
+    return new QueryModelImpl(modelDef, eventStream);
+}
+class QueryModelImpl {
+    constructor(modelDef, eventStream) {
+        this.eventStream = eventStream;
+        this.dialect = new dialect_1.StandardSQLDialect();
+        // dialect: Dialect = new PostgresDialect();
+        this.modelDef = undefined;
+        this.structs = new Map();
+        this.exploreSearchSQLMap = new Map();
+        if (modelDef) {
+            this.loadModelFromDef(modelDef);
+        }
+    }
+    // Another circularity breaking method ... call into QueryQuery
+    // to find the output shape of a query
+    getFinalOutputStruct(query, options) {
+        const result = this.loadQuery(query, undefined, options, false, false);
+        return result.structs.pop();
+    }
+    loadModelFromDef(modelDef) {
+        this.modelDef = modelDef;
+        for (const s of Object.values(this.modelDef.contents)) {
+            let qs;
+            if ((0, malloy_types_1.isSourceDef)(s)) {
+                qs = new query_node_1.QueryStruct(s, undefined, { model: this }, {});
+                this.structs.set((0, malloy_types_1.getIdentifier)(s), qs);
+                qs.resolveQueryFields((query, options) => this.getFinalOutputStruct(query, options));
+            }
+            else if (s.type === 'query') {
+                /* TODO */
+            }
+            else {
+                throw new Error('Internal Error: Unknown structure type');
+            }
+        }
+    }
+    getStructByName(name) {
+        const s = this.structs.get(name);
+        if (s) {
+            return s;
+        }
+        throw new Error(`Struct ${name} not found in model.`);
+    }
+    getStructFromRef(structRef, sourceArguments, prepareResultOptions) {
+        prepareResultOptions !== null && prepareResultOptions !== void 0 ? prepareResultOptions : (prepareResultOptions = {});
+        if (typeof structRef === 'string') {
+            const ret = this.getStructByName(structRef);
+            if (sourceArguments !== undefined) {
+                return new query_node_1.QueryStruct(ret.structDef, sourceArguments, ret.parent ? { struct: ret.parent } : { model: this }, prepareResultOptions);
+            }
+            return ret;
+        }
+        return new query_node_1.QueryStruct(structRef, sourceArguments, { model: this }, prepareResultOptions);
+    }
+    loadQuery(query, stageWriter, prepareResultOptions, emitFinalStage = false, isJoinedSubquery = false) {
+        var _a;
+        const malloy = '';
+        if (!stageWriter) {
+            stageWriter = new stage_writer_1.StageWriter(true, undefined);
+        }
+        const turtleDef = {
+            type: 'turtle',
+            name: 'ignoreme',
+            pipeline: query.pipeline,
+            filterList: query.filterList,
+        };
+        const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
+        const q = query_query_1.QueryQuery.makeQuery(turtleDef, this.getStructFromRef(structRef, query.sourceArguments, prepareResultOptions), stageWriter, isJoinedSubquery, (name) => this.structs.get(name));
+        const ret = q.generateSQLFromPipeline(stageWriter);
+        if (emitFinalStage && q.parent.dialect.hasFinalStage) {
+            // const fieldNames: string[] = [];
+            // for (const f of ret.outputStruct.fields) {
+            //   fieldNames.push(getIdentifier(f));
+            // }
+            const fieldNames = [];
+            for (const f of ret.outputStruct.fields) {
+                if ((0, malloy_types_1.isAtomic)(f)) {
+                    const quoted = q.parent.dialect.sqlMaybeQuoteIdentifier(f.name);
+                    fieldNames.push(quoted);
+                }
+            }
+            // const fieldNames = getAtomicFields(ret.outputStruct).map(fieldDef =>
+            //   q.parent.dialect.sqlMaybeQuoteIdentifier(fieldDef.name)
+            // );
+            ret.lastStageName = stageWriter.addStage(q.parent.dialect.sqlFinalStage(ret.lastStageName, fieldNames));
+        }
+        return {
+            lastStageName: ret.lastStageName,
+            malloy,
+            stageWriter,
+            structs: [ret.outputStruct],
+            connectionName: q.parent.connectionName,
+        };
+    }
+    addDefaultRowLimit(query, defaultRowLimit) {
+        const nope = { query, addedDefaultRowLimit: undefined };
+        if (defaultRowLimit === undefined)
+            return nope;
+        const lastSegment = query.pipeline[query.pipeline.length - 1];
+        if (lastSegment.type === 'raw')
+            return nope;
+        if (lastSegment.limit !== undefined)
+            return nope;
+        return {
+            query: {
+                ...query,
+                pipeline: [
+                    ...query.pipeline.slice(0, -1),
+                    {
+                        ...lastSegment,
+                        limit: defaultRowLimit,
+                    },
+                ],
+            },
+            addedDefaultRowLimit: defaultRowLimit,
+        };
+    }
+    compileQuery(query, prepareResultOptions, finalize = true) {
+        var _a, _b, _c;
+        let newModel;
+        const addDefaultRowLimit = this.addDefaultRowLimit(query, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.defaultRowLimit);
+        query = addDefaultRowLimit.query;
+        const addedDefaultRowLimit = addDefaultRowLimit.addedDefaultRowLimit;
+        const m = newModel || this;
+        const ret = m.loadQuery(query, undefined, prepareResultOptions, finalize, false);
+        const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
+        const sourceExplore = typeof structRef === 'string'
+            ? structRef
+            : structRef.as || structRef.name;
+        const sourceArguments = (_b = query.sourceArguments) !== null && _b !== void 0 ? _b : (typeof structRef === 'string' ? undefined : structRef.arguments);
+        // LTNote:  I don't understand why this might be here.  It should have happened in loadQuery...
+        if (finalize && this.dialect.hasFinalStage) {
+            ret.lastStageName = ret.stageWriter.addStage(
+            // note this will be broken on duckDB waiting on a real fix.
+            this.dialect.sqlFinalStage(ret.lastStageName, []));
+        }
+        return {
+            lastStageName: ret.lastStageName,
+            malloy: ret.malloy,
+            sql: ret.stageWriter.generateSQLStages(),
+            dependenciesToMaterialize: ret.stageWriter.dependenciesToMaterialize,
+            materialization: (0, utils_1.shouldMaterialize)(query.annotation)
+                ? (0, utils_1.buildQueryMaterializationSpec)((_c = query.location) === null || _c === void 0 ? void 0 : _c.url, query.name, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.materializedTablePrefix)
+                : undefined,
+            structs: ret.structs,
+            sourceExplore,
+            sourceFilters: query.filterList,
+            sourceArguments,
+            queryName: query.name,
+            connectionName: ret.connectionName,
+            annotation: query.annotation,
+            queryTimezone: ret.structs[0].queryTimezone,
+            defaultRowLimitAdded: addedDefaultRowLimit,
+        };
+    }
+    async searchIndex(connection, explore, searchValue, limit = 1000, searchField = undefined) {
+        if (!connection.canPersist()) {
+            return undefined;
+        }
+        // make a search index if one isn't modelled.
+        const struct = this.getStructByName(explore);
+        const d = struct.dialect;
+        let indexStar = [];
+        for (const [fn, fv] of struct.nameMap) {
+            if ((0, query_node_1.isScalarField)(fv) && fv.includeInWildcard()) {
+                indexStar.push({ type: 'fieldref', path: [fn] });
+            }
+        }
+        indexStar = indexStar.sort((a, b) => a.path[0].localeCompare(b.path[0]));
+        const indexQuery = {
+            structRef: explore,
+            pipeline: [
+                {
+                    type: 'index',
+                    indexFields: indexStar,
+                    sample: d.defaultSampling,
+                    outputStruct: {
+                        type: 'query_result',
+                        name: 'index',
+                        connection: struct.connectionName,
+                        dialect: struct.dialect.name,
+                        fields: [
+                            { name: 'fieldName', type: 'string' },
+                            { name: 'fieldPath', type: 'string' },
+                            { name: 'fieldType', type: 'string' },
+                            { name: 'weight', type: 'number' },
+                            { name: 'fieldValue', type: 'string' },
+                        ],
+                    },
+                },
+            ],
+        };
+        const fieldNameColumn = d.sqlMaybeQuoteIdentifier('fieldName');
+        const fieldPathColumn = d.sqlMaybeQuoteIdentifier('fieldPath');
+        const fieldValueColumn = d.sqlMaybeQuoteIdentifier('fieldValue');
+        const fieldTypeColumn = d.sqlMaybeQuoteIdentifier('fieldType');
+        const weightColumn = d.sqlMaybeQuoteIdentifier('weight');
+        // if we've compiled the SQL before use it otherwise
+        let sqlPDT = this.exploreSearchSQLMap.get(explore);
+        if (sqlPDT === undefined) {
+            sqlPDT = this.compileQuery(indexQuery, undefined, false).sql;
+            this.exploreSearchSQLMap.set(explore, sqlPDT);
+        }
+        let query = `SELECT
+              ${fieldNameColumn},
+              ${fieldPathColumn},
+              ${fieldValueColumn},
+              ${fieldTypeColumn},
+              ${weightColumn},
+              CASE WHEN lower(${fieldValueColumn}) LIKE lower(${d.sqlLiteralString(searchValue + '%')}) THEN 1 ELSE 0 END as match_first
+            FROM  ${await connection.manifestTemporaryTable(sqlPDT)}
+            WHERE lower(${fieldValueColumn}) LIKE lower(${d.sqlLiteralString('%' + searchValue + '%')}) ${searchField !== undefined
+            ? ` AND ${fieldNameColumn} = '` + searchField + "' \n"
+            : ''}
+            ORDER BY CASE WHEN lower(${fieldValueColumn}) LIKE  lower(${d.sqlLiteralString(searchValue + '%')}) THEN 1 ELSE 0 END DESC, ${weightColumn} DESC
+            LIMIT ${limit}
+          `;
+        if (d.hasFinalStage) {
+            query = `WITH __stage0 AS(\n${query}\n)\n${d.sqlFinalStage('__stage0', [
+                fieldNameColumn,
+                fieldPathColumn,
+                fieldValueColumn,
+                fieldTypeColumn,
+                weightColumn,
+                'match_first',
+            ])}`;
+        }
+        const result = await connection.runSQL(query, {
+            rowLimit: 1000,
+        });
+        return result.rows;
+    }
+}
+exports.QueryModelImpl = QueryModelImpl;
+function getResultStructDefForQuery(model, query) {
+    const queryModel = makeQueryModel(model);
+    const compiled = queryModel.compileQuery(query, undefined, true);
+    return compiled.structs[compiled.structs.length - 1];
+}
+function getResultStructDefForView(source, view) {
+    const qs = new query_node_1.QueryStruct(source, undefined, {
+        model: makeQueryModel(undefined),
+    }, {});
+    const queryQueryQuery = query_query_1.QueryQuery.makeQuery(view, qs, new stage_writer_1.StageWriter(true, undefined), // stage write indicates we want to get a result.
+    false, () => undefined);
+    return queryQueryQuery.getResultStructDef();
+}
+//# sourceMappingURL=query_model_impl.js.map