@malloydata/malloy 0.0.22-dev230207182613 → 0.0.22-dev230207183024

package/dist/model/malloy_query.js

@@ -24,8 +24,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flattenQuery = exports.QueryModel = exports.Segment = void 0;
 const lodash_1 = require("lodash");
-const standardsql_1 = require("../dialect/standardsql");
 const dialect_1 = require("../dialect");
+const standardsql_1 = require("../dialect/standardsql");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 // quote a string for SQL use.  Perhaps should be in dialect.
@@ -84,7 +84,7 @@ class StageWriter {
     //  return SQL and the last stage name
     combineStages(includeLastStage) {
         if (!this.useCTE) {
-            return { sql: this.withs[0], lastStageName: this.withs[0] };
+            return { "sql": this.withs[0], "lastStageName": this.withs[0] };
         }
         let lastStageName = this.getName(0);
         let prefix = `WITH `;
@@ -98,7 +98,7 @@ class StageWriter {
             w += `${prefix}${lastStageName} AS (\n${(0, utils_1.indent)(sql)})\n`;
             prefix = ", ";
         }
-        return { sql: w, lastStageName };
+        return { "sql": w, lastStageName };
     }
     /** emit the SQL for all the stages.  */
     generateSQLStages() {
@@ -362,16 +362,15 @@ class QueryField extends QueryNode {
         for (const ordering of orderByDef) {
             if (typeof ordering.field === "string") {
                 orderingField = {
-                    name: ordering.field,
-                    fif: resultStruct.getField(ordering.field),
+                    "name": ordering.field,
+                    "fif": resultStruct.getField(ordering.field)
                 };
             }
             else {
                 orderingField = resultStruct.getFieldByNumber(ordering.field);
             }
             if (resultStruct.firstSegment.type === "reduce") {
-                obSQL.push(" " +
-                    orderingField.fif.getSQL() +
+                obSQL.push(` ${orderingField.fif.getSQL()}` +
                     // this.parent.dialect.sqlMaybeQuoteIdentifier(
                     //   `${orderingField.name}__${resultStruct.groupSet}`
                     // ) +
@@ -481,7 +480,7 @@ class QueryField extends QueryNode {
                 this.parent.fieldDef.structSource.type === "inline" ||
                 (this.parent.fieldDef.structSource.type === "sql" &&
                     this.parent.fieldDef.structSource.method === "nested"), this.parent.fieldDef.structRelationship.type === "nested" &&
-                this.parent.fieldDef.structRelationship.isArray),
+                this.parent.fieldDef.structRelationship.isArray)
         ];
     }
     generateExpression(resultSet) {
@@ -532,17 +531,17 @@ class QueryFieldStruct extends QueryAtomicField {
     getAsJoinedStructDef(foreignKeyName) {
         return {
             ...this.parent.fieldDef,
-            structRelationship: {
-                type: "one",
-                onExpression: [
+            "structRelationship": {
+                "type": "one",
+                "onExpression": [
                     {
-                        type: "field",
-                        path: this.primaryKey,
+                        "type": "field",
+                        "path": this.primaryKey
                     },
                     "=",
-                    { type: "field", path: foreignKeyName },
-                ],
-            },
+                    { "type": "field", "path": foreignKeyName }
+                ]
+            }
         };
     }
 }
@@ -553,7 +552,7 @@ class QueryFieldDate extends QueryAtomicField {
             return super.generateExpression(resultSet);
         }
         else {
-            const truncated = this.parent.dialect.sqlTrunc({ value: this.getExpr(), valueType: "date" }, fd.timeframe);
+            const truncated = this.parent.dialect.sqlTrunc({ "value": this.getExpr(), "valueType": "date" }, fd.timeframe);
             return this.generateExpressionFromExpr(resultSet, this.parent, truncated);
         }
     }
@@ -561,8 +560,8 @@ class QueryFieldDate extends QueryAtomicField {
     getChildByName(name) {
         const fieldDef = {
             ...this.fieldDef,
-            as: `${this.getIdentifier()}_${name}`,
-            timeframe: name,
+            "as": `${this.getIdentifier()}_${name}`,
+            "timeframe": name
         };
         return new QueryFieldDate(fieldDef, this.parent);
     }
@@ -572,8 +571,8 @@ class QueryFieldTimestamp extends QueryAtomicField {
     getChildByName(name) {
         const fieldDef = {
             ...this.fieldDef,
-            as: `${this.getIdentifier()}_${name}`,
-            timeframe: name,
+            "as": `${this.getIdentifier()}_${name}`,
+            "timeframe": name
         };
         return new QueryFieldTimestamp(fieldDef, this.parent);
     }
@@ -709,7 +708,7 @@ class FieldInstanceResult {
             if (fi instanceof FieldInstanceField) {
                 if (fi.fieldUsage.type === "result" &&
                     fi.fieldUsage.resultIndex === index) {
-                    return { name, fif: fi };
+                    return { name, "fif": fi };
                 }
             }
         }
@@ -818,16 +817,16 @@ class FieldInstanceResult {
                 if (fi.fieldUsage.type === "result") {
                     firstField || (firstField = fi.fieldUsage.resultIndex);
                     if (["date", "timestamp"].indexOf(fi.f.fieldDef.type) > -1) {
-                        return [{ dir: "desc", field: fi.fieldUsage.resultIndex }];
+                        return [{ "dir": "desc", "field": fi.fieldUsage.resultIndex }];
                     }
                     else if (isCalculatedField(fi.f)) {
-                        return [{ dir: "desc", field: fi.fieldUsage.resultIndex }];
+                        return [{ "dir": "desc", "field": fi.fieldUsage.resultIndex }];
                     }
                 }
             }
         }
         if (firstField) {
-            return [{ dir: "asc", field: firstField }];
+            return [{ "dir": "asc", "field": firstField }];
         }
         return [];
     }
@@ -859,7 +858,7 @@ class FieldInstanceResult {
             joinStack.indexOf(name) === -1) {
             query.addDependantExpr(this, qs.parent, sr.onExpression, [
                 ...joinStack,
-                name,
+                name
             ]);
         }
         if (!(join = this.root().joins.get(name))) {
@@ -1030,9 +1029,9 @@ class JoinInstance {
             this.joinFilterConditions = [];
             for (const filter of this.queryStruct.fieldDef.filterList) {
                 const qf = new QueryFieldBoolean({
-                    type: "boolean",
-                    name: "ignoreme",
-                    e: filter.expression,
+                    "type": "boolean",
+                    "name": "ignoreme",
+                    "e": filter.expression
                 }, this.queryStruct);
                 this.joinFilterConditions.push(qf);
             }
@@ -1062,9 +1061,9 @@ class JoinInstance {
         const dialectFieldList = [];
         for (const f of this.queryStruct.fieldDef.fields.filter(malloy_types_1.isPhysical)) {
             dialectFieldList.push({
-                type: f.type,
-                sqlExpression: (0, malloy_types_1.getIdentifier)(f),
-                sqlOutputName: (0, malloy_types_1.getIdentifier)(f),
+                "type": f.type,
+                "sqlExpression": (0, malloy_types_1.getIdentifier)(f),
+                "sqlOutputName": (0, malloy_types_1.getIdentifier)(f)
             });
         }
         return dialectFieldList;
@@ -1082,12 +1081,12 @@ class Segment {
     // static nextStructDef(s: StructDef, q: AnonymousQueryDef): StructDef
     static nextStructDef(structDef, segment) {
         const qs = new QueryStruct(structDef, {
-            model: new QueryModel(undefined),
+            "model": new QueryModel(undefined)
         });
         const turtleDef = {
-            type: "turtle",
-            name: "ignoreme",
-            pipeline: [segment],
+            "type": "turtle",
+            "name": "ignoreme",
+            "pipeline": [segment]
         };
         const queryQueryQuery = QueryQuery.makeQuery(turtleDef, qs, new StageWriter(true, undefined) // stage write indicates we want to get a result.
         );
@@ -1121,17 +1120,20 @@ class QueryQuery extends QueryField {
             firstStage.extendSource !== undefined) {
             parent = new QueryStruct({
                 ...parentStruct.fieldDef,
-                fields: [...parentStruct.fieldDef.fields, ...firstStage.extendSource],
-            }, parent.parent ? { struct: parent } : { model: parent.model });
+                "fields": [
+                    ...parentStruct.fieldDef.fields,
+                    ...firstStage.extendSource
+                ]
+            }, parent.parent ? { "struct": parent } : { "model": parent.model });
             flatTurtleDef = {
                 ...flatTurtleDef,
-                pipeline: [
+                "pipeline": [
                     {
                         ...firstStage,
-                        extendSource: undefined,
+                        "extendSource": undefined
                     },
-                    ...flatTurtleDef.pipeline.slice(1),
-                ],
+                    ...flatTurtleDef.pipeline.slice(1)
+                ]
             };
         }
         switch (firstStage.type) {
@@ -1299,9 +1301,9 @@ class QueryQuery extends QueryField {
                     const key = expr.fields.sort().join("|") + expr.type;
                     if (resultStruct.ungroupedSets.get(key) === undefined) {
                         resultStruct.ungroupedSets.set(key, {
-                            type: expr.type,
-                            fields: expr.fields,
-                            groupSet: -1,
+                            "type": expr.type,
+                            "fields": expr.fields,
+                            "groupSet": -1
                         });
                     }
                 }
@@ -1395,7 +1397,7 @@ class QueryQuery extends QueryField {
             else if (field instanceof QueryAtomicField) {
                 resultStruct.addField(as, field, {
                     resultIndex,
-                    type: "result",
+                    "type": "result"
                 });
                 this.addDependancies(resultStruct, field);
                 if (isCalculatedField(field)) {
@@ -1478,7 +1480,8 @@ class QueryQuery extends QueryField {
             if (fi.fieldUsage.type === "result") {
                 const fieldDef = fi.f.fieldDef;
                 let filterList;
-                const sourceField = fi.f.parent.getFullOutputName() + (fieldDef.name || fieldDef.as);
+                const sourceField = fi.f.parent.getFullOutputName() +
+                    (fieldDef.name || fieldDef.as || "undefined");
                 const sourceExpression = fieldDef.code;
                 const sourceClasses = [sourceField];
                 if (isCalculatedField(fi.f)) {
@@ -1488,7 +1491,7 @@ class QueryQuery extends QueryField {
                         sourceExpression,
                         filterList,
                         sourceClasses,
-                        fieldKind: "measure",
+                        "fieldKind": "measure"
                     };
                 }
                 if (isScalarField(fi.f)) {
@@ -1497,7 +1500,7 @@ class QueryQuery extends QueryField {
                         sourceExpression,
                         filterList,
                         sourceClasses,
-                        fieldKind: "dimension",
+                        "fieldKind": "dimension"
                     };
                 }
                 else {
@@ -1516,8 +1519,8 @@ class QueryQuery extends QueryField {
                     sourceField,
                     filterList,
                     sourceClasses,
-                    fieldKind: "struct",
-                    limit,
+                    "fieldKind": "struct",
+                    limit
                 };
             }
         }
@@ -1538,11 +1541,11 @@ class QueryQuery extends QueryField {
                 const resultType = fi.getRepeatedResultType() === "nested" ? "nested" : "inline";
                 structDef.name = name;
                 structDef.structRelationship = {
-                    field: name,
-                    type: resultType,
-                    isArray: false,
+                    "field": name,
+                    "type": resultType,
+                    "isArray": false
                 };
-                structDef.structSource = { type: resultType };
+                structDef.structSource = { "type": resultType };
                 structDef.resultMetadata = resultMetadata;
                 fields.push(structDef);
             }
@@ -1570,9 +1573,9 @@ class QueryQuery extends QueryField {
                         case "string":
                             fields.push({
                                 name,
-                                type: fi.f.fieldDef.type,
+                                "type": fi.f.fieldDef.type,
                                 resultMetadata,
-                                location,
+                                location
                             });
                             break;
                         case "timestamp": {
@@ -1585,10 +1588,10 @@ class QueryQuery extends QueryField {
                                 case "day":
                                     fields.push({
                                         name,
-                                        type: "date",
+                                        "type": "date",
                                         timeframe,
                                         resultMetadata,
-                                        location,
+                                        location
                                     });
                                     break;
                                 case "second":
@@ -1596,18 +1599,18 @@ class QueryQuery extends QueryField {
                                 case "hour":
                                     fields.push({
                                         name,
-                                        type: "timestamp",
+                                        "type": "timestamp",
                                         timeframe,
                                         resultMetadata,
-                                        location,
+                                        location
                                     });
                                     break;
                                 default:
                                     fields.push({
                                         name,
-                                        type: "timestamp",
+                                        "type": "timestamp",
                                         resultMetadata,
-                                        location,
+                                        location
                                     });
                                     break;
                             }
@@ -1616,20 +1619,20 @@ class QueryQuery extends QueryField {
                         case "date": {
                             fields.push({
                                 name,
-                                type: fi.f.fieldDef.type,
-                                timeframe: fi.f.fieldDef.timeframe,
+                                "type": fi.f.fieldDef.type,
+                                "timeframe": fi.f.fieldDef.timeframe,
                                 resultMetadata,
-                                location,
+                                location
                             });
                             break;
                         }
                         case "number":
                             fields.push({
                                 name,
-                                numberType: fi.f.fieldDef.numberType,
-                                type: "number",
+                                "numberType": fi.f.fieldDef.numberType,
+                                "type": "number",
                                 resultMetadata,
-                                location,
+                                location
                             });
                             break;
                         default:
@@ -1640,16 +1643,16 @@ class QueryQuery extends QueryField {
         }
         return {
             fields,
-            name: this.resultStage || "result",
-            dialect: this.parent.dialect.name,
+            "name": this.resultStage || "result",
+            "dialect": this.parent.dialect.name,
             primaryKey,
-            structRelationship: {
-                type: "basetable",
-                connectionName: this.parent.connectionName,
+            "structRelationship": {
+                "type": "basetable",
+                "connectionName": this.parent.connectionName
             },
-            structSource: { type: "query_result" },
-            resultMetadata: this.getResultMetadata(this.rootResult),
-            type: "struct",
+            "structSource": { "type": "query_result" },
+            "resultMetadata": this.getResultMetadata(this.rootResult),
+            "type": "struct"
         };
     }
     generateSQLJoinBlock(stageWriter, ji) {
@@ -1667,9 +1670,9 @@ class QueryQuery extends QueryField {
             }
             if (structRelationship.onExpression) {
                 onCondition = new QueryFieldBoolean({
-                    type: "boolean",
-                    name: "ignoreme",
-                    e: structRelationship.onExpression,
+                    "type": "boolean",
+                    "name": "ignoreme",
+                    "e": structRelationship.onExpression
                 }, qs.parent).generateExpression(this.rootResult);
             }
             else {
@@ -1951,12 +1954,12 @@ class QueryQuery extends QueryField {
         let from = this.generateSQLJoins(stageWriter);
         const wheres = this.generateSQLWhereTurtled();
         const f = {
-            dimensionIndexes: [1],
-            fieldIndex: 2,
-            sql: ["group_set"],
-            lateralJoinSQLExpressions: [],
-            groupsAggregated: [],
-            outputPipelinedSQL: [],
+            "dimensionIndexes": [1],
+            "fieldIndex": 2,
+            "sql": ["group_set"],
+            "lateralJoinSQLExpressions": [],
+            "groupsAggregated": [],
+            "outputPipelinedSQL": []
         };
         this.generateStage0Fields(this.rootResult, f, stageWriter);
         if (this.firstSegment.type === "project") {
@@ -2003,8 +2006,8 @@ class QueryQuery extends QueryField {
                 else if (fi.depth === depth) {
                     const s = this.generateTurtleSQL(fi, stageWriter, sqlFieldName, output.outputPipelinedSQL);
                     output.groupsAggregated.push({
-                        fromGroup: fi.groupSet,
-                        toGroup: resultSet.groupSet,
+                        "fromGroup": fi.groupSet,
+                        "toGroup": resultSet.groupSet
                     });
                     groupsToMap.push(fi.groupSet);
                     output.sql.push(`${s} as ${sqlFieldName}`);
@@ -2026,12 +2029,12 @@ class QueryQuery extends QueryField {
     generateSQLDepthN(depth, stageWriter, stageName) {
         let s = "SELECT \n";
         const f = {
-            dimensionIndexes: [1],
-            fieldIndex: 2,
-            sql: ["group_set"],
-            lateralJoinSQLExpressions: [],
-            groupsAggregated: [],
-            outputPipelinedSQL: [],
+            "dimensionIndexes": [1],
+            "fieldIndex": 2,
+            "sql": ["group_set"],
+            "lateralJoinSQLExpressions": [],
+            "groupsAggregated": [],
+            "outputPipelinedSQL": []
         };
         this.generateDepthNFields(depth, this.rootResult, f, stageWriter);
         s += (0, utils_1.indent)(f.sql.join(",\n")) + "\n";
@@ -2109,8 +2112,8 @@ class QueryQuery extends QueryField {
         for (const ordering of orderByDef) {
             if (typeof ordering.field === "string") {
                 orderingField = {
-                    name: ordering.field,
-                    fif: resultStruct.getField(ordering.field),
+                    "name": ordering.field,
+                    "fif": resultStruct.getField(ordering.field)
                 };
             }
             else {
@@ -2138,11 +2141,11 @@ class QueryQuery extends QueryField {
                 // fieldsSQL.push(`${name}__${resultStruct.groupSet} as ${sqlName}`);
                 // outputFieldNames.push(name);
                 dialectFieldList.push({
-                    type: field instanceof FieldInstanceField
+                    "type": field instanceof FieldInstanceField
                         ? field.f.fieldDef.type
                         : "struct",
-                    sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
-                    sqlOutputName: sqlName,
+                    "sqlExpression": this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                    "sqlOutputName": sqlName
                 });
             }
             else if (resultStruct.firstSegment.type === "project" &&
@@ -2152,9 +2155,9 @@ class QueryQuery extends QueryField {
                 //   `${field.f.generateExpression(resultStruct)} as ${sqlName}`
                 // );
                 dialectFieldList.push({
-                    type: field.type,
-                    sqlExpression: field.f.generateExpression(resultStruct),
-                    sqlOutputName: sqlName,
+                    "type": field.type,
+                    "sqlExpression": field.f.generateExpression(resultStruct),
+                    "sqlOutputName": sqlName
                 });
             }
         }
@@ -2183,7 +2186,7 @@ class QueryQuery extends QueryField {
             else {
                 outputPipelinedSQL.push({
                     sqlFieldName,
-                    pipelineSQL: `(${sql})`,
+                    "pipelineSQL": `(${sql})`
                 });
             }
         }
@@ -2201,14 +2204,14 @@ class QueryQuery extends QueryField {
             const pipeline = [...fi.turtleDef.pipeline];
             pipeline.shift();
             const newTurtle = {
-                type: "turtle",
-                name: "starthere",
-                pipeline,
+                "type": "turtle",
+                "name": "starthere",
+                pipeline
             };
             structDef.name = this.parent.dialect.sqlUnnestPipelineHead(repeatedResultType === "inline_all_numbers", sourceSQLExpression);
-            structDef.structSource = { type: "sql", method: "nested" };
+            structDef.structSource = { "type": "sql", "method": "nested" };
             const qs = new QueryStruct(structDef, {
-                model: this.parent.getModel(),
+                "model": this.parent.getModel()
             });
             const q = QueryQuery.makeQuery(newTurtle, qs, stageWriter);
             pipeOut = q.generateSQLFromPipeline(stageWriter);
@@ -2217,7 +2220,7 @@ class QueryQuery extends QueryField {
         }
         return {
             structDef,
-            pipeOut,
+            pipeOut
         };
     }
     generateComplexSQL(stageWriter) {
@@ -2260,20 +2263,20 @@ class QueryQuery extends QueryField {
             const pipeline = [...this.fieldDef.pipeline];
             let structDef = {
                 ...outputStruct,
-                structSource: { type: "sql", method: "lastStage" },
+                "structSource": { "type": "sql", "method": "lastStage" }
             };
             pipeline.shift();
             for (const transform of pipeline) {
                 const s = new QueryStruct(structDef, {
-                    model: this.parent.getModel(),
+                    "model": this.parent.getModel()
                 });
-                const q = QueryQuery.makeQuery({ type: "turtle", name: "ignoreme", pipeline: [transform] }, s, stageWriter);
+                const q = QueryQuery.makeQuery({ "type": "turtle", "name": "ignoreme", "pipeline": [transform] }, s, stageWriter);
                 q.prepare(stageWriter);
                 lastStageName = q.generateSQL(stageWriter);
                 outputStruct = q.getResultStructDef();
                 structDef = {
                     ...outputStruct,
-                    structSource: { type: "sql", method: "lastStage" },
+                    "structSource": { "type": "sql", "method": "lastStage" }
                 };
             }
         }
@@ -2295,7 +2298,7 @@ class QueryQueryIndexStage extends QueryQuery {
     // get a field ref and expand it.
     expandField(f) {
         const field = this.parent.getFieldByName(f);
-        return { as: f, field };
+        return { "as": f, field };
     }
     expandFields(resultStruct) {
         let resultIndex = 1;
@@ -2306,7 +2309,7 @@ class QueryQueryIndexStage extends QueryQuery {
             const { as, field } = this.expandField(f);
             resultStruct.addField(as, field, {
                 resultIndex,
-                type: "result",
+                "type": "result"
             });
             if (field instanceof QueryAtomicField) {
                 this.addDependancies(resultStruct, field);
@@ -2318,7 +2321,7 @@ class QueryQueryIndexStage extends QueryQuery {
             const f = this.parent.getFieldByName(measure);
             resultStruct.addField(measure, f, {
                 resultIndex,
-                type: "result",
+                "type": "result"
             });
             this.addDependancies(resultStruct, f);
         }
@@ -2342,7 +2345,7 @@ class QueryQueryIndexStage extends QueryQuery {
             const fi = field;
             if (fi.fieldUsage.type === "result" && isScalarField(fi.f)) {
                 const expression = fi.f.generateExpression(this.rootResult);
-                fields.push({ name, type: fi.f.fieldDef.type, expression });
+                fields.push({ name, "type": fi.f.fieldDef.type, expression });
             }
         }
         let s = `SELECT\n  group_set,\n`;
@@ -2484,12 +2487,12 @@ class QueryQueryIndex extends QueryQuery {
         for (const fields of stages) {
             const q = new QueryQueryIndexStage({
                 ...this.fieldDef,
-                pipeline: [
+                "pipeline": [
                     {
                         ...this.fieldDef.pipeline[0],
-                        fields: fields,
-                    },
-                ],
+                        "fields": fields
+                    }
+                ]
             }, this.parent, stageWriter);
             q.prepare(stageWriter);
             const lastStageName = q.generateSQL(stageWriter);
@@ -2508,20 +2511,20 @@ class QueryQueryIndex extends QueryQuery {
     /**  All Indexes have the same output schema */
     getResultStructDef() {
         return {
-            type: "struct",
-            name: this.resultStage || "result",
-            dialect: this.parent.fieldDef.dialect,
-            fields: [
-                { type: "string", name: "fieldName" },
-                { type: "string", name: "fieldValue" },
-                { type: "string", name: "fieldType" },
-                { type: "number", name: "weight", numberType: "integer" },
+            "type": "struct",
+            "name": this.resultStage || "result",
+            "dialect": this.parent.fieldDef.dialect,
+            "fields": [
+                { "type": "string", "name": "fieldName" },
+                { "type": "string", "name": "fieldValue" },
+                { "type": "string", "name": "fieldType" },
+                { "type": "number", "name": "weight", "numberType": "integer" }
             ],
-            structRelationship: {
-                type: "basetable",
-                connectionName: this.parent.connectionName,
+            "structRelationship": {
+                "type": "basetable",
+                "connectionName": this.parent.connectionName
             },
-            structSource: { type: "query_result" },
+            "structSource": { "type": "query_result" }
         };
     }
 }
@@ -2560,7 +2563,7 @@ class QueryStruct extends QueryNode {
             switch (field.type) {
                 case "struct": {
                     this.addFieldToNameMap(as, new QueryStruct(field, {
-                        struct: this,
+                        "struct": this
                     }));
                     break;
                 }
@@ -2577,7 +2580,7 @@ class QueryStruct extends QueryNode {
         }
         // if we don't have distinct key yet for this struct, add it.
         if (!this.nameMap.has("__distinct_key")) {
-            this.addFieldToNameMap("__distinct_key", new QueryFieldDistinctKey({ type: "string", name: "__distinct_key" }, this));
+            this.addFieldToNameMap("__distinct_key", new QueryFieldDistinctKey({ "type": "string", "name": "__distinct_key" }, this));
         }
     }
     // generate unique string for the alias.
@@ -2624,15 +2627,15 @@ class QueryStruct extends QueryNode {
         const aliasName = (0, malloy_types_1.getIdentifier)(this.fieldDef);
         const pkName = this.fieldDef.primaryKey;
         const fieldDef = {
-            type: pkType,
-            name: `${aliasName}_id`,
-            e: [
+            "type": pkType,
+            "name": `${aliasName}_id`,
+            "e": [
                 {
-                    type: "field",
+                    "type": "field",
                     // path: pkField.getFullOutputName(),
-                    path: pkField.getIdentifier(),
-                },
-            ],
+                    "path": pkField.getIdentifier()
+                }
+            ]
         };
         return new QueryFieldStruct(fieldDef, this, `${aliasName}.${pkName}`);
     }
@@ -2957,10 +2960,10 @@ class QueryStruct extends QueryNode {
         pipeline = (0, lodash_1.cloneDeep)(pipeline);
         pipeline[0].filterList = addedFilters.concat(pipeline[0].filterList || [], this.fieldDef.filterList || []);
         const flatTurtleDef = {
-            type: "turtle",
-            name: turtleDef.name,
+            "type": "turtle",
+            "name": turtleDef.name,
             pipeline,
-            location: turtleDef.location,
+            "location": turtleDef.location
         };
         return flatTurtleDef;
     }
@@ -2983,7 +2986,7 @@ class QueryModel {
         for (const s of Object.values(this.modelDef.contents)) {
             let qs;
             if (s.type === "struct") {
-                qs = new QueryStruct(s, { model: this });
+                qs = new QueryStruct(s, { "model": this });
                 this.structs.set((0, malloy_types_1.getIdentifier)(s), qs);
                 qs.resolveQueryFields();
             }
@@ -3005,7 +3008,7 @@ class QueryModel {
             else {
                 throw new Error(`No query specified in Struct '${path[0]}'`);
             }
-            return { queryName: path.join("."), struct };
+            return { "queryName": path.join("."), struct };
         }
         else {
             throw new Error(`Cannot find Struct '${path[0]}' Model`);
@@ -3031,7 +3034,7 @@ class QueryModel {
         else {
             throw new Error("Broken for now");
         }
-        return new QueryStruct(structDef, { model: this });
+        return new QueryStruct(structDef, { "model": this });
     }
     loadQuery(query, stageWriter, emitFinalStage = false) {
         const malloy = "";
@@ -3039,11 +3042,11 @@ class QueryModel {
             stageWriter = new StageWriter(true, undefined);
         }
         const turtleDef = {
-            type: "turtle",
-            name: "ignoreme",
-            pipeHead: query.pipeHead,
-            pipeline: query.pipeline,
-            filterList: query.filterList,
+            "type": "turtle",
+            "name": "ignoreme",
+            "pipeHead": query.pipeHead,
+            "pipeline": query.pipeline,
+            "filterList": query.filterList
         };
         const q = QueryQuery.makeQuery(turtleDef, this.getStructFromRef(query.structRef), stageWriter);
         const ret = q.generateSQLFromPipeline(stageWriter);
@@ -3056,11 +3059,11 @@ class QueryModel {
             ret.lastStageName = stageWriter.addStage(q.parent.dialect.sqlFinalStage(ret.lastStageName, fieldNames));
         }
         return {
-            lastStageName: ret.lastStageName,
+            "lastStageName": ret.lastStageName,
             malloy,
             stageWriter,
-            structs: [ret.outputStruct],
-            connectionName: q.parent.connectionName,
+            "structs": [ret.outputStruct],
+            "connectionName": q.parent.connectionName
         };
     }
     compileQuery(query, finalize = true) {
@@ -3081,16 +3084,16 @@ class QueryModel {
             this.dialect.sqlFinalStage(ret.lastStageName, []));
         }
         return {
-            lastStageName: ret.lastStageName,
-            malloy: ret.malloy,
-            sql: ret.stageWriter.generateSQLStages(),
-            structs: ret.structs,
+            "lastStageName": ret.lastStageName,
+            "malloy": ret.malloy,
+            "sql": ret.stageWriter.generateSQLStages(),
+            "structs": ret.structs,
             sourceExplore,
-            sourceFilters: query.filterList,
-            queryName: query.pipeHead && query.pipeline.length === 0
+            "sourceFilters": query.filterList,
+            "queryName": query.pipeHead && query.pipeline.length === 0
                 ? query.pipeHead.name
                 : undefined,
-            connectionName: ret.connectionName,
+            "connectionName": ret.connectionName
         };
     }
     async searchIndex(connection, explore, searchValue, limit = 1000, searchField = undefined) {
@@ -3102,21 +3105,21 @@ class QueryModel {
         let indexQuery;
         if (!struct.nameMap.get("search_index")) {
             indexQuery = {
-                structRef: explore,
-                pipeline: [
+                "structRef": explore,
+                "pipeline": [
                     {
-                        type: "index",
-                        fields: ["*"],
-                        sample: struct.dialect.defaultSampling,
-                    },
-                ],
+                        "type": "index",
+                        "fields": ["*"],
+                        "sample": struct.dialect.defaultSampling
+                    }
+                ]
             };
         }
         else {
             indexQuery = {
-                structRef: explore,
-                pipeHead: { name: "search_index" },
-                pipeline: [],
+                "structRef": explore,
+                "pipeHead": { "name": "search_index" },
+                "pipeline": []
             };
         }
         const fieldNameColumn = struct.dialect.sqlMaybeQuoteIdentifier("fieldName");
@@ -3147,11 +3150,11 @@ class QueryModel {
                 fieldValueColumn,
                 fieldTypeColumn,
                 "weight",
-                "match_first",
+                "match_first"
             ])}`;
         }
         const result = await connection.runSQL(query, {
-            rowLimit: 1000,
+            "rowLimit": 1000
         });
         return result.rows;
     }
@@ -3166,7 +3169,7 @@ function flattenQuery(model, query) {
     const queryStruct = queryModel.getStructByName(structRef);
     const turtleDef = queryStruct.flattenTurtleDef({
         ...query,
-        type: "turtle",
+        "type": "turtle"
     });
     return turtleDef;
 }