@malloydata/malloy 0.0.434 → 0.0.435

package/dist/model/query_query.js

@@ -34,9 +34,52 @@ function fieldIsAnalytic(fi) {
     return ((0, malloy_types_1.hasExpression)(fi.f.fieldDef) &&
         (0, malloy_types_1.expressionIsAnalytic)(fi.f.fieldDef.expressionType));
 }
-// 1-based SELECT positions of the dimension columns, for `GROUP BY 1,2,...`.
-function groupByPositions(columns) {
-    return columns.flatMap((c, i) => (c.isDimension ? [i + 1] : []));
+// `<expr> as <name>`
+function aliasedColumn(expr, name, role) {
+    var _a;
+    return {
+        sql: `${expr} as ${name}`,
+        expr,
+        name,
+        isDimension: role.isDimension,
+        constant: (_a = role.constant) !== null && _a !== void 0 ? _a : false,
+    };
+}
+// Does a field's expression read any column of its source?
+function readsColumn(fieldDef) {
+    if (!(0, malloy_types_1.hasExpression)(fieldDef)) {
+        return true;
+    }
+    for (const node of (0, utils_1.exprWalk)(fieldDef.e)) {
+        switch (node.node) {
+            case 'field':
+            case 'outputField':
+            case 'source-reference':
+            case 'genericSQLExpr':
+                return true;
+        }
+    }
+    return false;
+}
+// The dimension columns as GROUP BY terms: 1-based SELECT positions, or the
+// expressions for a dialect without ordinals in GROUP BY.
+function groupByTerms(dialect, columns) {
+    if (dialect.groupByClause === 'ordinal') {
+        return columns.flatMap((c, i) => (c.isDimension ? [`${i + 1}`] : []));
+    }
+    return columns.flatMap(c => (c.isDimension && !c.constant ? [c.expr] : []));
+}
+function sqlGroupBy(dialect, columns) {
+    const terms = groupByTerms(dialect, columns);
+    if (terms.length > 0) {
+        return `GROUP BY ${terms.join(',')}\n`;
+    }
+    // Dimensions which are all constants still make one group of the input
+    if (dialect.groupByClause === 'expression' &&
+        columns.some(c => c.isDimension)) {
+        return 'GROUP BY ()\n';
+    }
+    return '';
 }
 function pushDialectField(dl, f) {
     const { sqlExpression, rawName } = f;
@@ -904,9 +947,10 @@ class QueryQuery extends query_node_1.QueryField {
         // Joins
         let structSQL = this.getStructSourceSQL(qs, stageWriter);
         if ((0, malloy_types_1.isIndexSegment)(this.firstSegment)) {
-            structSQL = this.parent.dialect.sqlSampleTable(structSQL, this.firstSegment.sample);
+            structSQL = this.parent.dialect.sqlSampleTable(structSQL, this.firstSegment.sample, qs.structDef.type === 'table');
             if (this.firstSegment.sample) {
-                structSQL = stageWriter.addStage(`SELECT * from ${structSQL} as x limit 100000 `);
+                const d = this.parent.dialect;
+                structSQL = stageWriter.addStage(`SELECT * from ${structSQL} as x ${d.sqlOrderByLimit([], 100000)}`);
             }
         }
         if ((0, malloy_types_1.isBaseTable)(qs.structDef)) {
@@ -950,7 +994,6 @@ class QueryQuery extends query_node_1.QueryField {
         return result;
     }
     genereateSQLOrderBy(queryDef, resultStruct) {
-        let s = '';
         // Collect array joins for dialects that need explicit ordering.
         // Only for project queries - reduce queries aggregate rows so individual
         // row order doesn't matter, and we can't ORDER BY columns not in GROUP BY.
@@ -964,24 +1007,24 @@ class QueryQuery extends query_node_1.QueryField {
             // For project without explicit ordering, we still need array ordinality
             // ordering if the dialect requires it
             if (arrayJoins.length === 0) {
-                return ''; // No default ordering for project.
+                return []; // No default ordering for project.
             }
         }
         // Intermediate results (in a pipeline or join) that have no limit, don't need an orderby
         //  Some database don't have this optimization.
         if (this.fieldDef.pipeline.length > 1 && queryDef.limit === undefined) {
-            return '';
+            return [];
         }
         // ignore orderby if all aggregates.
         if (resultStruct.getRepeatedResultType() === 'inline_all_numbers') {
-            return '';
+            return [];
         }
         // if we are in the last stage of a query and the query is a subquery
         //  and has no limit, ORDER BY is superfluous
         if (this.isJoinedSubquery &&
             this.fieldDef.pipeline.length === 1 &&
             queryDef.limit === undefined) {
-            return '';
+            return [];
         }
         const orderBy = queryDef.orderBy || resultStruct.calculateDefaultOrderBy();
         const o = [];
@@ -1024,10 +1067,7 @@ class QueryQuery extends query_node_1.QueryField {
         for (const aj of arrayJoins) {
             o.push(`${aj.alias}_outer.__row_id ASC`);
         }
-        if (o.length > 0) {
-            s = this.parent.dialect.sqlOrderBy(o, 'query') + '\n';
-        }
-        return s;
+        return o;
     }
     /**
      * The single-scan form, with no `group_set` fan-out: one `SELECT` over the
@@ -1040,45 +1080,36 @@ class QueryQuery extends query_node_1.QueryField {
      */
     generateSimpleSQL(stageWriter) {
         this.rootResult.emitsGroupSet = false;
-        let s = '';
-        s += 'SELECT \n';
-        const fields = [];
+        const limit = !(0, malloy_types_1.isRawSegment)(this.firstSegment) && this.firstSegment.limit
+            ? this.firstSegment.limit
+            : undefined;
+        let s = 'SELECT \n';
+        // A projection groups nothing; a reduce groups its scalar result fields.
+        const grouped = this.firstSegment.type === 'reduce';
+        const columns = [];
         const outputPipelinedSQL = [];
         for (const [name, fi] of this.rootResult.allFields) {
             const sqlName = this.parent.dialect.sqlQuoteIdentifier(name);
             if (fi instanceof field_instance_1.FieldInstanceField) {
                 if (fi.fieldUsage.type === 'result') {
-                    fields.push(` ${fi.generateExpression()} as ${sqlName}`);
+                    columns.push(aliasedColumn(fi.generateExpression(), sqlName, {
+                        isDimension: grouped && (0, query_node_1.isScalarField)(fi.f),
+                        constant: !readsColumn(fi.f.fieldDef),
+                    }));
                 }
             }
             else if (fi instanceof field_instance_1.FieldInstanceResult) {
                 const turtle = this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL, true);
-                fields.push(` ${turtle} as ${sqlName}`);
+                columns.push(aliasedColumn(turtle, sqlName, { isDimension: false }));
             }
         }
-        s += (0, utils_1.indent)(fields.join(',\n')) + '\n';
+        s += (0, utils_1.indent)(columns.map(c => ` ${c.sql}`).join(',\n')) + '\n';
         s += this.generateSQLJoins(stageWriter);
         s += this.generateSQLFilters(this.rootResult, 'where').sql('where');
-        // group by
-        if (this.firstSegment.type === 'reduce') {
-            const n = [];
-            for (const field of this.rootResult.fields()) {
-                const fi = field;
-                if (fi.fieldUsage.type === 'result' && (0, query_node_1.isScalarField)(fi.f)) {
-                    n.push(fi.fieldUsage.resultIndex.toString());
-                }
-            }
-            if (n.length > 0) {
-                s += `GROUP BY ${n.join(',')}\n`;
-            }
-        }
+        s += sqlGroupBy(this.parent.dialect, columns);
         s += this.generateSQLFilters(this.rootResult, 'having').sql('having');
-        // order by
-        s += this.genereateSQLOrderBy(this.firstSegment, this.rootResult);
-        // limit
-        if (!(0, malloy_types_1.isRawSegment)(this.firstSegment) && this.firstSegment.limit) {
-            s += `LIMIT ${this.firstSegment.limit}\n`;
-        }
+        // order by, limit
+        s += this.parent.dialect.sqlOrderByLimit(this.genereateSQLOrderBy(this.firstSegment, this.rootResult), limit);
         this.resultStage = stageWriter.addStage(s);
         // Consumes any pipelined turtle output. The nests that reach here are
         // single-stage (canUseSingleGroupSetSQL), so outputPipelinedSQL is empty and
@@ -1190,6 +1221,7 @@ class QueryQuery extends query_node_1.QueryField {
                             });
                             output.columns.push({
                                 sql: outputFieldName,
+                                expr: outputFieldName,
                                 name: outputName,
                                 isDimension: true,
                             });
@@ -1198,6 +1230,7 @@ class QueryQuery extends query_node_1.QueryField {
                                 const outputFieldNameString = `__lateral_join_bag.${outputNameString}`;
                                 output.columns.push({
                                     sql: outputFieldNameString,
+                                    expr: outputFieldNameString,
                                     name: outputNameString,
                                     isDimension: true,
                                 });
@@ -1210,19 +1243,14 @@ class QueryQuery extends query_node_1.QueryField {
                         }
                         else {
                             // just treat it like a regular field.
-                            output.columns.push({
-                                sql: `${exp} as ${outputName}`,
-                                name: outputName,
+                            output.columns.push(aliasedColumn(exp, outputName, {
                                 isDimension: true,
-                            });
+                                constant: !readsColumn(fi.f.fieldDef),
+                            }));
                         }
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
-                        output.columns.push({
-                            sql: `${exp} as ${outputName}`,
-                            name: outputName,
-                            isDimension: false,
-                        });
+                        output.columns.push(aliasedColumn(exp, outputName, { isDimension: false }));
                     }
                 }
             }
@@ -1232,11 +1260,7 @@ class QueryQuery extends query_node_1.QueryField {
                 }
                 else if (fi.firstSegment.type === 'project') {
                     const s = this.generateTurtleSQL(fi, stageWriter, outputName, output.outputPipelinedSQL);
-                    output.columns.push({
-                        sql: `${s} as ${outputName}`,
-                        name: outputName,
-                        isDimension: false,
-                    });
+                    output.columns.push(aliasedColumn(s, outputName, { isDimension: false }));
                 }
             }
         }
