@malloydata/malloy 0.0.24-dev230224184907 → 0.0.24-dev230228224434

package/dist/model/malloy_query.js

@@ -40,7 +40,7 @@ class StageWriter {
         this.withs = [];
         this.udfs = [];
         this.pdts = [];
-        this.stagePrefix = "__stage";
+        this.stagePrefix = '__stage';
         this.parent = parent;
         this.useCTE = useCTE;
     }
@@ -69,7 +69,7 @@ class StageWriter {
         // eslint-disable-next-line prefer-const
         let { sql, lastStageName } = stageWriter.combineStages(true);
         if (lastStageName === undefined) {
-            throw new Error("Internal Error: no stage to combine");
+            throw new Error('Internal Error: no stage to combine');
         }
         sql += dialect.sqlCreateFunctionCombineLastStage(lastStageName, structDef);
         const id = `${dialect.udfPrefix}${this.root().udfs.length}`;
@@ -79,7 +79,7 @@ class StageWriter {
     }
     addPDT(baseName, dialect) {
         const sql = this.combineStages(false).sql + this.withs[this.withs.length - 1];
-        const tableName = "scratch." + baseName + (0, utils_1.generateHash)(sql);
+        const tableName = 'scratch.' + baseName + (0, utils_1.generateHash)(sql);
         this.root().pdts.push(dialect.sqlCreateTableAsSelect(tableName, sql));
         return tableName;
     }
@@ -87,11 +87,11 @@ 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 `;
-        let w = "";
+        let prefix = 'WITH ';
+        let w = '';
         for (let i = 0; i < this.withs.length - (includeLastStage ? 0 : 1); i++) {
             const sql = this.withs[i];
             lastStageName = this.getName(i);
@@ -99,18 +99,18 @@ class StageWriter {
                 throw new Error(`Expected sql WITH to be present for stage ${lastStageName}.`);
             }
             w += `${prefix}${lastStageName} AS (\n${(0, utils_1.indent)(sql)})\n`;
-            prefix = ", ";
+            prefix = ', ';
         }
-        return { "sql": w, lastStageName };
+        return { sql: w, lastStageName };
     }
     /** emit the SQL for all the stages.  */
     generateSQLStages() {
         const lastStageNum = this.withs.length - 1;
         if (lastStageNum < 0) {
-            throw new Error("No SQL generated");
+            throw new Error('No SQL generated');
         }
-        const udfs = this.udfs.join(`\n`);
-        const pdts = this.pdts.join(`\n`);
+        const udfs = this.udfs.join('\n');
+        const pdts = this.pdts.join('\n');
         const sql = this.combineStages(false).sql;
         return udfs + pdts + sql + this.withs[lastStageNum];
     }
@@ -180,12 +180,12 @@ class QueryField extends QueryNode {
     getJoinableParent() {
         // if it is inline it should always have a parent
         const parent = this.parent;
-        if (parent.fieldDef.structRelationship.type === "inline") {
+        if (parent.fieldDef.structRelationship.type === 'inline') {
             if (parent) {
                 return parent.getJoinableParent();
             }
             else {
-                throw new Error(`Internal Error: inline struct cannot be root`);
+                throw new Error('Internal Error: inline struct cannot be root');
             }
         }
         return parent;
@@ -197,7 +197,7 @@ class QueryField extends QueryNode {
         else {
             const exp = groupSets.length === 1
                 ? `=${groupSets[0]}`
-                : ` IN (${groupSets.join(",")})`;
+                : ` IN (${groupSets.join(',')})`;
             return `CASE WHEN group_set${exp} THEN\n  ${s}\n  END`;
         }
     }
@@ -248,12 +248,12 @@ class QueryField extends QueryNode {
     }
     generateUngroupedFragment(resultSet, context, expr, state) {
         if (state.totalGroupSet !== -1) {
-            throw new Error(`Already in ALL.  Cannot nest within an all calcuation.`);
+            throw new Error('Already in ALL.  Cannot nest within an all calcuation.');
         }
         let totalGroupSet;
         let ungroupSet;
         if (expr.fields && expr.fields.length > 0) {
-            const key = expr.fields.sort().join("|") + expr.type;
+            const key = expr.fields.sort().join('|') + expr.type;
             ungroupSet = resultSet.ungroupedSets.get(key);
             if (ungroupSet === undefined) {
                 throw new Error(`Internal Error, cannot find groupset with key ${key}`);
@@ -265,8 +265,8 @@ class QueryField extends QueryNode {
         }
         const s = this.generateExpressionFromExpr(resultSet, context, expr.e, state.withTotal(totalGroupSet));
         const fields = resultSet.getUngroupPartitions(ungroupSet);
-        let partitionBy = "";
-        const fieldsString = fields.map((f) => f.getPartitionSQL()).join(", ");
+        let partitionBy = '';
+        const fieldsString = fields.map(f => f.getPartitionSQL()).join(', ');
         if (fieldsString.length > 0) {
             partitionBy = `PARTITION BY ${fieldsString}`;
         }
@@ -303,9 +303,9 @@ class QueryField extends QueryNode {
     }
     generateSymmetricFragment(resultSet, context, expr, state) {
         const dimSQL = this.generateDimFragment(resultSet, context, expr, state);
-        const f = expr.function === "count_distinct"
-            ? "count(distinct "
-            : expr.function + "(";
+        const f = expr.function === 'count_distinct'
+            ? 'count(distinct '
+            : expr.function + '(';
         return `${f}${dimSQL})`;
     }
     generateAvgFragment(resultSet, context, expr, state) {
@@ -331,11 +331,11 @@ class QueryField extends QueryNode {
         }
     }
     generateCountFragment(resultSet, context, expr, state) {
-        let func = "COUNT(";
-        let thing = "1";
+        let func = 'COUNT(';
+        let thing = '1';
         const distinctKeySQL = this.generateDistinctKeyIfNecessary(resultSet, context, expr.structPath);
         if (distinctKeySQL) {
-            func = "COUNT(DISTINCT";
+            func = 'COUNT(DISTINCT';
             thing = distinctKeySQL;
         }
         // find the structDef and return the path to the field...
@@ -351,46 +351,46 @@ class QueryField extends QueryNode {
     }
     generateAnalyticFragment(resultStruct, context, expr, state) {
         const fields = resultStruct.getUngroupPartitions(undefined);
-        let partitionBy = "";
-        const fieldsString = fields.map((f) => f.getPartitionSQL()).join(", ");
+        let partitionBy = '';
+        const fieldsString = fields.map(f => f.getPartitionSQL()).join(', ');
         if (fieldsString.length > 0) {
             partitionBy = `PARTITION BY ${fieldsString}`;
         }
-        let orderBy = "";
+        let orderBy = '';
         // calculate the ordering.
         const obSQL = [];
         let orderingField;
         const orderByDef = resultStruct.firstSegment.orderBy ||
             resultStruct.calculateDefaultOrderBy();
         for (const ordering of orderByDef) {
-            if (typeof ordering.field === "string") {
+            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") {
+            if (resultStruct.firstSegment.type === 'reduce') {
                 obSQL.push(` ${orderingField.fif.getSQL()}` +
                     // this.parent.dialect.sqlMaybeQuoteIdentifier(
                     //   `${orderingField.name}__${resultStruct.groupSet}`
                     // ) +
-                    ` ${ordering.dir || "ASC"}`);
+                    ` ${ordering.dir || 'ASC'}`);
             }
-            else if (resultStruct.firstSegment.type === "project") {
-                obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || "ASC"}`);
+            else if (resultStruct.firstSegment.type === 'project') {
+                obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || 'ASC'}`);
             }
         }
         const func = malloy_types_1.malloyFunctions[expr.function];
         const paramSQL = [];
         if (expr.parameters !== undefined) {
             for (const e of expr.parameters) {
-                if (typeof e === "string") {
+                if (typeof e === 'string') {
                     paramSQL.push(e); // need to map to dimensional expression.
                 }
-                else if (typeof e === "number") {
+                else if (typeof e === 'number') {
                     paramSQL.push(e.toString());
                 }
                 else {
@@ -399,15 +399,15 @@ class QueryField extends QueryNode {
             }
         }
         if (obSQL.length > 0) {
-            orderBy = " " + this.parent.dialect.sqlOrderBy(obSQL);
+            orderBy = ' ' + this.parent.dialect.sqlOrderBy(obSQL);
         }
         const sqlName = func.sqlName || expr.function;
-        return `${sqlName}(${paramSQL.join(", ")}) OVER(${partitionBy} ${orderBy} )`;
+        return `${sqlName}(${paramSQL.join(', ')}) OVER(${partitionBy} ${orderBy} )`;
     }
     generateExpressionFromExpr(resultSet, context, e, state = new GenerateState()) {
-        let s = "";
+        let s = '';
         for (const expr of e) {
-            if (typeof expr === "string") {
+            if (typeof expr === 'string') {
                 s += expr;
             }
             else if ((0, malloy_types_1.isFieldFragment)(expr)) {
@@ -427,16 +427,16 @@ class QueryField extends QueryNode {
             }
             else if ((0, malloy_types_1.isAggregateFragment)(expr)) {
                 let agg;
-                if (expr.function === "sum") {
+                if (expr.function === 'sum') {
                     agg = this.generateSumFragment(resultSet, context, expr, state);
                 }
-                else if (expr.function === "avg") {
+                else if (expr.function === 'avg') {
                     agg = this.generateAvgFragment(resultSet, context, expr, state);
                 }
-                else if (expr.function === "count") {
+                else if (expr.function === 'count') {
                     agg = this.generateCountFragment(resultSet, context, expr, state);
                 }
-                else if (["count_distinct", "min", "max"].includes(expr.function)) {
+                else if (['count_distinct', 'min', 'max'].includes(expr.function)) {
                     agg = this.generateSymmetricFragment(resultSet, context, expr, state);
                 }
                 else {
@@ -462,10 +462,10 @@ class QueryField extends QueryNode {
                     s += state.applyValue;
                 }
                 else {
-                    throw new Error(`Internal Error: Partial application value referenced but not provided`);
+                    throw new Error('Internal Error: Partial application value referenced but not provided');
                 }
             }
-            else if (expr.type == "dialect") {
+            else if (expr.type === 'dialect') {
                 s += this.generateDialect(resultSet, context, expr, state);
             }
             else {
@@ -479,11 +479,11 @@ class QueryField extends QueryNode {
             return this.fieldDef.e;
         }
         return [
-            this.parent.dialect.sqlFieldReference(this.parent.getSQLIdentifier(), this.fieldDef.name, this.fieldDef.type, this.parent.fieldDef.structSource.type === "nested" ||
-                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.dialect.sqlFieldReference(this.parent.getSQLIdentifier(), this.fieldDef.name, this.fieldDef.type, this.parent.fieldDef.structSource.type === 'nested' ||
+                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),
         ];
     }
     generateExpression(resultSet) {
@@ -536,17 +536,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 },
+                ],
+            },
         };
     }
 }
@@ -557,7 +557,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);
         }
     }
@@ -565,8 +565,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);
     }
@@ -576,8 +576,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);
     }
@@ -589,13 +589,13 @@ class QueryFieldDistinctKey extends QueryAtomicField {
             const pk = this.parent.getPrimaryKeyField(this.fieldDef);
             return pk.generateExpression(resultSet);
         }
-        else if (this.parent.fieldDef.structSource.type === "nested") {
+        else if (this.parent.fieldDef.structSource.type === 'nested') {
             const parentKey = (_a = this.parent.parent) === null || _a === void 0 ? void 0 : _a.getDistinctKey().generateExpression(resultSet);
-            return `CONCAT(${parentKey}, 'x', ${this.parent.dialect.sqlFieldReference(this.parent.getIdentifier(), "__row_id", "string", true, false)})`;
+            return `CONCAT(${parentKey}, 'x', ${this.parent.dialect.sqlFieldReference(this.parent.getIdentifier(), '__row_id', 'string', true, false)})`;
         }
         else {
             // return this.parent.getIdentifier() + "." + "__distinct_key";
-            return this.parent.dialect.sqlFieldReference(this.parent.getIdentifier(), "__distinct_key", "string", this.parent.fieldDef.structRelationship.type === "nested", false);
+            return this.parent.dialect.sqlFieldReference(this.parent.getIdentifier(), '__distinct_key', 'string', this.parent.fieldDef.structRelationship.type === 'nested', false);
         }
     }
     includeInWildcard() {
@@ -622,7 +622,7 @@ function sqlSumDistinct(dialect, sqlExp, sqlDistintKey) {
 }
 class FieldInstanceField {
     constructor(f, fieldUsage, parent) {
-        this.type = "field";
+        this.type = 'field';
         this.additionalGroupSets = [];
         this.f = f;
         this.fieldUsage = fieldUsage;
@@ -651,7 +651,7 @@ class FieldInstanceField {
 }
 class FieldInstanceResult {
     constructor(turtleDef, parent) {
-        this.type = "query";
+        this.type = 'query';
         this.allFields = new Map();
         this.groupSet = 0;
         this.depth = 0;
@@ -667,12 +667,12 @@ class FieldInstanceResult {
     addField(as, field, usage) {
         let fi;
         if ((fi = this.allFields.get(as))) {
-            if (fi.type === "query") {
+            if (fi.type === 'query') {
                 throw new Error(`Redefinition of field ${field.fieldDef.name} as struct`);
             }
             const fif = fi;
-            if (fif.fieldUsage.type === "result") {
-                if (usage.type !== "result") {
+            if (fif.fieldUsage.type === 'result') {
+                if (usage.type !== 'result') {
                     // its already in the result, we can just ignore it.
                     return;
                 }
@@ -711,9 +711,9 @@ class FieldInstanceResult {
     getFieldByNumber(index) {
         for (const [name, fi] of this.allFields) {
             if (fi instanceof FieldInstanceField) {
-                if (fi.fieldUsage.type === "result" &&
+                if (fi.fieldUsage.type === 'result' &&
                     fi.fieldUsage.resultIndex === index) {
-                    return { name, "fif": fi };
+                    return { name, fif: fi };
                 }
             }
         }
@@ -737,10 +737,10 @@ class FieldInstanceResult {
         let isComplex = false;
         let children = [this.groupSet];
         for (const [_name, fi] of this.allFields) {
-            if (fi.type === "query") {
+            if (fi.type === 'query') {
                 const fir = fi;
                 isComplex = true;
-                if (fir.firstSegment.type === "reduce") {
+                if (fir.firstSegment.type === 'reduce') {
                     const r = fir.computeGroups(nextGroupSetNumber, depth + 1);
                     children = children.concat(r.children);
                     nextGroupSetNumber = r.nextGroupSetNumber;
@@ -779,14 +779,14 @@ class FieldInstanceResult {
     //  and emit the resulting structure as a RECORD instead of REPEATED
     //  if we have all numbers, we need to know because we'll have to conjur a record.
     getRepeatedResultType() {
-        let ret = "inline_all_numbers";
+        let ret = 'inline_all_numbers';
         for (const f of this.fields()) {
-            if (f.fieldUsage.type === "result") {
+            if (f.fieldUsage.type === 'result') {
                 if (isScalarField(f.f)) {
-                    return "nested";
+                    return 'nested';
                 }
                 if (f.f instanceof QueryStruct) {
-                    ret = "inline";
+                    ret = 'inline';
                 }
             }
         }
@@ -819,19 +819,19 @@ class FieldInstanceResult {
         let firstField;
         for (const [_name, fi] of this.allFields) {
             if (fi instanceof FieldInstanceField) {
-                if (fi.fieldUsage.type === "result") {
+                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 }];
+                    if (['date', 'timestamp'].indexOf(fi.f.fieldDef.type) > -1) {
+                        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 [];
     }
@@ -863,7 +863,7 @@ class FieldInstanceResult {
             joinStack.indexOf(name) === -1) {
             query.addDependantExpr(this, qs.parent, sr.onExpression, [
                 ...joinStack,
-                name
+                name,
             ]);
         }
         if (!(join = this.root().joins.get(name))) {
@@ -884,7 +884,7 @@ class FieldInstanceResult {
         if (this.parent) {
             return this.parent.root();
         }
-        throw new Error(`Internal Error, Null parent FieldInstanceResult`);
+        throw new Error('Internal Error, Null parent FieldInstanceResult');
     }
     getUngroupPartitions(ungroupSet) {
         let ret = [];
@@ -892,13 +892,13 @@ class FieldInstanceResult {
         let excludeFields = [];
         let inScopeFieldNames = [];
         // all defaults to all fields at the current level.
-        if (ungroupSet === undefined || ungroupSet.type === "all") {
+        if (ungroupSet === undefined || ungroupSet.type === 'all') {
             // fields specified an an all, convert it to an exclude set.
             const allFields = (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.fields) || [];
             // convert an All into the equivalent exclude
-            excludeFields = this.fields((fi) => isScalarField(fi.f) &&
-                fi.fieldUsage.type === "result" &&
-                allFields.indexOf(fi.f.getIdentifier()) === -1).map((fi) => fi.f.getIdentifier());
+            excludeFields = this.fields(fi => isScalarField(fi.f) &&
+                fi.fieldUsage.type === 'result' &&
+                allFields.indexOf(fi.f.getIdentifier()) === -1).map(fi => fi.f.getIdentifier());
         }
         else {
             excludeFields = ungroupSet.fields;
@@ -906,13 +906,13 @@ class FieldInstanceResult {
         let firstScope = true;
         while (p !== undefined) {
             // get a list of valid fieldnames for the current scope.
-            if (firstScope || (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.type) === "exclude") {
+            if (firstScope || (ungroupSet === null || ungroupSet === void 0 ? void 0 : ungroupSet.type) === 'exclude') {
                 inScopeFieldNames = inScopeFieldNames.concat(p
-                    .fields((fi) => isScalarField(fi.f) && fi.fieldUsage.type === "result")
-                    .map((fi) => fi.f.getIdentifier()));
+                    .fields(fi => isScalarField(fi.f) && fi.fieldUsage.type === 'result')
+                    .map(fi => fi.f.getIdentifier()));
             }
-            ret = ret.concat(p.fields((fi) => isScalarField(fi.f) &&
-                fi.fieldUsage.type === "result" &&
+            ret = ret.concat(p.fields(fi => isScalarField(fi.f) &&
+                fi.fieldUsage.type === 'result' &&
                 excludeFields.indexOf(fi.f.getIdentifier()) === -1));
             p = p.parent;
             firstScope = false;
@@ -954,12 +954,12 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
     //  groups that were used in ungroup calculations.  We need to do this only
     //  once and in the very next stage.
     eliminateComputeGroupsSQL() {
-        if (this.elimatedComputeGroups || this.computeOnlyGroups.length == 0) {
-            return "";
+        if (this.elimatedComputeGroups || this.computeOnlyGroups.length === 0) {
+            return '';
         }
         else {
             this.elimatedComputeGroups = true;
-            return `group_set NOT IN (${this.computeOnlyGroups.join(",")})`;
+            return `group_set NOT IN (${this.computeOnlyGroups.join(',')})`;
         }
     }
     // look at all the fields again in the structs in the query
@@ -968,14 +968,14 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
         for (const [name, join] of this.joins) {
             // first join is by default the
             const relationship = join.parentRelationship();
-            if (relationship === "many_to_many") {
+            if (relationship === 'many_to_many') {
                 // everything must be calculated with symmetric aggregates
-                leafiest = "0never";
+                leafiest = '0never';
             }
             else if (leafiest === undefined) {
                 leafiest = name;
             }
-            else if (join.parentRelationship() === "one_to_many") {
+            else if (join.parentRelationship() === 'one_to_many') {
                 // check up the parent relationship until you find
                 //  the current leafiest node.  If it isn't in the direct path
                 //  we need symmetric aggregate for everything.
@@ -986,7 +986,7 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
                 }
                 else {
                     // we have more than on one_to_many join chain, all bets are off.
-                    leafiest = "0never";
+                    leafiest = '0never';
                 }
             }
         }
@@ -1005,7 +1005,7 @@ class FieldInstanceResultRoot extends FieldInstanceResult {
                     if (!j.queryStruct.primaryKey()) {
                         j.makeUniqueKey = true;
                     }
-                    if (j.queryStruct.fieldDef.structRelationship.type === "nested") {
+                    if (j.queryStruct.fieldDef.structRelationship.type === 'nested') {
                         j = j.parent;
                     }
                     else {
@@ -1034,9 +1034,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);
             }
@@ -1044,19 +1044,19 @@ class JoinInstance {
     }
     parentRelationship() {
         if (this.queryStruct.parent === undefined) {
-            return "root";
+            return 'root';
         }
         switch (this.queryStruct.fieldDef.structRelationship.type) {
-            case "one":
-                return "many_to_one";
-            case "cross":
-                return "many_to_many";
-            case "many":
-                return "one_to_many";
-            case "nested":
-                return "one_to_many";
-            case "inline":
-                return "one_to_one";
+            case 'one':
+                return 'many_to_one';
+            case 'cross':
+                return 'many_to_many';
+            case 'many':
+                return 'one_to_many';
+            case 'nested':
+                return 'one_to_many';
+            case 'inline':
+                return 'one_to_one';
             default:
                 throw new Error(`Internal error unknown relationship type to parent for ${this.queryStruct.fieldDef.name}`);
         }
@@ -1066,9 +1066,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;
@@ -1086,12 +1086,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.
         );
@@ -1125,28 +1125,25 @@ 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) {
-            case "reduce":
+            case 'reduce':
                 return new QueryQueryReduce(flatTurtleDef, parent, stageWriter);
-            case "project":
+            case 'project':
                 return new QueryQueryProject(flatTurtleDef, parent, stageWriter);
-            case "index":
+            case 'index':
                 return new QueryQueryIndex(flatTurtleDef, parent, stageWriter);
         }
     }
@@ -1154,11 +1151,11 @@ class QueryQuery extends QueryField {
         switch (this.firstSegment.type) {
             // case "index":
             //   return this.firstSegment.fields || [];
-            case "reduce":
+            case 'reduce':
                 return this.firstSegment.fields;
             // probably need some way of checking type class of field here...
             //  project should only contain scalars
-            case "project":
+            case 'project':
                 return this.firstSegment.fields;
             default:
                 throw new Error(`Query contains no fields ${JSON.stringify(this.fieldDef)}`);
@@ -1169,19 +1166,19 @@ class QueryQuery extends QueryField {
         let as;
         let field;
         // if it is a string
-        if (typeof f === "string") {
+        if (typeof f === 'string') {
             field = this.parent.getQueryFieldByName(f);
         }
-        else if ("type" in f) {
+        else if ('type' in f) {
             field = this.parent.makeQueryField(f);
         }
         // or FilteredAliasedName or a hacked timestamp field.
-        else if ("name" in f && "as" in f) {
+        else if ('name' in f && 'as' in f) {
             field = this.parent.getQueryFieldByName(f.name);
             // QueryFieldStructs return new names...
             as = field.fieldDef.as || f.as;
             if (field instanceof QueryFieldStruct) {
-                throw new Error("Syntax currently disallowed. Semantics up for discussion");
+                throw new Error('Syntax currently disallowed. Semantics up for discussion');
             }
             // Types of aliased fields.
             // turtles
@@ -1249,17 +1246,17 @@ class QueryQuery extends QueryField {
     expandWildCards(fields, filter = undefined) {
         let ret = [];
         for (const f of fields) {
-            if (typeof f !== "string") {
+            if (typeof f !== 'string') {
                 ret.push(f);
             }
             else {
                 const fieldName = f;
-                const path = fieldName.split(".");
-                if (!path[path.length - 1].startsWith("*")) {
+                const path = fieldName.split('.');
+                if (!path[path.length - 1].startsWith('*')) {
                     ret.push(f);
                 }
                 else {
-                    const expandChildren = path.pop() === "**";
+                    const expandChildren = path.pop() === '**';
                     let struct = this.parent;
                     let pathElementName;
                     while (path.length > 0 && (pathElementName = path.shift())) {
@@ -1290,7 +1287,7 @@ class QueryQuery extends QueryField {
             struct = node;
         }
         else {
-            throw new Error(`Internal Error:  Unknown object type`);
+            throw new Error('Internal Error:  Unknown object type');
         }
         resultStruct
             .root()
@@ -1303,12 +1300,12 @@ class QueryQuery extends QueryField {
                 resultStruct.root().isComplexQuery = true;
                 resultStruct.root().queryUsesPartitioning = true;
                 if (expr.fields && expr.fields.length > 0) {
-                    const key = expr.fields.sort().join("|") + expr.type;
+                    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,
                         });
                     }
                 }
@@ -1334,28 +1331,28 @@ class QueryQuery extends QueryField {
             else if ((0, malloy_types_1.isDialectFragment)(expr)) {
                 const expressions = [];
                 switch (expr.function) {
-                    case "now":
+                    case 'now':
                         break;
-                    case "div":
+                    case 'div':
                         expressions.push(expr.denominator);
                         expressions.push(expr.numerator);
                         break;
-                    case "timeLiteral":
+                    case 'timeLiteral':
                         break;
-                    case "stringLiteral":
+                    case 'stringLiteral':
                         break;
-                    case "timeDiff":
+                    case 'timeDiff':
                         expressions.push(expr.left.value, expr.right.value);
                         break;
-                    case "delta":
+                    case 'delta':
                         expressions.push(expr.base.value, expr.delta);
                         break;
-                    case "trunc":
-                    case "extract":
+                    case 'trunc':
+                    case 'extract':
                         expressions.push(expr.expr.value);
                         break;
-                    case "regexpMatch":
-                    case "cast":
+                    case 'regexpMatch':
+                    case 'cast':
                         expressions.push(expr.expr);
                         break;
                     default:
@@ -1392,7 +1389,7 @@ class QueryQuery extends QueryField {
         for (const f of this.expandWildCards(resultStruct.firstSegment.fields)) {
             const { as, field } = this.expandField(f);
             if (field instanceof QueryTurtle || field instanceof QueryQuery) {
-                if (this.firstSegment.type === "project") {
+                if (this.firstSegment.type === 'project') {
                     throw new Error(`Turtled Queries cannot be used in PROJECT - '${field.fieldDef.name}'`);
                 }
                 const fir = new FieldInstanceResult(field.fieldDef, resultStruct);
@@ -1402,11 +1399,11 @@ 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)) {
-                    if (this.firstSegment.type === "project") {
+                    if (this.firstSegment.type === 'project') {
                         throw new Error(`Aggregate Fields cannot be used in PROJECT - '${field.fieldDef.name}'`);
                     }
                 }
@@ -1446,7 +1443,7 @@ class QueryQuery extends QueryField {
         }
         for (const join of resultStruct.root().joins.values() || []) {
             for (const qf of join.joinFilterConditions || []) {
-                if (qf.fieldDef.type === "boolean" && qf.fieldDef.e) {
+                if (qf.fieldDef.type === 'boolean' && qf.fieldDef.e) {
                     this.addDependantExpr(resultStruct, qf.parent, qf.fieldDef.e, []);
                 }
             }
@@ -1463,8 +1460,8 @@ class QueryQuery extends QueryField {
         // in the correct catgory.
         for (const cond of list || []) {
             const context = this.parent;
-            if ((which === "having" && (0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) ||
-                (which === "where" && cond.expressionType === "scalar")) {
+            if ((which === 'having' && (0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) ||
+                (which === 'where' && cond.expressionType === 'scalar')) {
                 const sqlClause = this.generateExpressionFromExpr(resultStruct, context, cond.expression, undefined);
                 resultFilters.add(sqlClause);
             }
@@ -1482,11 +1479,11 @@ class QueryQuery extends QueryField {
     // get the source fieldname and filters associated with the field (so we can drill later)
     getResultMetadata(fi) {
         if (fi instanceof FieldInstanceField) {
-            if (fi.fieldUsage.type === "result") {
+            if (fi.fieldUsage.type === 'result') {
                 const fieldDef = fi.f.fieldDef;
                 let filterList;
                 const sourceField = fi.f.parent.getFullOutputName() +
-                    (fieldDef.name || fieldDef.as || "undefined");
+                    (fieldDef.name || fieldDef.as || 'undefined');
                 const sourceExpression = fieldDef.code;
                 const sourceClasses = [sourceField];
                 if (isCalculatedField(fi.f)) {
@@ -1496,7 +1493,7 @@ class QueryQuery extends QueryField {
                         sourceExpression,
                         filterList,
                         sourceClasses,
-                        "fieldKind": "measure"
+                        fieldKind: 'measure',
                     };
                 }
                 if (isScalarField(fi.f)) {
@@ -1505,7 +1502,7 @@ class QueryQuery extends QueryField {
                         sourceExpression,
                         filterList,
                         sourceClasses,
-                        "fieldKind": "dimension"
+                        fieldKind: 'dimension',
                     };
                 }
                 else {
@@ -1524,8 +1521,8 @@ class QueryQuery extends QueryField {
                     sourceField,
                     filterList,
                     sourceClasses,
-                    "fieldKind": "struct",
-                    limit
+                    fieldKind: 'struct',
+                    limit,
                 };
             }
         }
@@ -1540,22 +1537,22 @@ class QueryQuery extends QueryField {
         for (const [name, fi] of resultStruct.allFields) {
             const resultMetadata = this.getResultMetadata(fi);
             if (fi instanceof FieldInstanceResult) {
-                const { structDef } = this.generateTurtlePipelineSQL(fi, new StageWriter(true, undefined), "<nosource>");
+                const { structDef } = this.generateTurtlePipelineSQL(fi, new StageWriter(true, undefined), '<nosource>');
                 // LTNOTE: This is probably broken now.  Need to look at the last stage
                 //  to figure out the resulting nested/inline state...
-                const resultType = fi.getRepeatedResultType() === "nested" ? "nested" : "inline";
+                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);
             }
             else if (fi instanceof FieldInstanceField) {
-                if (fi.fieldUsage.type === "result") {
+                if (fi.fieldUsage.type === 'result') {
                     if (fi.f instanceof QueryFieldStruct) {
                         fields.push(fi.f.getAsJoinedStructDef(name));
                     }
@@ -1573,74 +1570,74 @@ class QueryQuery extends QueryField {
                     const location = fi.f.fieldDef.location;
                     // build out the result fields...
                     switch (fi.f.fieldDef.type) {
-                        case "boolean":
-                        case "json":
-                        case "string":
+                        case 'boolean':
+                        case 'json':
+                        case 'string':
                             fields.push({
                                 name,
-                                "type": fi.f.fieldDef.type,
+                                type: fi.f.fieldDef.type,
                                 resultMetadata,
-                                location
+                                location,
                             });
                             break;
-                        case "timestamp": {
+                        case 'timestamp': {
                             const timeframe = fi.f.fieldDef.timeframe;
                             switch (timeframe) {
-                                case "year":
-                                case "month":
-                                case "week":
-                                case "quarter":
-                                case "day":
+                                case 'year':
+                                case 'month':
+                                case 'week':
+                                case 'quarter':
+                                case 'day':
                                     fields.push({
                                         name,
-                                        "type": "date",
+                                        type: 'date',
                                         timeframe,
                                         resultMetadata,
-                                        location
+                                        location,
                                     });
                                     break;
-                                case "second":
-                                case "minute":
-                                case "hour":
+                                case 'second':
+                                case 'minute':
+                                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;
                             }
                             break;
                         }
-                        case "date": {
+                        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":
+                        case 'number':
                             fields.push({
                                 name,
-                                "numberType": fi.f.fieldDef.numberType,
-                                "type": "number",
+                                numberType: fi.f.fieldDef.numberType,
+                                type: 'number',
                                 resultMetadata,
-                                location
+                                location,
                             });
                             break;
-                        case "unsupported":
+                        case 'unsupported':
                             fields.push({ ...fi.f.fieldDef, resultMetadata, location });
                             break;
                         default:
@@ -1651,20 +1648,20 @@ 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) {
-        let s = "";
+        let s = '';
         const qs = ji.queryStruct;
         const structRelationship = qs.fieldDef.structRelationship;
         let structSQL = qs.structSourceSQL(stageWriter);
@@ -1672,55 +1669,55 @@ class QueryQuery extends QueryField {
             if (ji.makeUniqueKey) {
                 structSQL = `(SELECT ${qs.dialect.sqlGenerateUUID()} as __distinct_key, * FROM ${structSQL})`;
             }
-            let onCondition = "";
+            let onCondition = '';
             if (qs.parent === undefined) {
-                throw new Error("Expected joined struct to have a parent.");
+                throw new Error('Expected joined struct to have a parent.');
             }
             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 {
-                onCondition = "1=1";
+                onCondition = '1=1';
             }
-            let filters = "";
+            let filters = '';
             let conditions = undefined;
             if (ji.joinFilterConditions) {
-                conditions = ji.joinFilterConditions.map((qf) => qf.generateExpression(this.rootResult));
+                conditions = ji.joinFilterConditions.map(qf => qf.generateExpression(this.rootResult));
             }
             if (ji.children.length === 0 || conditions === undefined) {
                 if (conditions !== undefined && conditions.length >= 1) {
-                    filters = ` AND (${conditions.join(" AND ")})`;
+                    filters = ` AND (${conditions.join(' AND ')})`;
                 }
                 s += `LEFT JOIN ${structSQL} AS ${ji.alias}\n  ON ${onCondition}${filters}\n`;
             }
             else {
                 let select = `SELECT ${ji.alias}.*`;
-                let joins = "";
+                let joins = '';
                 for (const childJoin of ji.children) {
                     joins += this.generateSQLJoinBlock(stageWriter, childJoin);
-                    const physicalFields = (0, malloy_types_1.getPhysicalFields)(childJoin.queryStruct.fieldDef).map((fieldDef) => this.parent.dialect.sqlMaybeQuoteIdentifier(fieldDef.name));
+                    const physicalFields = (0, malloy_types_1.getPhysicalFields)(childJoin.queryStruct.fieldDef).map(fieldDef => this.parent.dialect.sqlMaybeQuoteIdentifier(fieldDef.name));
                     select += `, ${this.parent.dialect.sqlSelectAliasAsStruct(childJoin.alias, physicalFields)} AS ${childJoin.alias}`;
                 }
-                select += `\nFROM ${structSQL} AS ${ji.alias}\n${joins}\nWHERE ${conditions === null || conditions === void 0 ? void 0 : conditions.join(" AND ")}\n`;
+                select += `\nFROM ${structSQL} AS ${ji.alias}\n${joins}\nWHERE ${conditions === null || conditions === void 0 ? void 0 : conditions.join(' AND ')}\n`;
                 s += `LEFT JOIN (\n${(0, utils_1.indent)(select)}) AS ${ji.alias}\n  ON ${onCondition}\n`;
                 return s;
             }
         }
-        else if (structRelationship.type === "nested") {
+        else if (structRelationship.type === 'nested') {
             if (qs.parent === undefined || ji.parent === undefined) {
-                throw new Error("Internal Error, nested structure with no parent.");
+                throw new Error('Internal Error, nested structure with no parent.');
             }
-            const fieldExpression = this.parent.dialect.sqlFieldReference(qs.parent.getSQLIdentifier(), structRelationship.field, "struct", qs.parent.fieldDef.structRelationship.type === "nested", this.parent.fieldDef.structRelationship.type === "nested" &&
+            const fieldExpression = this.parent.dialect.sqlFieldReference(qs.parent.getSQLIdentifier(), structRelationship.field, 'struct', qs.parent.fieldDef.structRelationship.type === 'nested', this.parent.fieldDef.structRelationship.type === 'nested' &&
                 this.parent.fieldDef.structRelationship.isArray);
             // we need to generate primary key.  If parent has a primary key combine
             s += `${this.parent.dialect.sqlUnnestAlias(fieldExpression, ji.alias, ji.getDialectFieldList(), ji.makeUniqueKey, structRelationship.isArray)}\n`;
         }
-        else if (structRelationship.type === "inline") {
-            throw new Error("Internal Error: inline structs should never appear in join trees");
+        else if (structRelationship.type === 'inline') {
+            throw new Error('Internal Error: inline structs should never appear in join trees');
         }
         else {
             throw new Error(`Join type not implemented ${JSON.stringify(qs.fieldDef.structRelationship)}`);
@@ -1731,7 +1728,7 @@ class QueryQuery extends QueryField {
         return s;
     }
     generateSQLJoins(stageWriter) {
-        let s = "";
+        let s = '';
         // get the first value from the map (weird, I know)
         const [[, ji]] = this.rootResult.joins;
         const qs = ji.queryStruct;
@@ -1744,14 +1741,14 @@ class QueryQuery extends QueryField {
             }
         }
         const structRelationship = qs.fieldDef.structRelationship;
-        if (structRelationship.type === "basetable") {
+        if (structRelationship.type === 'basetable') {
             if (ji.makeUniqueKey) {
                 structSQL = `(SELECT ${qs.dialect.sqlGenerateUUID()} as __distinct_key, * FROM ${structSQL} as x)`;
             }
             s += `FROM ${structSQL} as ${this.parent.getIdentifier()}\n`;
         }
         else {
-            throw new Error("Internal Error, queries must start from a basetable");
+            throw new Error('Internal Error, queries must start from a basetable');
         }
         for (const childJoin of ji.children) {
             s += this.generateSQLJoinBlock(stageWriter, childJoin);
@@ -1759,60 +1756,60 @@ class QueryQuery extends QueryField {
         return s;
     }
     genereateSQLOrderBy(queryDef, resultStruct) {
-        let s = "";
-        if (this.firstSegment.type === "project" && !queryDef.orderBy) {
-            return ""; // No default ordering for project.
+        let s = '';
+        if (this.firstSegment.type === 'project' && !queryDef.orderBy) {
+            return ''; // No default ordering for project.
         }
         const orderBy = queryDef.orderBy || resultStruct.calculateDefaultOrderBy();
         const o = [];
         for (const f of orderBy) {
-            if (typeof f.field === "string") {
+            if (typeof f.field === 'string') {
                 // convert name to an index
                 const fi = resultStruct.getField(f.field);
-                if (fi && fi.fieldUsage.type === "result") {
-                    o.push(`${fi.fieldUsage.resultIndex} ${f.dir || "ASC"}`);
+                if (fi && fi.fieldUsage.type === 'result') {
+                    o.push(`${fi.fieldUsage.resultIndex} ${f.dir || 'ASC'}`);
                 }
                 else {
                     throw new Error(`Unknown field in ORDER BY ${f.field}`);
                 }
             }
             else {
-                o.push(`${f.field} ${f.dir || "ASC"}`);
+                o.push(`${f.field} ${f.dir || 'ASC'}`);
             }
         }
         if (o.length > 0) {
-            s = this.parent.dialect.sqlOrderBy(o) + `\n`;
+            s = this.parent.dialect.sqlOrderBy(o) + '\n';
         }
         return s;
     }
     generateSimpleSQL(stageWriter) {
-        let s = "";
-        s += "SELECT \n";
+        let s = '';
+        s += 'SELECT \n';
         const fields = [];
         for (const [name, field] of this.rootResult.allFields) {
             const fi = field;
             const sqlName = this.parent.dialect.sqlMaybeQuoteIdentifier(name);
-            if (fi.fieldUsage.type === "result") {
+            if (fi.fieldUsage.type === 'result') {
                 fields.push(` ${fi.f.generateExpression(this.rootResult)} as ${sqlName}`);
             }
         }
-        s += (0, utils_1.indent)(fields.join(",\n")) + "\n";
+        s += (0, utils_1.indent)(fields.join(',\n')) + '\n';
         s += this.generateSQLJoins(stageWriter);
-        s += this.generateSQLFilters(this.rootResult, "where").sql("where");
+        s += this.generateSQLFilters(this.rootResult, 'where').sql('where');
         // group by
-        if (this.firstSegment.type === "reduce") {
+        if (this.firstSegment.type === 'reduce') {
             const n = [];
             for (const field of this.rootResult.fields()) {
                 const fi = field;
-                if (fi.fieldUsage.type === "result" && isScalarField(fi.f)) {
+                if (fi.fieldUsage.type === 'result' && isScalarField(fi.f)) {
                     n.push(fi.fieldUsage.resultIndex.toString());
                 }
             }
             if (n.length > 0) {
-                s += `GROUP BY ${n.join(",")}\n`;
+                s += `GROUP BY ${n.join(',')}\n`;
             }
         }
-        s += this.generateSQLFilters(this.rootResult, "having").sql("having");
+        s += this.generateSQLFilters(this.rootResult, 'having').sql('having');
         // order by
         s += this.genereateSQLOrderBy(this.firstSegment, this.rootResult);
         // limit
@@ -1829,9 +1826,9 @@ class QueryQuery extends QueryField {
             return lastStageName;
         }
         const pipelinesSQL = outputPipelinedSQL
-            .map((o) => `${o.pipelineSQL} as ${o.sqlFieldName}
+            .map(o => `${o.pipelineSQL} as ${o.sqlFieldName}
       `)
