@malloydata/malloy 0.0.303 → 0.0.305

package/dist/{model/composite_source_utils.js → lang/composite-source-utils.js}

@@ -3,9 +3,10 @@
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * This source code is licensed under the MIT license found in the
- *  LICENSE file in the root directory of this source tree.
+ * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpandedSegment = getExpandedSegment;
 exports.getPartitionCompositeDesc = getPartitionCompositeDesc;
 exports.resolveCompositeSources = resolveCompositeSources;
 exports.fieldUsagePaths = fieldUsagePaths;
@@ -24,10 +25,10 @@ exports.pathEq = pathEq;
 exports.pathBegins = pathBegins;
 exports.hasCompositesAnywhere = hasCompositesAnywhere;
 exports.logCompositeError = logCompositeError;
-exports.compileFilterExpression = compileFilterExpression;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
-const malloy_types_1 = require("./malloy_types");
-const utils_1 = require("../lang/utils");
+const malloy_types_1 = require("../model/malloy_types");
+const utils_1 = require("./utils");
+const utils_2 = require("../model/utils");
 const annotation_1 = require("../annotation");
 function _resolveCompositeSources(path, source, rootFields, nests, fieldUsage, 
 // for resolving nested composites; the list of sources to try
@@ -38,7 +39,7 @@ sources) {
     let anyComposites = false;
     let joinsProcessed = false;
     const nonCompositeFields = getNonCompositeFields(source);
-    const expandedForError = onlyCompositeUsage(expandFieldUsage(fieldUsage, rootFields).result, source.fields);
+    const expandedForError = onlyCompositeUsage(_expandFieldUsage(fieldUsage, rootFields).result, source.fields);
     if (source.type === 'composite') {
         let found = false;
         anyComposites = true;
@@ -63,9 +64,9 @@ sources) {
                     fieldNames.add((_a = field.as) !== null && _a !== void 0 ? _a : field.name);
                 }
             }
-            const fieldUsageWithWheres = (_b = mergeFieldUsage(fieldUsage, getFieldUsageFromFilterList(inputSource))) !== null && _b !== void 0 ? _b : [];
+            const fieldUsageWithWheres = (_b = mergeFieldUsage(getFieldUsageFromFilterList(inputSource), fieldUsage)) !== null && _b !== void 0 ? _b : [];
             const fieldsForLookup = [...nonCompositeFields, ...inputSource.fields];