@@ -1254,11 +1278,7 @@ class QueryQuery extends query_node_1.QueryField {
             }
             else {
                 resultSet.hasHaving = true;
-                output.columns.push({
-                    sql: `CASE WHEN group_set=${resultSet.groupSet} THEN CASE WHEN ${having.sql()} THEN 0 ELSE 1 END END as __delete__${resultSet.groupSet}`,
-                    name: `__delete__${resultSet.groupSet}`,
-                    isDimension: false,
-                });
+                output.columns.push(aliasedColumn(`CASE WHEN group_set=${resultSet.groupSet} THEN CASE WHEN ${having.sql()} THEN 0 ELSE 1 END END`, `__delete__${resultSet.groupSet}`, { isDimension: false }));
             }
         }
     }
@@ -1437,7 +1457,14 @@ class QueryQuery extends query_node_1.QueryField {
         let from = this.generateSQLJoins(stageWriter);
         const wheres = this.generateSQLWhereTurtled();
         const f = {
-            columns: [{ sql: 'group_set', name: 'group_set', isDimension: true }],
+            columns: [
+                {
+                    sql: 'group_set',
+                    expr: 'group_set',
+                    name: 'group_set',
+                    isDimension: true,
+                },
+            ],
             lateralJoinSQLExpressions: [],
             groupsAggregated: [],
             outputPipelinedSQL: [],
@@ -1447,7 +1474,7 @@ class QueryQuery extends query_node_1.QueryField {
             throw new malloy_compile_error_1.MalloyCompileError("Cannot use 'select:' in a stage that contains nested views. " +
                 'Use `group_by:` or restructure the pipeline.', 'compiler-project-with-turtles', this.fieldDef.location);
         }
-        const groupBy = 'GROUP BY ' + groupByPositions(f.columns).join(',') + '\n';
+        const groupBy = sqlGroupBy(this.parent.dialect, f.columns);
         from += this.parent.dialect.sqlGroupSetTable(this.maxGroupSet) + '\n';
         s += (0, utils_1.indent)(f.columns.map(c => c.sql).join(',\n')) + '\n';
         if (f.lateralJoinSQLExpressions.length > 0) {
@@ -1469,19 +1496,11 @@ class QueryQuery extends query_node_1.QueryField {
                 if (fi.fieldUsage.type === 'result') {
                     if ((0, query_node_1.isScalarField)(fi.f)) {
                         const exp = (0, utils_1.caseGroup)(resultSet.groupSet > 0 ? resultSet.childGroups : [], sqlFieldName);
-                        output.columns.push({
-                            sql: `${exp} as ${sqlFieldName}`,
-                            name: sqlFieldName,
-                            isDimension: true,
-                        });
+                        output.columns.push(aliasedColumn(exp, sqlFieldName, { isDimension: true }));
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
                         const exp = this.parent.dialect.sqlAnyValue(resultSet.groupSet, sqlFieldName);
-                        output.columns.push({
-                            sql: `${exp} as ${sqlFieldName}`,
-                            name: sqlFieldName,
-                            isDimension: false,
-                        });
+                        output.columns.push(aliasedColumn(exp, sqlFieldName, { isDimension: false }));
                     }
                 }
             }
@@ -1496,11 +1515,7 @@ class QueryQuery extends query_node_1.QueryField {
                         toGroup: resultSet.groupSet,
                     });
                     groupsToMap.push(fi.groupSet);
-                    output.columns.push({
-                        sql: `${s} as ${sqlFieldName}`,
-                        name: sqlFieldName,
-                        isDimension: false,
-                    });
+                    output.columns.push(aliasedColumn(s, sqlFieldName, { isDimension: false }));
                 }
                 else {
                     this.generateDepthNFields(depth, fi, output, stageWriter);
@@ -1517,12 +1532,10 @@ class QueryQuery extends query_node_1.QueryField {
                 for (const m of output.groupsAggregated) {
                     groupSetSQL += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
                 }
-                groupSetSQL += 'ELSE group_set END as group_set';
-                output.columns[0] = {
-                    sql: groupSetSQL,
-                    name: 'group_set',
+                groupSetSQL += 'ELSE group_set END';
+                output.columns[0] = aliasedColumn(groupSetSQL, 'group_set', {
                     isDimension: true,
-                };
+                });
             }
             // For hasLateralColumnAliasInSelect, the remap is handled in
             // generateSQLDepthN to avoid adding it multiple times from recursion.
@@ -1531,7 +1544,14 @@ class QueryQuery extends query_node_1.QueryField {
     generateSQLDepthN(depth, stageWriter, stageName) {
         let s = 'SELECT \n';
         const f = {
-            columns: [{ sql: 'group_set', name: 'group_set', isDimension: true }],
+            columns: [
+                {
+                    sql: 'group_set',
+                    expr: 'group_set',
+                    name: 'group_set',
+                    isDimension: true,
+                },
+            ],
             lateralJoinSQLExpressions: [],
             groupsAggregated: [],
             outputPipelinedSQL: [],
@@ -1551,8 +1571,13 @@ class QueryQuery extends query_node_1.QueryField {
             for (const m of f.groupsAggregated) {
                 groupSetSQL += `WHEN group_set=${m.fromGroup} THEN ${m.toGroup} `;
             }
-            groupSetSQL += 'ELSE group_set END as __remapped_group_set';
-            f.columns[0] = { sql: groupSetSQL, name: 'group_set', isDimension: true };
+            groupSetSQL += 'ELSE group_set END';
+            f.columns[0] = {
+                sql: `${groupSetSQL} as __remapped_group_set`,
+                expr: groupSetSQL,
+                name: 'group_set',
+                isDimension: true,
+            };
         }
         s += (0, utils_1.indent)(f.columns.map(c => c.sql).join(',\n')) + '\n';
         s += `FROM ${stageName}\n`;
@@ -1560,10 +1585,7 @@ class QueryQuery extends query_node_1.QueryField {
         if (where.length > 0) {
             s += `WHERE ${where}\n`;
         }
-        const dimensionPositions = groupByPositions(f.columns);
-        if (dimensionPositions.length > 0) {
-            s += `GROUP BY ${dimensionPositions.join(',')}\n`;
-        }
+        s += sqlGroupBy(this.parent.dialect, f.columns);
         this.resultStage = stageWriter.addStage(s);
         if (needsRemapStage) {
             const cols = f.columns.slice(1).map(c => c.name);
@@ -1574,6 +1596,9 @@ class QueryQuery extends query_node_1.QueryField {
         return this.resultStage;
     }
     genereateSQLCombineTurtles(stageWriter, stage0Name) {
+        const limit = !(0, malloy_types_1.isRawSegment)(this.firstSegment) && this.firstSegment.limit
+            ? this.firstSegment.limit
+            : undefined;
         let s = 'SELECT\n';
         // Columns this combine stage emits. Unlike the grouped stages above, these
         // are the final output names (unsuffixed), not the group-set-suffixed form.
@@ -1585,15 +1610,13 @@ class QueryQuery extends query_node_1.QueryField {
             if (fi instanceof field_instance_1.FieldInstanceField) {
                 if (fi.fieldUsage.type === 'result') {
                     if ((0, query_node_1.isScalarField)(fi.f)) {
-                        columns.push({
-                            sql: this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`) + ` as ${sqlName}`,
-                            name: sqlName,
-                            isDimension: true,
-                        });
+                        columns.push(aliasedColumn(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), sqlName, { isDimension: true }));
                     }
                     else if ((0, query_node_1.isBasicCalculation)(fi.f)) {
+                        const lastTurtle = this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName);
                         columns.push({
-                            sql: this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName),
+                            sql: lastTurtle,
+                            expr: lastTurtle,
                             name: sqlName,
                             isDimension: false,
                         });
@@ -1602,15 +1625,13 @@ class QueryQuery extends query_node_1.QueryField {
             }
             else if (fi instanceof field_instance_1.FieldInstanceResult) {
                 if (fi.firstSegment.type === 'reduce') {
-                    columns.push({
-                        sql: `${this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL)} as ${sqlName}`,
-                        name: sqlName,
-                        isDimension: false,
-                    });
+                    columns.push(aliasedColumn(this.generateTurtleSQL(fi, stageWriter, sqlName, outputPipelinedSQL), sqlName, { isDimension: false }));
                 }
                 else if (fi.firstSegment.type === 'project') {
+                    const lastTurtle = this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName);
                     columns.push({
-                        sql: this.parent.dialect.sqlAnyValueLastTurtle(this.parent.dialect.sqlQuoteIdentifier(`${name}__${this.rootResult.groupSet}`), this.rootResult.groupSet, sqlName),
+                        sql: lastTurtle,
+                        expr: lastTurtle,
                         name: sqlName,
                         isDimension: false,
                     });
@@ -1622,19 +1643,12 @@ class QueryQuery extends query_node_1.QueryField {
         if (where.length > 0) {
             s += `WHERE ${where}\n`;
         }
-        const dimensionPositions = groupByPositions(columns);
-        if (dimensionPositions.length > 0) {
-            s += `GROUP BY ${dimensionPositions.join(',')}\n`;
-        }
-        // order by
-        const orderBySQL = this.genereateSQLOrderBy(this.firstSegment, this.rootResult);
-        s += orderBySQL;
-        // limit
-        if (!(0, malloy_types_1.isRawSegment)(this.firstSegment) && this.firstSegment.limit) {
-            s += `LIMIT ${this.firstSegment.limit}\n`;
-        }
+        s += sqlGroupBy(this.parent.dialect, columns);
+        // order by, limit
+        const orderTerms = this.genereateSQLOrderBy(this.firstSegment, this.rootResult);
+        s += this.parent.dialect.sqlOrderByLimit(orderTerms, limit);
         this.resultStage = stageWriter.addStage(s);
-        this.resultStage = this.generatePipelinedStages(outputPipelinedSQL, this.resultStage, stageWriter, columns, orderBySQL);
+        this.resultStage = this.generatePipelinedStages(outputPipelinedSQL, this.resultStage, stageWriter, columns, this.parent.dialect.sqlOrderByLimit(orderTerms, undefined));
         return this.resultStage;
     }
     // create a simplified version of the StructDef for dialects.
@@ -1947,30 +1961,37 @@ class QueryQueryIndexStage extends QueryQuery {
                 fields.push({ name, path, type: fi.f.fieldDef.type, expression });
             }
         }
-        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},\n`;
-        s += '  CASE group_set\n';
-        for (let i = 0; i < fields.length; i++) {
-            const path = pathToCol(fields[i].path);
-            s += `    WHEN ${i} THEN '${path}'\n`;
-        }
-        s += `  END as ${fieldPathColumn},\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 ${dialect.castToString('NULL')}\n`;
-        for (let i = 0; i < fields.length; i++) {
-            if (fields[i].type === 'string') {
-                s += `    WHEN ${i} THEN ${fields[i].expression}\n`;
+        // The grouped columns: group_set and one CASE per index column.
+        const caseOnGroupSet = (when, firstWhen) => {
+            let c = 'CASE group_set\n';
+            if (firstWhen !== undefined) {
+                c += `    ${firstWhen}\n`;
             }
-        }
-        s += `  END as ${fieldValueColumn},\n`;
+            for (let i = 0; i < fields.length; i++) {
+                const value = when(i);
+                if (value !== undefined) {
+                    c += `    WHEN ${i} THEN ${value}\n`;
+                }
+            }
+            return c + '  END';
+        };
+        const grouped = [
+            {
+                sql: 'group_set',
+                expr: 'group_set',
+                name: 'group_set',
+                isDimension: true,
+            },
+            aliasedColumn(caseOnGroupSet(i => `'${fields[i].name}'`), fieldNameColumn, { isDimension: true }),
+            aliasedColumn(caseOnGroupSet(i => `'${pathToCol(fields[i].path)}'`), fieldPathColumn, { isDimension: true }),
+            aliasedColumn(caseOnGroupSet(i => `'${fields[i].type}'`), fieldTypeColumn, { isDimension: true }),
+            aliasedColumn(caseOnGroupSet(i => (fields[i].type === 'string' ? fields[i].expression : undefined), `WHEN 99999 THEN ${dialect.castToString('NULL')}`), fieldValueColumn, { isDimension: true }),
+        ];
+        const limit = !(0, malloy_types_1.isRawSegment)(this.firstSegment) && this.firstSegment.limit
+            ? this.firstSegment.limit
+            : undefined;
+        let s = 'SELECT\n';
+        s += grouped.map(c => `  ${c.sql},\n`).join('');
         s += ` ${measureSQL} as ${weightColumn},\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 ''";
@@ -1993,11 +2014,8 @@ class QueryQueryIndexStage extends QueryQuery {
         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,5\n';
-        // limit
-        if (!(0, malloy_types_1.isRawSegment)(this.firstSegment) && this.firstSegment.limit) {
-            s += `LIMIT ${this.firstSegment.limit}\n`;
-        }
+        s += sqlGroupBy(dialect, grouped);
+        s += dialect.sqlOrderByLimit([], limit);
         // console.log(s);
         const resultStage = stageWriter.addStage(s);
         this.resultStage = stageWriter.addStage(`SELECT

package/dist/model/source_def_utils.d.ts

@@ -7,7 +7,13 @@
  * fields they need, never using spread, so identity is not propagated onto a
  * freshly built source.
  */
-import type { BuildID, FieldDef, GivenID, ModelDef, PersistableSourceDef, Query, QuerySourceDef, SourceDef, SourceID, SourceRegistryEntry, SourceRegistryValue, SQLPhraseSegment, SQLSourceDef, TableSourceDef } from './malloy_types';
+import type { BuildID, FieldDef, GivenID, ModelDef, NamedModelObject, PersistableSourceDef, Query, QuerySourceDef, SourceDef, SourceID, SourceRegistryEntry, SourceRegistryValue, SQLPhraseSegment, SQLSourceDef, TableSourceDef } from './malloy_types';
+/**
+ * The dialect an entry commits whoever imports it to, if any. A query begins
+ * at a source, which is either inline in the query or named in the model the
+ * query came from.
+ */
+export declare function dialectOfEntry(entry: NamedModelObject, from: ModelDef): string | undefined;
 export declare function mkSourceID(name: string, url: string | undefined): SourceID;
 export declare function mkGivenID(name: string, url: string | undefined): GivenID;
 /**

package/dist/model/source_def_utils.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: MIT
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialectOfEntry = dialectOfEntry;
 exports.mkSourceID = mkSourceID;
 exports.mkGivenID = mkGivenID;
 exports.mkBuildID = mkBuildID;
@@ -17,6 +18,25 @@ exports.registerSource = registerSource;
 exports.hasSourceRegistryEntry = hasSourceRegistryEntry;
 const utils_1 = require("./utils");
 const malloy_types_1 = require("./malloy_types");
+/**
+ * The dialect an entry commits whoever imports it to, if any. A query begins
+ * at a source, which is either inline in the query or named in the model the
+ * query came from.
+ */
+function dialectOfEntry(entry, from) {
+    if ((0, malloy_types_1.isSourceDef)(entry)) {
+        return entry.dialect;
+    }
+    if (entry.type === 'query') {
+        const head = entry.structRef;
+        if (typeof head === 'string') {
+            const named = (0, malloy_types_1.safeRecordGet)(from.contents, head);
+            return named && (0, malloy_types_1.isSourceDef)(named) ? named.dialect : undefined;
+        }
+        return head.dialect;
+    }
+    return undefined;
+}
 function mkSourceID(name, url) {
     return `${name}@${url !== null && url !== void 0 ? url : 'unknown'}`;
 }

package/dist/test/index.js

@@ -113,14 +113,20 @@ function databasesFromEnvironmentOr(defaultDatabases) {
             : defaultDatabases;
 }
 /**
- * A replacement for [describe()] that mimics [describe.skip()]
+ * A replacement for [describe()] that mimics [describe.skip()].
+ *
+ * Built on demand, not at module scope: this module is also imported outside
+ * jest (scripts that construct a test connection), where the jest globals do
+ * not exist.
  */
-const describeSkip = Object.assign((name, fn) => describe.skip(name, fn), {
-    skip: describe.skip,
-    // eslint-disable-next-line no-restricted-properties
-    only: describe.only,
-    each: (() => () => it.skip('skipped', () => { })),
-});
+function makeDescribeSkip() {
+    return Object.assign((name, fn) => describe.skip(name, fn), {
+        skip: describe.skip,
+        // eslint-disable-next-line no-restricted-properties
+        only: describe.only,
+        each: (() => () => it.skip('skipped', () => { })),
+    });
+}
 /**
  * Confirms that one or more of the databases being tested overlaps with
  * the databases a test suite can accept. If there is overlap, return a tuple
@@ -130,7 +136,9 @@ const describeSkip = Object.assign((name, fn) => describe.skip(name, fn), {
 function describeIfDatabaseAvailable(acceptableDatabases) {
     const currentDatabases = databasesFromEnvironmentOr(acceptableDatabases);
     const overlap = acceptableDatabases.filter(d => currentDatabases.includes(d));
-    return overlap.length > 0 ? [describe, overlap] : [describeSkip, overlap];
+    return overlap.length > 0
+        ? [describe, overlap]
+        : [makeDescribeSkip(), overlap];
 }
 function brokenIn(dialectName, connectionName) {
     return dialectName === connectionName;

package/dist/test/matchers.d.ts

@@ -1,7 +1,7 @@
 /**
  * Import this module to register Jest matchers (toMatchResult, toEqualResult).
  *
- * Usage in jest.config.js:
+ * Usage in jest.config.ts:
  *   setupFilesAfterEnv: ['@malloydata/malloy/test/matchers']
  *
  * Or import directly in a test file:

package/dist/test/matchers.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Import this module to register Jest matchers (toMatchResult, toEqualResult).
  *
- * Usage in jest.config.js:
+ * Usage in jest.config.ts:
  *   setupFilesAfterEnv: ['@malloydata/malloy/test/matchers']
  *
  * Or import directly in a test file:

package/dist/test/test-models.js

@@ -229,19 +229,12 @@ function generateSQL(dialect, rows) {
         .join(', ');
     const innerQuery = selects.join('\nUNION ALL ');
     // Generate ORDER BY based on dialect preference
-    let orderByClause;
-    if (dialect.orderByClause === 'ordinal') {
-        orderByClause = `ORDER BY ${columnList.length + 1}`;
-    }
-    else if (dialect.orderByClause === 'output_name') {
-        orderByClause = `ORDER BY ${rowIdColumn}`;
-    }
-    else {
-        orderByClause = `ORDER BY ${rowIdColumn}`;
-    }
-    // Presto/Trino ignores ORDER BY on a subquery without LIMIT
-    orderByClause += ` LIMIT ${rows.length}`;
-    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}\n) AS t_result\n`;
+    const orderTerm = dialect.orderByClause === 'ordinal'
+        ? `${columnList.length + 1}`
+        : rowIdColumn;
+    // Presto/Trino ignores ORDER BY on a subquery without a row limit
+    const orderByClause = dialect.sqlOrderByLimit([orderTerm], rows.length);
+    const sql = `SELECT ${quotedColumns}\nFROM (\n  SELECT *\n  FROM (\n${innerQuery}\n  ) AS t_sorted\n  ${orderByClause}) AS t_result\n`;
     return sql;
 }
 /**

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.434";
+export declare const MALLOY_VERSION = "0.0.435";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.434';
+exports.MALLOY_VERSION = '0.0.435';
 //# sourceMappingURL=version.js.map