-            .join(",\n");
+            .join(',\n');
         return stageWriter.addStage(`SELECT * replace (${pipelinesSQL}) FROM ${lastStageName}
       `);
     }
@@ -1839,15 +1836,15 @@ class QueryQuery extends QueryField {
         for (const [name, fi] of resultSet.allFields) {
             const outputName = this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultSet.groupSet}`);
             if (fi instanceof FieldInstanceField) {
-                if (fi.fieldUsage.type === "result") {
+                if (fi.fieldUsage.type === 'result') {
                     const exp = fi.getSQL();
                     if (isScalarField(fi.f)) {
-                        if (this.parent.dialect.name === "standardsql" &&
+                        if (this.parent.dialect.name === 'standardsql' &&
                             this.rootResult.queryUsesPartitioning) {
                             // BigQuery can't partition aggregate function except when the field has no
                             //  expression.  Additionally it can't partition by floats.  We stuff expressions
                             //  and numbers as strings into a lateral join when the query has ungrouped expressions
-                            if (fi.f.fieldDef.type === "number") {
+                            if (fi.f.fieldDef.type === 'number') {
                                 // make an extra dimension as a string
                                 output.sql.push(`${exp} as ${outputName}`);
                                 const outputFieldName = `__lateral_join_bag.${outputName}_string`;
@@ -1876,10 +1873,10 @@ class QueryQuery extends QueryField {
                 }
             }
             else if (fi instanceof FieldInstanceResult) {
-                if (fi.firstSegment.type === "reduce") {
+                if (fi.firstSegment.type === 'reduce') {
                     this.generateStage0Fields(fi, output, stageWriter);
                 }
-                else if (fi.firstSegment.type === "project") {
+                else if (fi.firstSegment.type === 'project') {
                     const s = this.generateTurtleSQL(fi, stageWriter, outputName, output.outputPipelinedSQL);
                     output.sql.push(`${s} as ${outputName}`);
                     output.fieldIndex++;
@@ -1890,7 +1887,7 @@ class QueryQuery extends QueryField {
         //  leaf turtles can have their having clauses in the main query
         //  turtles with leaves need to promote their state to their
         //  children.
-        const having = this.generateSQLFilters(resultSet, "having");
+        const having = this.generateSQLFilters(resultSet, 'having');
         if (!having.empty()) {
             // if we have no children, the having can run at the root level
             if (resultSet.childGroups.length === 1) {
@@ -1908,11 +1905,11 @@ class QueryQuery extends QueryField {
     generateSQLWhereChildren(resultStruct) {
         const wheres = new utils_1.AndChain();
         for (const [, field] of resultStruct.allFields) {
-            if (field.type === "query") {
+            if (field.type === 'query') {
                 const fir = field;
-                const turtleWhere = this.generateSQLFilters(fir, "where");
+                const turtleWhere = this.generateSQLFilters(fir, 'where');
                 if (turtleWhere.present()) {
-                    const groupSets = fir.childGroups.join(",");
+                    const groupSets = fir.childGroups.join(',');
                     wheres.add(`(group_set NOT IN (${groupSets})` +
                         ` OR (group_set IN (${groupSets}) AND ${turtleWhere.sql()}))`);
                 }
@@ -1922,9 +1919,9 @@ class QueryQuery extends QueryField {
         return wheres;
     }
     generateSQLWhereTurtled() {
-        const wheres = this.generateSQLFilters(this.rootResult, "where");
+        const wheres = this.generateSQLFilters(this.rootResult, 'where');
         wheres.addChain(this.generateSQLWhereChildren(this.rootResult));
-        return wheres.sql("where");
+        return wheres.sql('where');
     }
     // iterate over the nested queries looking for Havings (and someday limits).
     //  if you find any, generate a new stage(s) to perform these functions.
@@ -1937,51 +1934,51 @@ class QueryQuery extends QueryField {
                 const dimensions = [];
                 let r = result;
                 while (r) {
-                    for (const name of r.fieldNames((fi) => isScalarField(fi.f))) {
+                    for (const name of r.fieldNames(fi => isScalarField(fi.f))) {
                         dimensions.push(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${r.groupSet}`));
                     }
                     r = r.parent;
                 }