-            const expanded = expandFieldUsage(fieldUsageWithWheres, fieldsForLookup);
+            const expanded = _expandFieldUsage(fieldUsageWithWheres, fieldsForLookup);
             if (expanded.missingFields.length > 0) {
                 // A lookup failed while expanding, which means this source certainly won't work
                 for (const missingField of expanded.missingFields) {
@@ -83,7 +84,7 @@ sources) {
             const expandedCategorized = categorizeFieldUsage(expanded.result);
             const compositeUsageInThisSource = onlyCompositeUsage(expandedCategorized.sourceUsage, source.fields);
             for (const usage of compositeUsageInThisSource) {
-                if (!fieldNames.has(usage.path[0])) {
+                if (usage.path.length > 0 && !fieldNames.has(usage.path[0])) {
                     fail({
                         type: 'missing-field',
                         field: usage,
@@ -176,7 +177,7 @@ sources) {
     }
     else if (source.partitionComposite !== undefined) {
         anyComposites = true;
-        const expanded = expandFieldUsage(fieldUsage, rootFields).result;
+        const expanded = _expandFieldUsage(fieldUsage, rootFields).result;
         // TODO possibly abort if expanded has missing fields...
         const expandedCategorized = categorizeFieldUsage(expanded);
         const { partitionFilter, issues } = getPartitionCompositeFilter(source.partitionComposite, expandedCategorized.sourceUsage);
@@ -198,7 +199,7 @@ sources) {
         };
     }
     if (!joinsProcessed) {
-        const expanded = expandFieldUsage(fieldUsage, getJoinFields(rootFields, path));
+        const expanded = _expandFieldUsage(fieldUsage, getJoinFields(rootFields, path));
         if (expanded.missingFields.length > 0) {
             return {
                 error: {
@@ -228,40 +229,192 @@ function onlyCompositeUsage(fieldUsage, fields) {
         }
     });
 }
-function expandFieldUsage(fieldUsage, fields) {
+function getExpandedSegment(segment, inputSource) {
     var _a;
-    const allFieldPathsReferenced = [...fieldUsage];
-    const joinPathsProcessed = [];
-    const missingFields = [];
-    for (let i = 0; i < allFieldPathsReferenced.length; i++) {
-        const reference = allFieldPathsReferenced[i];
-        const referenceJoinPath = reference.path.slice(0, -1);
-        // Look up this referenced field; if it is a composite field, then add it to the list
-        // of composite fields found;
-        // if it has composite usage, add those usages to the list of fields to look up next
-        // if it doesn't exist, then this source won't work.
-        let def;
-        try {
-            def = lookup(reference.path, fields);
+    if (segment.type === 'raw')
+        return segment;
+    const sourceExtensions = (0, malloy_types_1.isQuerySegment)(segment)
+        ? (_a = segment.extendSource) !== null && _a !== void 0 ? _a : []
+        : [];
+    const fields = mergeFields(inputSource.fields, sourceExtensions);
+    const collectedUngroupings = [];
+    let updatedSegment = segment;
+    if ((0, malloy_types_1.isQuerySegment)(segment)) {
+        // Single walk through query fields
+        const updatedQueryFields = segment.queryFields.map(field => {
+            if (field.type === 'fieldref') {
+                // Just return it - field usage already in segment.fieldUsage
+                return field;
+            }
+            else if (field.type === 'turtle') {
+                if (field.pipeline.length === 0)
+                    return field;
+                // Process entire turtle pipeline
+                const updatedPipeline = [];
+                let turtleInput = inputSource; // First stage sees parent's input
+                for (const stage of field.pipeline) {
+                    const processedStage = getExpandedSegment(stage, turtleInput);
+                    updatedPipeline.push(processedStage);
+                    if (processedStage.type === 'raw')
+                        continue;
+                    // Collect ungroupings from turtle with adjusted paths
+                    if (processedStage.expandedUngroupings) {
+                        const adjusted = processedStage.expandedUngroupings.map(u => ({
+                            ...u,
+                            path: [field.name, ...u.path],
+                        }));
+                        collectedUngroupings.push(...adjusted);
+                    }
+                    turtleInput = processedStage.outputStruct;
+                }
+                return { ...field, pipeline: updatedPipeline };
+            }
+            else {
+                // Regular fields - only collect ungroupings
+                collectedUngroupings.push(...(field.ungroupings || []));
+                return field;
+            }
+        });
+        updatedSegment = { ...segment, queryFields: updatedQueryFields };
+    }
+    const allFieldUsage = mergeFieldUsage(getFieldUsageFromFilterList(inputSource), segment.fieldUsage);
+    const expanded = _expandFieldUsage(allFieldUsage || [], fields);
+    // Merge ungroupings from direct collection and field expansion
+    const allUngroupings = [...collectedUngroupings, ...expanded.ungroupings];
+    return {
+        ...updatedSegment,
+        expandedFieldUsage: expanded.result,
+        activeJoins: expanded.activeJoins,
+        expandedUngroupings: allUngroupings,
+    };
+}
+function getJoin(jdMap, joinKey, joinPath) {
+    if (!jdMap[joinKey]) {
+        jdMap[joinKey] = { path: joinPath, dependsOn: new Set() };
+    }
+    return jdMap[joinKey];
+}
+function findActiveJoins(dependencies) {
+    const sorted = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = (key) => {
+        if (visited.has(key))
+            return;
+        if (visiting.has(key)) {
+            return;
         }
-        catch {
+        visiting.add(key);
+        const dep = dependencies[key];
+        if (dep) {
+            // Visit all dependencies first (depth-first)
+            for (const depKey of dep.dependsOn) {
+                visit(depKey);
+            }
+        }
+        visiting.delete(key);
+        visited.add(key);
+        // Add this join's path to the sorted list after its dependencies
+        if (dep) {
+            sorted.push({ path: dep.path });
+        }
+    };
+    // Visit all joins in the dependency graph
+    for (const key of Object.keys(dependencies)) {
+        visit(key);
+    }
+    return sorted;
+}
+/**
+ * Given a list of field usage requests, expand to include all the join on and join filter expressions
+ * needed to be able to reference those fields.
+ *
+ * @returns An object containing:
+ * - `result`: The expanded field usage, including usages from necessary joins
+ * - `missingFields`: References to fields which could not be resolved
+ * - `activeJoins`: Topologically sorted list of joins needed to resolve these uses
+ */
+function _expandFieldUsage(fieldUsage, fields) {
+    var _a, _b, _c;
+    const seen = {};
+    const missingFields = [];
+    const toProcess = [];
+    const activeJoinGraph = {};
+    const ungroupings = [];
+    // Initialize: mark original inputs and add them to processing queue
+    for (const usage of fieldUsage) {
+        const seenKey = (0, utils_2.pathToKey)('field', usage.path);
+        seen[seenKey] = usage;
+        toProcess.push(usage);
+    }
+    // Process the expanding queue
+    const fieldNameSpace = buildNamespace(fields);
+    for (let i = 0; i < toProcess.length; i++) {
+        const reference = toProcess[i];
+        if (reference.path.length === 0)
+            continue;
+        const def = inNamespace(reference.path, fieldNameSpace);
+        if (!def) {
             missingFields.push(reference);
             continue;
         }
         if ((0, malloy_types_1.isAtomic)(def)) {
             const fieldUsage = (_a = def.fieldUsage) !== null && _a !== void 0 ? _a : [];
-            allFieldPathsReferenced.push(...fieldUsageAt(joinedFieldUsage(referenceJoinPath, fieldUsage), reference.at).filter(u1 => !allFieldPathsReferenced.some(u2 => pathEq(u1.path, u2.path))));
+            // Add the atomic field's dependencies to the queue
+            const refPath = reference.path.slice(0, -1);
+            for (const usage of joinedFieldUsage(refPath, fieldUsage)) {
+                const key = (0, utils_2.pathToKey)('field', usage.path);
+                if (!seen[key]) {
+                    seen[key] = usage;
+                    toProcess.push(usage);
+                }
+                else if (usage.uniqueKeyRequirement) {
+                    seen[key].uniqueKeyRequirement = {
+                        isCount: (_b = usage.uniqueKeyRequirement.isCount) !== null && _b !== void 0 ? _b : (_c = seen[key].uniqueKeyRequirement) === null || _c === void 0 ? void 0 : _c.isCount,
+                    };
+                }
+            }
+            if (def.ungroupings) {
+                ungroupings.push(...joinedUngroupings(refPath, def.ungroupings));
+            }
         }
-        if (reference.path.length > 1) {
-            if (!joinPathsProcessed.some(p => pathEq(p, referenceJoinPath))) {
-                joinPathsProcessed.push(referenceJoinPath);
-                const join = lookup(referenceJoinPath, fields);
-                const joinFieldUsage = getJoinFieldUsage(join, referenceJoinPath);
-                allFieldPathsReferenced.push(...fieldUsageAt(joinFieldUsage, reference.at).filter(u1 => !allFieldPathsReferenced.some(u2 => pathEq(u1.path, u2.path))));
+        // For paths through joins, additionaly track join relationships
+        for (let joinLen = 1; joinLen < reference.path.length; joinLen++) {
+            const joinPath = reference.path.slice(0, joinLen);
+            const joinDef = inNamespace(joinPath, fieldNameSpace);
+            if (!joinDef)
+                break;
+            const joinKey = (0, utils_2.pathToKey)('join', joinPath);
+            const thisDep = getJoin(activeJoinGraph, joinKey, joinPath);
+            if ((0, malloy_types_1.isJoined)(joinDef) && !thisDep.checked) {
+                thisDep.checked = true;
+                const joinFieldUsage = getJoinFieldUsage(joinDef, joinPath);
+                // Add join's field dependencies to the queue
+                for (const usage of joinFieldUsage) {
+                    const key = (0, utils_2.pathToKey)('field', usage.path);
+                    if (!seen[key]) {
+                        seen[key] = usage;
+                        toProcess.push(usage);
+                    }
+                    // Track join-to-join dependencies
+                    const isInternalReference = usage.path.length === joinPath.length + 1 &&
+                        pathBegins(usage.path, joinPath);
+                    if (!isInternalReference && usage.path.length > 1) {
+                        const dependencyPath = usage.path.slice(0, -1);
+                        const dependencyKey = (0, utils_2.pathToKey)('join', dependencyPath);
+                        getJoin(activeJoinGraph, dependencyKey, dependencyPath);
+                        thisDep.dependsOn.add(dependencyKey);
+                    }
+                }
             }
         }
     }
-    return { result: allFieldPathsReferenced, missingFields };
+    return {
+        result: Object.values(seen),
+        missingFields,
+        activeJoins: findActiveJoins(activeJoinGraph),
+        ungroupings,
+    };
 }
 function categorizeFieldUsage(fieldUsage) {
     var _a;
@@ -271,7 +424,7 @@ function categorizeFieldUsage(fieldUsage) {
         joinUsage: {},
     };
     for (const usage of fieldUsage) {
-        if (usage.path.length === 1) {
+        if (usage.path.length <= 1) {
             categorized.sourceUsage.push(usage);
         }
         else {
@@ -497,18 +650,25 @@ function processJoins(path, base, rootFields, nests, categorizedFieldUsage) {
     }
     return { anyComposites, errors };
 }
+function segmentFieldUsage(segment) {
+    var _a;
+    return ((_a = ((0, malloy_types_1.isQuerySegment)(segment) || (0, malloy_types_1.isIndexSegment)(segment)
+        ? segment.fieldUsage
+        : undefined)) !== null && _a !== void 0 ? _a : emptyFieldUsage());
+}
 function getFieldUsageFromFilterList(source) {
     var _a;
     return ((_a = source.filterList) !== null && _a !== void 0 ? _a : []).flatMap(filter => { var _a; return (_a = filter.fieldUsage) !== null && _a !== void 0 ? _a : []; });
 }
-function resolveCompositeSources(source, segment, fieldUsage) {
+function resolveCompositeSources(source, segment) {
     var _a, _b;
+    const fieldUsage = segmentFieldUsage(segment);
     const sourceExtensions = (0, malloy_types_1.isQuerySegment)(segment)
         ? (_a = segment.extendSource) !== null && _a !== void 0 ? _a : []
         : [];
     const nestLevels = extractNestLevels(segment);
     const fields = mergeFields(source.fields, sourceExtensions);
-    const fieldUsageWithWheres = (_b = mergeFieldUsage(fieldUsage, getFieldUsageFromFilterList(source))) !== null && _b !== void 0 ? _b : [];
+    const fieldUsageWithWheres = (_b = mergeFieldUsage(getFieldUsageFromFilterList(source), fieldUsage)) !== null && _b !== void 0 ? _b : [];
     const result = _resolveCompositeSources([], source, fields, nestLevels, fieldUsageWithWheres);
     if ('success' in result) {
         if (result.anyComposites) {
@@ -623,7 +783,7 @@ function nestLevelsAt(nests, at) {
     return {
         fieldsReferencedDirectly: fieldUsageAt(nests.fieldsReferencedDirectly, at),
         nested: nests.nested.map(n => nestLevelsAt(n, at)),
-        fieldsReferenced: fieldUsageAt(nests.fieldsReferencedDirectly, at),
+        fieldsReferenced: fieldUsageAt(nests.fieldsReferenced, at),
         ungroupings: ungroupingsAt(nests.ungroupings, at),
         requiredGroupBys: (_a = requiredGroupBysAt(nests.requiredGroupBys, at)) !== null && _a !== void 0 ? _a : [],
         singleValueFilters: nests.singleValueFilters,
@@ -664,6 +824,7 @@ function joinedUngroupings(joinPath, ungroupings) {
         ...u,
         fieldUsage: joinedFieldUsage(joinPath, u.fieldUsage),
         requiresGroupBy: joinedRequiredGroupBys(joinPath, u.requiresGroupBy),
+        path: joinPath, // Set the path to the join path
     }));
 }
 function extractNestLevels(segment) {
@@ -688,7 +849,32 @@ function extractNestLevels(segment) {
             }
             else if (field.type === 'turtle') {
                 const head = field.pipeline[0];
-                nested.push(nestLevelsAt(extractNestLevels(head), head.referencedAt));
+                const nestedLevels = extractNestLevels(head);
+                // Check if the nested query has ANY unique key requirements
+                let hasNestedUniqueKeyReqs = nestedLevels.fieldsReferenced.some(usage => usage.uniqueKeyRequirement);
+                // Also check the head segment's fieldUsage directly
+                if ((0, malloy_types_1.isQuerySegment)(head) && head.fieldUsage) {
+                    const hasDirectUniqueKeyReqs = head.fieldUsage.some(usage => usage.uniqueKeyRequirement);
+                    if (hasDirectUniqueKeyReqs) {
+                        hasNestedUniqueKeyReqs = true;
+                    }
+                }
+                // If the nested query has any unique key requirements, parent needs unique input
+                if (hasNestedUniqueKeyReqs) {
+                    fieldsReferenced.push({
+                        path: [],
+                        uniqueKeyRequirement: { isCount: true },
+                        at: head.referencedAt,
+                    });
+                }
+                const adjustedUngroupings = nestedLevels.ungroupings.map(u => ({
+                    ...u,
+                    path: [field.name, ...u.path],
+                }));
+                nested.push(nestLevelsAt({
+                    ...nestedLevels,
+                    ungroupings: adjustedUngroupings,
+                }, head.referencedAt));
             }
             else {
                 const fieldUsage = (_a = field.fieldUsage) !== null && _a !== void 0 ? _a : [];
@@ -734,7 +920,7 @@ function getSingleValueFilterFields(filter) {
 function isSingleValueFilterNode(e) {
     if (e.node === 'filterMatch') {
         if (e.kids.expr.node === 'field') {
-            const result = compileFilterExpression(e.dataType, e.kids.filterExpr);
+            const result = translateFilterExpression(e.dataType, e.kids.filterExpr);
             if (!result)
                 return [];
             if ((result.parsed.operator === 'null' && !result.parsed.not) ||
@@ -783,6 +969,8 @@ function expandRefs(nests, fields) {
     const joinPathsProcessed = [];
     const missingFields = [];
     for (let i = 0; i < references.length; i++) {
+        if (references[i].path.length === 0)
+            continue;
         const field = references[i];
         let def;
         try {
@@ -795,6 +983,16 @@ function expandRefs(nests, fields) {
         const joinPath = field.path.slice(0, -1);
         if ((0, malloy_types_1.isTurtle)(def)) {
             const head = def.pipeline[0];
+            const nestedLevels = extractNestLevels(head);
+            // Update paths for ungroupings in nested turtle
+            const adjustedLevels = {
+                ...nestedLevels,
+                ungroupings: nestedLevels.ungroupings.map(u => ({
+                    ...u,
+                    path: field.path, // This IS the correct path to the turtle field
+                })),
+            };
+            newNests.push(adjustedLevels);
             newNests.push(extractNestLevels(head));
         }
         else if ((0, malloy_types_1.isAtomic)(def)) {
@@ -852,6 +1050,7 @@ function expandRefs(nests, fields) {
         missingFields.push(...((_d = expanded.missingFields) !== null && _d !== void 0 ? _d : []));
         nested.push(expanded.result);
         unsatisfiableGroupBys.push(...expanded.result.unsatisfiableGroupBys);
+        allUngroupings.push(...expanded.result.ungroupings);
     }
     return {
         result: {
@@ -860,6 +1059,7 @@ function expandRefs(nests, fields) {
             unsatisfiableGroupBys,
             nested,
             singleValueFilters: nests.singleValueFilters,
+            ungroupings: allUngroupings,
         },
         missingFields: missingFields.length > 0 ? missingFields : undefined,
     };
@@ -867,11 +1067,11 @@ function expandRefs(nests, fields) {
 function getJoinFieldUsage(join, joinPath) {
     var _a, _b;
     return ((_b = mergeFieldUsage(
+    // For `fieldUsage` from join `where`s, we need the path including the join name
+    joinedFieldUsage(joinPath, (0, malloy_types_1.isSourceDef)(join) ? getFieldUsageFromFilterList(join) : []), 
     // For `fieldUsage` from join `on`, we need the path excluding the join name, since it's
     // already rooted at the parent
-    joinedFieldUsage(joinPath.slice(0, -1), (_a = join.fieldUsage) !== null && _a !== void 0 ? _a : []), 
-    // For `fieldUsage` from join `where`s, we need the path including the join name
-    joinedFieldUsage(joinPath, (0, malloy_types_1.isSourceDef)(join) ? getFieldUsageFromFilterList(join) : []))) !== null && _b !== void 0 ? _b : []);
+    joinedFieldUsage(joinPath.slice(0, -1), (_a = join.fieldUsage) !== null && _a !== void 0 ? _a : []))) !== null && _b !== void 0 ? _b : []);
 }
 function isUngroupedBy(ungrouping, groupedBy) {
     if (ungrouping.ungroupedFields === '*')
@@ -912,6 +1112,36 @@ function pathEq(a, b) {
 function pathBegins(path, prefix) {
     return path.length >= prefix.length && prefix.every((s, i) => path[i] === s);
 }
+function buildNamespace(fields) {
+    var _a;
+    const namespace = {
+        fields: {},
+        nested: {},
+    };
+    for (const field of fields) {
+        const name = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+        namespace.fields[name] = field;
+        // If it's a join with nested fields, recursively build its hierarchy
+        if ((0, malloy_types_1.isJoined)(field) && field.fields) {
+            namespace.nested[name] = buildNamespace(field.fields);
+        }
+    }
+    return namespace;
+}
+function inNamespace(path, space) {
+    const head = path[0];
+    const def = space.fields[head];
+    if (def === undefined)
+        return def;
+    if (path.length === 1) {
+        return def;
+    }
+    const nested = space.nested[head];
+    if (!nested) {
+        return undefined;
+    }
+    return inNamespace(path.slice(1), nested);
+}
 function lookup(field, fields) {
     const [head, ...rest] = field;
     const def = fields.find(f => { var _a; return ((_a = f.as) !== null && _a !== void 0 ? _a : f.name) === head; });
@@ -1033,7 +1263,7 @@ function logCompositeError(error, logTo) {
         logTo.logError('could-not-resolve-composite-source', 'Could not resolve composite source');
     }
 }
-function compileFilterExpression(ft, fexpr) {
+function translateFilterExpression(ft, fexpr) {
     if (fexpr.node !== 'filterLiteral') {
         return undefined;
     }
@@ -1060,4 +1290,4 @@ function compileFilterExpression(ft, fexpr) {
     }
     return undefined;
 }
-//# sourceMappingURL=composite_source_utils.js.map
+//# sourceMappingURL=composite-source-utils.js.map

package/dist/lang/test/parse-expects.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentLocation } from '../../model';
+import { type DocumentLocation } from '../../model';
 import type { LogSeverity } from '../parse-log';
 type MessageProblemSpec = {
     severity: LogSeverity;

package/dist/lang/test/parse-expects.js

@@ -23,6 +23,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../../model");
 const expr_to_str_1 = require("./expr-to-str");
 const test_translator_1 = require("./test-translator");
 function rangeToStr(loc) {
@@ -241,8 +242,11 @@ expect.extend({
             return badRefs;
         }
         const actual = bx.generated().fieldUsage;
-        const actualPaths = actual.map(u => u.path);
-        const pass = this.equals(actualPaths, paths);
+        const actualPaths = actual.filter(u => (0, model_1.bareFieldUsage)(u)).map(u => u.path);
+        // there is no guarantee of the order of field usage data, so we sort the two lists
+        // so i need to compare sorted versions of the two lists... we can sort on path.join('.)
+        // maybe make a lambda for that and pass it to sort
+        const pass = this.equals(actualPaths.sort((a, b) => a.join('.').localeCompare(b.join('.'))), paths.sort((a, b) => a.join('.').localeCompare(b.join('.'))));
         const msg = pass
             ? `Matched: ${actual}`
             : this.utils.diff(paths, actualPaths);

package/dist/lang/test/test-translator.js

@@ -564,7 +564,7 @@ function getSelectOneStruct(sqlBlock) {
             type: 'sql_select',
             name: key,
             dialect: 'standardsql',
-            connection: 'bigquery',
+            connection: '_db_',
             selectStr: sqlBlock.selectStr,
             fields: [{ type: 'number', name: 'one' }],
         },

package/dist/malloy.js

@@ -2098,7 +2098,7 @@ class ModelMaterializer extends FluentState {
           group_by: fieldName
           aggregate: cardinality is count(fieldValue)
           nest: values is {
-            select: fieldValue, weight
+            group_by: fieldValue, weight
             order_by: weight desc
             limit: ${limit}
           }

package/dist/model/expression_compiler.d.ts

@@ -0,0 +1,27 @@
+import type { Expr, FunctionCallNode, FunctionOverloadDef, FunctionOrderBy, FieldnameNode, OutputFieldNode, GenericSQLExpr, FilteredExpr, UngroupNode, ParameterNode, SpreadExpr, AggregateExpr, SourceReferenceNode, CaseExpr } from './malloy_types';
+import { type FieldInstanceResult } from './field_instance';
+import { GenerateState } from './utils';
+import type { QueryStruct, QueryField } from './query_node';
+/**
+ * Converts an expression to SQL.
+ * This function was extracted from QueryField.exprToSQL to break circular dependencies.
+ */
+export declare function exprToSQL(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, exprToTranslate: Expr, state?: GenerateState): string;
+export declare function generateFunctionCallExpression(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, frag: FunctionCallNode, state: GenerateState): string;
+export declare function generateFieldFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: FieldnameNode, state: GenerateState): string;
+export declare function generateOutputFieldFragment(field: QueryField, resultSet: FieldInstanceResult, _context: QueryStruct, frag: OutputFieldNode, _state: GenerateState): string;
+export declare function generateParameterFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: ParameterNode, state: GenerateState): string;
+export declare function generateFilterFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: FilteredExpr, state: GenerateState): string;
+export declare function generateDimFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: Expr, state: GenerateState): string;
+export declare function generateUngroupedFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: UngroupNode, state: GenerateState): string;
+export declare function generateDistinctKeyIfNecessary(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, structPath: string[] | undefined): string | undefined;
+export declare function generateSumFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateSymmetricFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateAvgFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateCountFragment(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: AggregateExpr, state: GenerateState): string;
+export declare function generateSpread(field: QueryField, _resultSet: FieldInstanceResult, _context: QueryStruct, _frag: SpreadExpr, _state: GenerateState): string;
+export declare function generateSourceReference(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, expr: SourceReferenceNode): string;
+export declare function generateCaseSQL(field: QueryField, pf: CaseExpr): string;
+export declare function getFunctionOrderBy(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, state: GenerateState, orderBy: FunctionOrderBy[], args: Expr[], overload: FunctionOverloadDef): string | undefined;
+export declare function getAnalyticPartitions(field: QueryField, resultStruct: FieldInstanceResult, extraPartitionFields?: string[]): string[];
+export declare function stringsFromSQLExpression(field: QueryField, resultSet: FieldInstanceResult, context: QueryStruct, e: GenericSQLExpr, state: GenerateState): Generator<string, void, unknown>;