-                fields.push(`MAX(CASE WHEN group_set IN (${result.childGroups.join(",")}) THEN __delete__${result.groupSet} END) OVER(partition by ${dimensions
-                    .map((x) => `CAST(${x} AS ${this.parent.dialect.stringTypeName}) `)
-                    .join(",")}) as __shaving__${result.groupSet}`);
+                fields.push(`MAX(CASE WHEN group_set IN (${result.childGroups.join(',')}) THEN __delete__${result.groupSet} END) OVER(partition by ${dimensions
+                    .map(x => `CAST(${x} AS ${this.parent.dialect.stringTypeName}) `)
+                    .join(',')}) as __shaving__${result.groupSet}`);
             }
         }
         if (resultsWithHaving.length > 0) {
-            lastStageName = stageWriter.addStage(`SELECT\n  *,\n  ${fields.join(",\n  ")} \nFROM ${lastStageName}`);
+            lastStageName = stageWriter.addStage(`SELECT\n  *,\n  ${fields.join(',\n  ')} \nFROM ${lastStageName}`);
             const havings = new utils_1.AndChain();
             for (const result of resultsWithHaving) {
-                havings.add(`group_set IN (${result.childGroups.join(",")}) AND __shaving__${result.groupSet}=1`);
+                havings.add(`group_set IN (${result.childGroups.join(',')}) AND __shaving__${result.groupSet}=1`);
             }
             lastStageName = stageWriter.addStage(`SELECT *\nFROM ${lastStageName}\nWHERE NOT (${havings.sqlOr()})`);
         }
         return lastStageName;
     }
     generateSQLStage0(stageWriter) {
-        let s = "SELECT\n";
+        let s = 'SELECT\n';
         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") {
-            throw new Error("PROJECT cannot be used on queries with turtles");
+        if (this.firstSegment.type === 'project') {
+            throw new Error('PROJECT cannot be used on queries with turtles');
         }
-        const groupBy = "GROUP BY " + f.dimensionIndexes.join(",") + "\n";
-        from += this.parent.dialect.sqlGroupSetTable(this.maxGroupSet) + "\n";
-        s += (0, utils_1.indent)(f.sql.join(",\n")) + "\n";
+        const groupBy = 'GROUP BY ' + f.dimensionIndexes.join(',') + '\n';
+        from += this.parent.dialect.sqlGroupSetTable(this.maxGroupSet) + '\n';
+        s += (0, utils_1.indent)(f.sql.join(',\n')) + '\n';
         // this should only happen on standard SQL,  BigQuery can't partition by expressions and
         //  aggregates.
         if (f.lateralJoinSQLExpressions.length > 0) {
-            from += `LEFT JOIN UNNEST([STRUCT(${f.lateralJoinSQLExpressions.join(",\n")})]) as __lateral_join_bag\n`;
+            from += `LEFT JOIN UNNEST([STRUCT(${f.lateralJoinSQLExpressions.join(',\n')})]) as __lateral_join_bag\n`;
         }
-        s += from + wheres + groupBy + this.rootResult.havings.sql("having");
+        s += from + wheres + groupBy + this.rootResult.havings.sql('having');
         // generate the stage
         const resultStage = stageWriter.addStage(s);
         // generate stages for havings and limits
@@ -1994,7 +1991,7 @@ class QueryQuery extends QueryField {
         for (const [name, fi] of resultSet.allFields) {
             const sqlFieldName = this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultSet.groupSet}`);
             if (fi instanceof FieldInstanceField) {
-                if (fi.fieldUsage.type === "result") {
+                if (fi.fieldUsage.type === 'result') {
                     if (isScalarField(fi.f)) {
                         const exp = this.caseGroup(resultSet.groupSet > 0 ? resultSet.childGroups : [], sqlFieldName);
                         output.sql.push(`${exp} as ${sqlFieldName}`);
@@ -2014,8 +2011,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}`);
@@ -2027,39 +2024,39 @@ class QueryQuery extends QueryField {
             }
         }
         if (output.groupsAggregated.length > 0) {
-            output.sql[0] = `CASE `;
+            output.sql[0] = 'CASE ';
             for (const m of output.groupsAggregated) {
                 output.sql[0] += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
             }
-            output.sql[0] += ` ELSE group_set END as group_set`;
+            output.sql[0] += ' ELSE group_set END as group_set';
         }
     }
     generateSQLDepthN(depth, stageWriter, stageName) {
-        let s = "SELECT \n";
+        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";
+        s += (0, utils_1.indent)(f.sql.join(',\n')) + '\n';
         s += `FROM ${stageName}\n`;
         const where = this.rootResult.eliminateComputeGroupsSQL();
         if (where.length > 0) {
             s += `WHERE ${where}\n`;
         }
         if (f.dimensionIndexes.length > 0) {
-            s += `GROUP BY ${f.dimensionIndexes.join(",")}\n`;
+            s += `GROUP BY ${f.dimensionIndexes.join(',')}\n`;
         }
         this.resultStage = stageWriter.addStage(s);
         this.resultStage = this.generatePipelinedStages(f.outputPipelinedSQL, this.resultStage, stageWriter);
         return this.resultStage;
     }
     genereateSQLCombineTurtles(stageWriter, stage0Name) {
-        let s = "SELECT\n";
+        let s = 'SELECT\n';
         const fieldsSQL = [];
         let fieldIndex = 1;
         const outputPipelinedSQL = [];
@@ -2067,7 +2064,7 @@ class QueryQuery extends QueryField {
         for (const [name, fi] of this.rootResult.allFields) {
             const sqlName = this.parent.dialect.sqlMaybeQuoteIdentifier(name);
             if (fi instanceof FieldInstanceField) {
-                if (fi.fieldUsage.type === "result") {
+                if (fi.fieldUsage.type === 'result') {
                     if (isScalarField(fi.f)) {
                         fieldsSQL.push(this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`);
                         dimensionIndexes.push(fieldIndex++);
@@ -2079,23 +2076,23 @@ class QueryQuery extends QueryField {
                 }
             }
             else if (fi instanceof FieldInstanceResult) {
-                if (fi.firstSegment.type === "reduce") {
+                if (fi.firstSegment.type === 'reduce') {
                     fieldsSQL.push(`${this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL)} as ${sqlName}`);
                     fieldIndex++;
                 }
-                else if (fi.firstSegment.type === "project") {
+                else if (fi.firstSegment.type === 'project') {
                     fieldsSQL.push(this.parent.dialect.sqlAnyValueLastTurtle(name, this.rootResult.groupSet, sqlName));
                     fieldIndex++;
                 }
             }
         }
-        s += (0, utils_1.indent)(fieldsSQL.join(",\n")) + `\nFROM ${stage0Name}\n`;
+        s += (0, utils_1.indent)(fieldsSQL.join(',\n')) + `\nFROM ${stage0Name}\n`;
         const where = this.rootResult.eliminateComputeGroupsSQL();
         if (where.length > 0) {
             s += `WHERE ${where}\n`;
         }
         if (dimensionIndexes.length > 0) {
-            s += `GROUP BY ${dimensionIndexes.join(",")}\n`;
+            s += `GROUP BY ${dimensionIndexes.join(',')}\n`;
         }
         // order by
         s += this.genereateSQLOrderBy(this.firstSegment, this.rootResult);
@@ -2110,7 +2107,7 @@ class QueryQuery extends QueryField {
     generateTurtleSQL(resultStruct, stageWriter, sqlFieldName, outputPipelinedSQL) {
         // let fieldsSQL: string[] = [];
         const dialectFieldList = [];
-        let orderBy = "";
+        let orderBy = '';
         const limit = resultStruct.firstSegment.limit;
         // calculate the ordering.
         const obSQL = [];
@@ -2118,61 +2115,61 @@ class QueryQuery extends QueryField {
         const orderByDef = resultStruct.firstSegment.orderBy ||
             resultStruct.calculateDefaultOrderBy();
         for (const ordering of orderByDef) {
-            if (typeof ordering.field === "string") {
+            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(" " +
+            if (resultStruct.firstSegment.type === 'reduce') {
+                obSQL.push(' ' +
                     this.parent.dialect.sqlMaybeQuoteIdentifier(`${orderingField.name}__${resultStruct.groupSet}`) +
-                    ` ${ordering.dir || "ASC"}`);
+                    ` ${ordering.dir || 'ASC'}`);
             }
-            else if (resultStruct.firstSegment.type === "project") {
-                obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || "ASC"}`);
+            else if (resultStruct.firstSegment.type === 'project') {
+                obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || 'ASC'}`);
             }
         }
         if (obSQL.length > 0) {
-            orderBy = " " + this.parent.dialect.sqlOrderBy(obSQL);
+            orderBy = ' ' + this.parent.dialect.sqlOrderBy(obSQL);
         }
         for (const [name, field] of resultStruct.allFields) {
             const sqlName = this.parent.dialect.sqlMaybeQuoteIdentifier(name);
             //
-            if (resultStruct.firstSegment.type === "reduce" &&
+            if (resultStruct.firstSegment.type === 'reduce' &&
                 (field instanceof FieldInstanceResult ||
                     (field instanceof FieldInstanceField &&
-                        field.fieldUsage.type === "result"))) {
+                        field.fieldUsage.type === 'result'))) {
                 // 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
+                        : 'struct',
+                    sqlExpression: this.parent.dialect.sqlMaybeQuoteIdentifier(`${name}__${resultStruct.groupSet}`),
+                    sqlOutputName: sqlName,
                 });
             }
-            else if (resultStruct.firstSegment.type === "project" &&
+            else if (resultStruct.firstSegment.type === 'project' &&
                 field instanceof FieldInstanceField &&
-                field.fieldUsage.type === "result") {
+                field.fieldUsage.type === 'result') {
                 // fieldsSQL.push(
                 //   `${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,
                 });
             }
         }
         let resultType;
         let ret;
-        if ((resultType = resultStruct.getRepeatedResultType()) !== "nested") {
-            if (resultType === "inline_all_numbers") {
+        if ((resultType = resultStruct.getRepeatedResultType()) !== 'nested') {
+            if (resultType === 'inline_all_numbers') {
                 ret = this.parent.dialect.sqlCoaleseMeasuresInline(resultStruct.groupSet, dialectFieldList);
             }
             else {
@@ -2194,7 +2191,7 @@ class QueryQuery extends QueryField {
             else {
                 outputPipelinedSQL.push({
                     sqlFieldName,
-                    "pipelineSQL": `(${sql})`
+                    pipelineSQL: `(${sql})`,
                 });
             }
         }
@@ -2212,14 +2209,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.name = this.parent.dialect.sqlUnnestPipelineHead(repeatedResultType === 'inline_all_numbers', sourceSQLExpression);
+            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);
@@ -2228,7 +2225,7 @@ class QueryQuery extends QueryField {
         }
         return {
             structDef,
-            pipeOut
+            pipeOut,
         };
     }
     generateComplexSQL(stageWriter) {
@@ -2259,7 +2256,7 @@ class QueryQuery extends QueryField {
     }
     toMalloy() {
         let ret = `EXPLORE ${(0, malloy_types_1.getIdentifier)(this.parent.fieldDef)} | `;
-        ret += this.fieldDef.type.toUpperCase() + " ";
+        ret += this.fieldDef.type.toUpperCase() + ' ';
         return ret;
     }
     generateSQLFromPipeline(stageWriter) {
@@ -2271,20 +2268,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' },
                 };
             }
         }
@@ -2306,7 +2303,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;
@@ -2317,7 +2314,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);
@@ -2329,19 +2326,19 @@ class QueryQueryIndexStage extends QueryQuery {
             const f = this.parent.getFieldByName(measure);
             resultStruct.addField(measure, f, {
                 resultIndex,
-                "type": "result"
+                type: 'result',
             });
             this.addDependancies(resultStruct, f);
         }
         this.expandFilters(resultStruct);
     }
     generateSQL(stageWriter) {
-        let measureSQL = "COUNT(*)";
+        let measureSQL = 'COUNT(*)';
         const dialect = this.parent.dialect;
-        const fieldNameColumn = dialect.sqlMaybeQuoteIdentifier("fieldName");
-        const fieldValueColumn = dialect.sqlMaybeQuoteIdentifier("fieldValue");
-        const fieldTypeColumn = dialect.sqlMaybeQuoteIdentifier("fieldType");
-        const fieldRangeColumn = dialect.sqlMaybeQuoteIdentifier("fieldRange");
+        const fieldNameColumn = dialect.sqlMaybeQuoteIdentifier('fieldName');
+        const fieldValueColumn = dialect.sqlMaybeQuoteIdentifier('fieldValue');
+        const fieldTypeColumn = dialect.sqlMaybeQuoteIdentifier('fieldType');
+        const fieldRangeColumn = dialect.sqlMaybeQuoteIdentifier('fieldRange');
         const measureName = this.firstSegment.weightMeasure;
         if (measureName) {
             measureSQL = this.rootResult
@@ -2351,37 +2348,37 @@ class QueryQueryIndexStage extends QueryQuery {
         const fields = [];
         for (const [name, field] of this.rootResult.allFields) {
             const fi = field;
-            if (fi.fieldUsage.type === "result" && isScalarField(fi.f)) {
+            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`;
-        s += `  CASE group_set\n`;
+        let s = 'SELECT\n  group_set,\n';
+        s += '  CASE group_set\n';
         for (let i = 0; i < fields.length; i++) {
             s += `    WHEN ${i} THEN '${fields[i].name}'\n`;
         }
         s += `  END as ${fieldNameColumn},`;
-        s += `  CASE group_set\n`;
+        s += '  CASE group_set\n';
         for (let i = 0; i < fields.length; i++) {
             s += `    WHEN ${i} THEN '${fields[i].type}'\n`;
         }
         s += `  END as ${fieldTypeColumn},`;
-        s += `  CASE group_set WHEN 99999 THEN NULL\n`;
+        s += '  CASE group_set WHEN 99999 THEN NULL\n';
         for (let i = 0; i < fields.length; i++) {
-            if (fields[i].type === "string") {
+            if (fields[i].type === 'string') {
                 s += `    WHEN ${i} THEN ${fields[i].expression}\n`;
             }
         }
         s += `  END as ${fieldValueColumn},\n`;
         s += ` ${measureSQL} as weight,\n`;
         // just in case we don't have any field types, force the case statement to have at least one value.
-        s += `  CASE group_set\n    WHEN 99999 THEN ''`;
+        s += "  CASE group_set\n    WHEN 99999 THEN ''";
         for (let i = 0; i < fields.length; i++) {
-            if (fields[i].type === "number") {
+            if (fields[i].type === 'number') {
                 s += `    WHEN ${i} THEN CAST(MIN(${fields[i].expression}) AS ${dialect.stringTypeName}) || ' to ' || CAST(MAX(${fields[i].expression}) AS ${dialect.stringTypeName})\n`;
             }
-            if (fields[i].type === "timestamp" || fields[i].type === "date") {
+            if (fields[i].type === 'timestamp' || fields[i].type === 'date') {
                 s += `    WHEN ${i} THEN MIN(${dialect.sqlDateToString(fields[i].expression)}) || ' to ' || MAX(${dialect.sqlDateToString(fields[i].expression)})\n`;
             }
         }
@@ -2394,9 +2391,9 @@ class QueryQueryIndexStage extends QueryQuery {
         // ELSE NULL
         // END as field_range\n`;
         s += this.generateSQLJoins(stageWriter);
-        s += dialect.sqlGroupSetTable(fields.length) + "\n";
-        s += this.generateSQLFilters(this.rootResult, "where").sql("where");
-        s += "GROUP BY 1,2,3,4\n";
+        s += dialect.sqlGroupSetTable(fields.length) + '\n';
+        s += this.generateSQLFilters(this.rootResult, 'where').sql('where');
+        s += 'GROUP BY 1,2,3,4\n';
         // limit
         if (this.firstSegment.limit) {
             s += `LIMIT ${this.firstSegment.limit}\n`;
@@ -2425,8 +2422,8 @@ class QueryQueryIndex extends QueryQuery {
     findFanPrefexes(qs) {
         for (const [_name, f] of qs.nameMap) {
             if (f instanceof QueryStruct &&
-                (f.fieldDef.structRelationship.type === "many" ||
-                    f.fieldDef.structRelationship.type === "nested") &&
+                (f.fieldDef.structRelationship.type === 'many' ||
+                    f.fieldDef.structRelationship.type === 'nested') &&
                 f.fieldDef.fields.length > 1 && // leave arrays in parent.
                 this.parent.dialect.dontUnionIndex === false) {
                 const key = f.getFullOutputName();
@@ -2439,9 +2436,9 @@ class QueryQueryIndex extends QueryQuery {
         // if no fields were specified, look in the parent struct for strings.
         let fieldNames = this.firstSegment.fields || [];
         if (fieldNames.length === 0) {
-            fieldNames.push("**");
+            fieldNames.push('**');
         }
-        fieldNames = this.expandWildCards(fieldNames, (qf) => ["string", "number", "timestamp", "date"].indexOf(qf.fieldDef.type) !==
+        fieldNames = this.expandWildCards(fieldNames, qf => ['string', 'number', 'timestamp', 'date'].indexOf(qf.fieldDef.type) !==
             -1);
         return fieldNames;
     }
@@ -2495,12 +2492,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);
@@ -2510,29 +2507,27 @@ class QueryQueryIndex extends QueryQuery {
             this.resultStage = outputStageNames[0];
         }
         else {
-            this.resultStage = stageWriter.addStage(outputStageNames
-                .map((n) => `SELECT * FROM ${n}\n`)
-                .join(" UNION ALL \n"));
+            this.resultStage = stageWriter.addStage(outputStageNames.map(n => `SELECT * FROM ${n}\n`).join(' UNION ALL \n'));
         }
         return this.resultStage;
     }
     /**  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' },
         };
     }
 }
@@ -2542,14 +2537,14 @@ class QueryStruct extends QueryNode {
         super(fieldDef);
         this.nameMap = new Map();
         this.setParent(parent);
-        if ("model" in parent) {
+        if ('model' in parent) {
             this.model = parent.model;
             this.pathAliasMap = new Map();
-            if (fieldDef.structRelationship.type === "basetable") {
+            if (fieldDef.structRelationship.type === 'basetable') {
                 this.connectionName = fieldDef.structRelationship.connectionName;
             }
             else {
-                throw new Error("All root StructDefs should be a baseTable");
+                throw new Error('All root StructDefs should be a baseTable');
             }
         }
         else {
@@ -2569,14 +2564,14 @@ class QueryStruct extends QueryNode {
         for (const field of fields) {
             const as = (0, malloy_types_1.getIdentifier)(field);
             switch (field.type) {
-                case "struct": {
+                case 'struct': {
                     this.addFieldToNameMap(as, new QueryStruct(field, {
-                        "struct": this
+                        struct: this,
                     }));
                     break;
                 }
                 // case "reduce" || "project" || "index": {
-                case "turtle": {
+                case 'turtle': {
                     // not sure why we need to cast here...
                     this.addFieldToNameMap(as, QueryQuery.makeQuery(field, this));
                     break;
@@ -2587,8 +2582,8 @@ 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));
+        if (!this.nameMap.has('__distinct_key')) {
+            this.addFieldToNameMap('__distinct_key', new QueryFieldDistinctKey({ type: 'string', name: '__distinct_key' }, this));
         }
     }
     // generate unique string for the alias.
@@ -2612,7 +2607,7 @@ class QueryStruct extends QueryNode {
                 return name;
             }
             else {
-                throw new Error("Internal Error: cannot create unique alias name");
+                throw new Error('Internal Error: cannot create unique alias name');
             }
             // get the malloy name for this struct (will include a trailing dot)
             // return this.getFullOutputName().replace(/\.$/, "").replace(/\./g, "_o_");
@@ -2629,28 +2624,28 @@ class QueryStruct extends QueryNode {
         }
         const pkField = this.getPrimaryKeyField(this.fieldDef);
         const pkType = pkField.fieldDef.type;
-        if (pkType !== "string" && pkType !== "number") {
+        if (pkType !== 'string' && pkType !== 'number') {
             throw new Error(`Unknown Primary key data type for ${pkField.fieldDef.name}`);
         }
         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}`);
     }
     getSQLIdentifier() {
         if (this.unnestWithNumbers() && this.parent !== undefined) {
             const x = this.parent.getSQLIdentifier() +
-                "." +
+                '.' +
                 (0, malloy_types_1.getIdentifier)(this.fieldDef) +
                 `[${this.getIdentifier()}.__row_id]`;
             return x;
@@ -2662,17 +2657,17 @@ class QueryStruct extends QueryNode {
     // return the name of the field in SQL
     getIdentifier() {
         // if it is the root table, use provided alias if we have one.
-        if (this.fieldDef.structRelationship.type === "basetable") {
+        if (this.fieldDef.structRelationship.type === 'basetable') {
             if (this.fieldDef.as === undefined) {
-                return "base";
+                return 'base';
             }
             else {
                 return super.getIdentifier();
             }
         }
         // if this is an inline object, include the parents alias.
-        if (this.fieldDef.structRelationship.type === "inline" && this.parent) {
-            return this.parent.getSQLIdentifier() + "." + super.getIdentifier();
+        if (this.fieldDef.structRelationship.type === 'inline' && this.parent) {
+            return this.parent.getSQLIdentifier() + '.' + super.getIdentifier();
         }
         // we are somewhere in the join tree.  Make sure the alias is unique.
         return this.getAliasIdentifier();
@@ -2680,10 +2675,10 @@ class QueryStruct extends QueryNode {
     // return the name of the field in Malloy
     getFullOutputName() {
         if (this.parent) {
-            return (this.parent.getFullOutputName() + (0, malloy_types_1.getIdentifier)(this.fieldDef) + ".");
+            return (this.parent.getFullOutputName() + (0, malloy_types_1.getIdentifier)(this.fieldDef) + '.');
         }
         else {
-            return "";
+            return '';
         }
     }
     needsSymetricCalculation(resultSet) {
@@ -2696,16 +2691,16 @@ class QueryStruct extends QueryNode {
     }
     unnestWithNumbers() {
         return (this.dialect.unnestWithNumbers &&
-            this.fieldDef.structRelationship.type === "nested");
+            this.fieldDef.structRelationship.type === 'nested');
     }
     getJoinableParent() {
         // if it is inline it should always have a parent
-        if (this.fieldDef.structRelationship.type === "inline") {
+        if (this.fieldDef.structRelationship.type === 'inline') {
             if (this.parent) {
                 return this.parent.getJoinableParent();
             }
             else {
-                throw new Error(`Internal Error: inline struct cannot be root`);
+                throw new Error('Internal Error: inline struct cannot be root');
             }
         }
         return this;
@@ -2732,7 +2727,7 @@ class QueryStruct extends QueryNode {
      * they exist) to the structure.
      */
     resolveQueryFields() {
-        if (this.fieldDef.structSource.type === "query") {
+        if (this.fieldDef.structSource.type === 'query') {
             const structDef = this.model
                 .loadQuery(this.fieldDef.structSource.query, undefined)
                 .structs.pop();
@@ -2765,16 +2760,16 @@ class QueryStruct extends QueryNode {
         }
         else {
             if (this.parent === undefined) {
-                throw new Error("Expected this query struct to have a parent, as no model was present.");
+                throw new Error('Expected this query struct to have a parent, as no model was present.');
             }
             return this.parent.getModel();
         }
     }
     setParent(parent) {
-        if ("struct" in parent) {
+        if ('struct' in parent) {
             this.parent = parent.struct;
         }
-        if ("model" in parent) {
+        if ('model' in parent) {
             this.model = parent.model;
         }
         else {
@@ -2784,24 +2779,24 @@ class QueryStruct extends QueryNode {
     /** makes a new queryable field object from a fieldDef */
     makeQueryField(field) {
         switch (field.type) {
-            case "string":
+            case 'string':
                 return new QueryFieldString(field, this);
-            case "date":
+            case 'date':
                 return new QueryFieldDate(field, this);
-            case "timestamp":
+            case 'timestamp':
                 return new QueryFieldTimestamp(field, this);
-            case "number":
+            case 'number':
                 return new QueryFieldNumber(field, this);
-            case "boolean":
+            case 'boolean':
                 return new QueryFieldBoolean(field, this);
-            case "json":
+            case 'json':
                 return new QueryFieldJSON(field, this);
-            case "unsupported":
+            case 'unsupported':
                 return new QueryFieldUnsupported(field, this);
             // case "reduce":
             // case "project":
             // case "index":
-            case "turtle":
+            case 'turtle':
                 return new QueryTurtle(field, this);
             default:
                 throw new Error(`unknown field definition ${JSON.stringify(field)}`);
@@ -2811,7 +2806,7 @@ class QueryStruct extends QueryNode {
      * return a field if it exists, make one if we are passed a field definition.
      */
     getOrMakeField(fieldRef) {
-        if (typeof fieldRef === "string") {
+        if (typeof fieldRef === 'string') {
             return this.getFieldByName(fieldRef);
         }
         else {
@@ -2830,31 +2825,31 @@ class QueryStruct extends QueryNode {
     }
     structSourceSQL(stageWriter) {
         switch (this.fieldDef.structSource.type) {
-            case "table": {
+            case 'table': {
                 const tablePath = this.fieldDef.structSource.tablePath;
                 return this.dialect.quoteTablePath(tablePath);
             }
-            case "sql":
-                if (this.fieldDef.structSource.method === "nested" ||
-                    this.fieldDef.structSource.method === "lastStage") {
+            case 'sql':
+                if (this.fieldDef.structSource.method === 'nested' ||
+                    this.fieldDef.structSource.method === 'lastStage') {
                     return this.fieldDef.name;
                 }
-                else if (this.fieldDef.structSource.method === "subquery") {
+                else if (this.fieldDef.structSource.method === 'subquery') {
                     return `(${this.fieldDef.structSource.sqlBlock.selectStr})`;
                 }
                 throw new Error("Internal Error: Unknown structSource type 'sql' method");
-            case "nested":
+            case 'nested':
                 // 'name' is always the source field even if has been renamed through
                 // 'as'
-                return `UNNEST(this.fieldDef.name)`;
-            case "inline":
-                return "";
-            case "query": {
+                return 'UNNEST(this.fieldDef.name)';
+            case 'inline':
+                return '';
+            case 'query': {
                 // cache derived table.
                 const name = (0, malloy_types_1.getIdentifier)(this.fieldDef);
                 // this is a hack for now.  Need some way to denote this table
                 //  should be cached.
-                if (name.includes("cache")) {
+                if (name.includes('cache')) {
                     const dtStageWriter = new StageWriter(true, stageWriter);
                     this.model.loadQuery(this.fieldDef.structSource.query, dtStageWriter);
                     return dtStageWriter.addPDT(name, this.dialect);
@@ -2886,7 +2881,7 @@ class QueryStruct extends QueryNode {
     }
     /** get the componennts of a field path */
     static resolvePath(name) {
-        return name.split(".");
+        return name.split('.');
     }
     getChildByName(name) {
         return this.nameMap.get(name);
@@ -2942,14 +2937,14 @@ class QueryStruct extends QueryNode {
         }
     }
     getDistinctKey() {
-        if (this.fieldDef.structRelationship.type !== "inline") {
-            return this.getDimensionByName("__distinct_key");
+        if (this.fieldDef.structRelationship.type !== 'inline') {
+            return this.getDimensionByName('__distinct_key');
         }
         else if (this.parent) {
             return this.parent.getDistinctKey();
         }
         else {
-            throw new Error("Internal Error.  inline struct can not be top level");
+            throw new Error('Internal Error.  inline struct can not be top level');
         }
     }
     // take a TurtleDef that might have names and make it so it doesn't.
@@ -2970,10 +2965,10 @@ class QueryStruct extends QueryNode {
         pipeline = (0, cloneDeep_1.default)(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;
     }
@@ -2995,21 +2990,21 @@ class QueryModel {
         this.modelDef = modelDef;
         for (const s of Object.values(this.modelDef.contents)) {
             let qs;
-            if (s.type === "struct") {
-                qs = new QueryStruct(s, { "model": this });
+            if (s.type === 'struct') {
+                qs = new QueryStruct(s, { model: this });
                 this.structs.set((0, malloy_types_1.getIdentifier)(s), qs);
                 qs.resolveQueryFields();
             }
-            else if (s.type === "query") {
+            else if (s.type === 'query') {
                 /* TODO */
             }
             else {
-                throw new Error("Internal Error: Unknown structure type");
+                throw new Error('Internal Error: Unknown structure type');
             }
         }
     }
     parseQueryPath(name) {
-        const path = name.split(".");
+        const path = name.split('.');
         let struct;
         if ((struct = this.structs.get(path[0]))) {
             if (path.length > 1) {
@@ -3018,7 +3013,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`);
@@ -3035,28 +3030,28 @@ class QueryModel {
     }
     getStructFromRef(structRef) {
         let structDef;
-        if (typeof structRef === "string") {
+        if (typeof structRef === 'string') {
             return this.getStructByName(structRef);
         }
-        else if (structRef.type === "struct") {
+        else if (structRef.type === 'struct') {
             structDef = structRef;
         }
         else {
-            throw new Error("Broken for now");
+            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 = "";
+        const malloy = '';
         if (!stageWriter) {
             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);
@@ -3065,28 +3060,28 @@ class QueryModel {
             // for (const f of ret.outputStruct.fields) {
             //   fieldNames.push(getIdentifier(f));
             // }
-            const fieldNames = (0, malloy_types_1.getPhysicalFields)(ret.outputStruct).map((fieldDef) => q.parent.dialect.sqlMaybeQuoteIdentifier(fieldDef.name));
+            const fieldNames = (0, malloy_types_1.getPhysicalFields)(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,
+            lastStageName: ret.lastStageName,
             malloy,
             stageWriter,
-            "structs": [ret.outputStruct],
-            "connectionName": q.parent.connectionName
+            structs: [ret.outputStruct],
+            connectionName: q.parent.connectionName,
         };
     }
     compileQuery(query, finalize = true) {
         let newModel;
         const m = newModel || this;
         const ret = m.loadQuery(query, undefined, finalize);
-        const sourceExplore = typeof query.structRef === "string"
+        const sourceExplore = typeof query.structRef === 'string'
             ? query.structRef
             : // LTNOTE: the parser needs to capture the query before the |.  This will work
                 //  in most cases but isn't actually complete.
-                query.structRef.type === "struct"
+                query.structRef.type === 'struct'
                     ? query.structRef.as || query.structRef.name
-                    : "(need to figure this out)";
+                    : '(need to figure this out)';
         // 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(
@@ -3094,16 +3089,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) {
@@ -3113,28 +3108,28 @@ class QueryModel {
         // make a search index if one isn't modelled.
         const struct = this.getStructByName(explore);
         let indexQuery;
-        if (!struct.nameMap.get("search_index")) {
+        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");
-        const fieldValueColumn = struct.dialect.sqlMaybeQuoteIdentifier("fieldValue");
-        const fieldTypeColumn = struct.dialect.sqlMaybeQuoteIdentifier("fieldType");
+        const fieldNameColumn = struct.dialect.sqlMaybeQuoteIdentifier('fieldName');
+        const fieldValueColumn = struct.dialect.sqlMaybeQuoteIdentifier('fieldValue');
+        const fieldTypeColumn = struct.dialect.sqlMaybeQuoteIdentifier('fieldType');
         // if we've compiled the SQL before use it otherwise
         let sqlPDT = this.exploreSearchSQLMap.get(explore);
         if (sqlPDT === undefined) {
@@ -3146,25 +3141,25 @@ class QueryModel {
               ${fieldValueColumn},
               ${fieldTypeColumn},
               weight,
-              CASE WHEN lower(${fieldValueColumn}) LIKE  lower(${generateSQLStringLiteral(searchValue + "%")}) THEN 1 ELSE 0 END as match_first
+              CASE WHEN lower(${fieldValueColumn}) LIKE  lower(${generateSQLStringLiteral(searchValue + '%')}) THEN 1 ELSE 0 END as match_first
             FROM  ${await connection.manifestTemporaryTable(sqlPDT)}
-            WHERE lower(${fieldValueColumn}) LIKE lower(${generateSQLStringLiteral("%" + searchValue + "%")}) ${searchField !== undefined
+            WHERE lower(${fieldValueColumn}) LIKE lower(${generateSQLStringLiteral('%' + searchValue + '%')}) ${searchField !== undefined
             ? ` AND ${fieldNameColumn} = '` + searchField + "' \n"
-            : ""}
-            ORDER BY CASE WHEN lower(${fieldValueColumn}) LIKE  lower(${generateSQLStringLiteral(searchValue + "%")}) THEN 1 ELSE 0 END DESC, weight DESC
+            : ''}
+            ORDER BY CASE WHEN lower(${fieldValueColumn}) LIKE  lower(${generateSQLStringLiteral(searchValue + '%')}) THEN 1 ELSE 0 END DESC, weight DESC
             LIMIT ${limit}
           `;
         if (struct.dialect.hasFinalStage) {
-            query = `WITH __stage0 AS(\n${query}\n)\n${struct.dialect.sqlFinalStage("__stage0", [
+            query = `WITH __stage0 AS(\n${query}\n)\n${struct.dialect.sqlFinalStage('__stage0', [
                 fieldNameColumn,
                 fieldValueColumn,
                 fieldTypeColumn,
-                "weight",
-                "match_first"
+                'weight',
+                'match_first',
             ])}`;
         }
         const result = await connection.runSQL(query, {
-            "rowLimit": 1000
+            rowLimit: 1000,
         });
         return result.rows;
     }
@@ -3172,14 +3167,14 @@ class QueryModel {
 exports.QueryModel = QueryModel;
 function flattenQuery(model, query) {
     let structRef = query.structRef;
-    if (typeof structRef !== "string") {
+    if (typeof structRef !== 'string') {
         structRef = structRef.as || structRef.name;
     }
     const queryModel = new QueryModel(model);
     const queryStruct = queryModel.getStructByName(structRef);
     const turtleDef = queryStruct.flattenTurtleDef({
         ...query,
-        "type": "turtle"
+        type: 'turtle',
     });
     return turtleDef;
 }