@malloydata/malloy 0.0.218-dev241122201503 → 0.0.218-dev241127170002

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,4 @@
-import { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, LeafAtomicTypeDef } from '../model/malloy_types';
+import { Expr, Sampling, AtomicTypeDef, MeasureTimeExpr, TimeTruncExpr, TimeExtractExpr, TimeDeltaExpr, TypecastExpr, RegexMatchExpr, TimeLiteralNode, RecordLiteralNode, ArrayLiteralNode, LeafAtomicTypeDef, OrderBy } from '../model/malloy_types';
 import { DialectFunctionOverloadDef } from './functions';
 type DialectFieldTypes = string | 'struct';
 interface DialectField {
@@ -80,7 +80,7 @@ export declare abstract class Dialect {
     abstract sqlFieldReference(alias: string, fieldName: string, fieldType: string, isNested: boolean, isArray: boolean): string;
     abstract sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string, fieldList?: DialectFieldList): string;
     abstract sqlCreateFunction(id: string, funcText: string): string;
-    abstract sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList): string;
+    abstract sqlCreateFunctionCombineLastStage(lastStageName: string, fieldList: DialectFieldList, orderBy: OrderBy[] | undefined): string;
     abstract sqlCreateTableAsSelect(tableName: string, sql: string): string;
     abstract sqlSelectAliasAsStruct(alias: string, fieldList: DialectFieldList): string;
     sqlFinalStage(_lastStageName: string, _fields: string[]): string;

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,4 +1,4 @@
-import { Sampling, AtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr, LeafAtomicTypeDef } from '../../model/malloy_types';
+import { Sampling, AtomicTypeDef, TimeDeltaExpr, RegexMatchExpr, MeasureTimeExpr, LeafAtomicTypeDef, OrderBy } from '../../model/malloy_types';
 import { DialectFunctionOverloadDef } from '../functions';
 import { DialectFieldList } from '../dialect';
 import { PostgresBase } from '../pg_impl';
@@ -39,7 +39,7 @@ export declare class DuckDBDialect extends PostgresBase {
     sqlFieldReference(alias: string, fieldName: string, _fieldType: string, _isNested: boolean, isArray: boolean): string;
     sqlUnnestPipelineHead(isSingleton: boolean, sourceSQLExpression: string): string;
     sqlCreateFunction(id: string, funcText: string): string;
-    sqlCreateFunctionCombineLastStage(lastStageName: string, dialectFieldList: DialectFieldList): string;
+    sqlCreateFunctionCombineLastStage(lastStageName: string, dialectFieldList: DialectFieldList, orderBy: OrderBy[] | undefined): string;
     sqlSelectAliasAsStruct(alias: string, dialectFieldList: DialectFieldList): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;

package/dist/dialect/duckdb/duckdb.js

@@ -185,10 +185,25 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     sqlCreateFunction(id, funcText) {
         return `DROP MACRO IF EXISTS ${id}; \n${hackSplitComment}\n CREATE MACRO ${id}(_param) AS (\n${(0, utils_1.indent)(funcText)}\n);\n${hackSplitComment}\n`;
     }
-    sqlCreateFunctionCombineLastStage(lastStageName, dialectFieldList) {
+    sqlCreateFunctionCombineLastStage(lastStageName, dialectFieldList, orderBy) {
+        let o = '';
+        if (orderBy) {
+            const clauses = [];
+            for (const c of orderBy) {
+                if (typeof c.field === 'string') {
+                    clauses.push(`${c.field} ${c.dir || 'asc'}`);
+                }
+                else {
+                    clauses.push(`${dialectFieldList[c.field].sqlOutputName} ${c.dir || 'asc'}`);
+                }
+            }
+            if (clauses.length > 0) {
+                o = ` ORDER BY ${clauses.join(', ')}`;
+            }
+        }
         return `SELECT LIST(STRUCT_PACK(${dialectFieldList
             .map(d => this.sqlMaybeQuoteIdentifier(d.sqlOutputName))
-            .join(',')})) FROM ${lastStageName}\n`;
+            .join(',')})${o}) FROM ${lastStageName}\n`;
     }
     sqlSelectAliasAsStruct(alias, dialectFieldList) {
         return `STRUCT_PACK(${dialectFieldList

package/dist/lang/ast/index.d.ts

@@ -91,7 +91,6 @@ export * from './query-properties/ordering';
 export * from './query-properties/project-statement';
 export * from './query-properties/qop-desc';
 export * from './query-properties/sampling';
-export * from './query-properties/top';
 export * from './source-elements/named-source';
 export * from './source-elements/query-source';
 export * from './source-elements/sql-source';

package/dist/lang/ast/index.js

@@ -129,7 +129,6 @@ __exportStar(require("./query-properties/ordering"), exports);
 __exportStar(require("./query-properties/project-statement"), exports);
 __exportStar(require("./query-properties/qop-desc"), exports);
 __exportStar(require("./query-properties/sampling"), exports);
-__exportStar(require("./query-properties/top"), exports);
 __exportStar(require("./source-elements/named-source"), exports);
 __exportStar(require("./source-elements/query-source"), exports);
 __exportStar(require("./source-elements/sql-source"), exports);

package/dist/lang/ast/query-builders/reduce-builder.d.ts

@@ -1,14 +1,13 @@
 import { CompositeFieldUsage, FilterCondition, PipeSegment, QuerySegment } from '../../../model/malloy_types';
 import { SourceFieldSpace } from '../types/field-space';
 import { Ordering } from '../query-properties/ordering';
-import { Top } from '../query-properties/top';
 import { QueryProperty } from '../types/query-property';
 import { QueryBuilder } from '../types/query-builder';
 import { QueryOperationSpace, ReduceFieldSpace } from '../field-space/query-spaces';
 import { QueryInputSpace } from '../field-space/query-input-space';
 import { MalloyElement } from '../types/malloy-element';
 export declare abstract class QuerySegmentBuilder implements QueryBuilder {
-    order?: Top | Ordering;
+    order?: Ordering;
     limit?: number;
     alwaysJoins: string[];
     abstract inputFS: QueryInputSpace;

package/dist/lang/ast/query-builders/reduce-builder.js

@@ -25,12 +25,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReduceBuilder = exports.QuerySegmentBuilder = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const error_factory_1 = require("../error-factory");
+const field_space_1 = require("../types/field-space");
 const limit_1 = require("../query-properties/limit");
 const ordering_1 = require("../query-properties/ordering");
-const top_1 = require("../query-properties/top");
 const query_spaces_1 = require("../field-space/query-spaces");
 const definition_list_1 = require("../types/definition-list");
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
+function queryFieldName(qf) {
+    if (qf.type === 'fieldref') {
+        return qf.path[qf.path.length - 1];
+    }
+    return qf.name;
+}
 class QuerySegmentBuilder {
     constructor() {
         this.alwaysJoins = [];
@@ -44,22 +50,6 @@ class QuerySegmentBuilder {
         if (qp instanceof definition_list_1.DefinitionList) {
             this.resultFS.pushFields(...qp.list);
         }
-        else if (qp instanceof top_1.Top) {
-            if (this.limit) {
-                qp.logError('limit-already-specified', 'Query operation already limited');
-            }
-            else {
-                this.limit = qp.limit;
-            }
-            if (qp.by) {
-                if (this.order) {
-                    qp.logError('ordering-already-specified', 'Query operation is already sorted');
-                }
-                else {
-                    this.order = qp;
-                }
-            }
-        }
         else if (qp instanceof limit_1.Limit) {
             if (this.limit) {
                 qp.logError('limit-already-specified', 'Query operation already limited');
@@ -83,30 +73,20 @@ class QuerySegmentBuilder {
     refineFrom(from, to) {
         var _a;
         if (from && from.type !== 'index' && from.type !== 'raw') {
-            if (!this.order) {
-                if (from.orderBy) {
-                    to.orderBy = from.orderBy;
-                }
-                else if (from.by) {
-                    to.by = from.by;
-                }
+            if (!this.limit && from.orderBy && !from.defaultOrderBy) {
+                to.orderBy = from.orderBy;
             }
             if (!this.limit && from.limit) {
                 to.limit = from.limit;
             }
         }
+        if (this.order) {
+            to.orderBy = this.order.getOrderBy(this.inputFS);
+            delete to.defaultOrderBy;
+        }
         if (this.limit) {
             to.limit = this.limit;
         }
-        if (this.order instanceof top_1.Top) {
-            const topBy = this.order.getBy(this.inputFS);
-            if (topBy) {
-                to.by = topBy;
-            }
-        }
-        if (this.order instanceof ordering_1.Ordering) {
-            to.orderBy = this.order.getOrderBy(this.inputFS);
-        }
         const oldFilters = (from === null || from === void 0 ? void 0 : from.filterList) || [];
         if (this.filters.length > 0 && !oldFilters) {
             to.filterList = this.filters;
@@ -144,6 +124,60 @@ class ReduceBuilder extends QuerySegmentBuilder {
         }
         const reduceSegment = this.resultFS.getQuerySegment(from);
         this.refineFrom(from, reduceSegment);
+        if (reduceSegment.orderBy) {
+            // In the modern world, we will ONLY allow names and not numbers in order by lists
+            for (const by of reduceSegment.orderBy) {
+                if (typeof by.field === 'number') {
+                    const by_field = reduceSegment.queryFields[by.field - 1];
+                    by.field = queryFieldName(by_field);
+                }
+            }
+        }
+        if (reduceSegment.orderBy === undefined || reduceSegment.defaultOrderBy) {
+            // In the modern world, we will order all reduce segments with the default ordering
+            let usableDefaultOrderField;
+            for (const field of reduceSegment.queryFields) {
+                let fieldAggregate = false;
+                let fieldAnalytic = false;
+                let fieldType;
+                const fieldName = queryFieldName(field);
+                if (field.type === 'fieldref') {
+                    const lookupPath = field.path.map(el => new field_space_1.FieldName(el));
+                    const refField = this.inputFS.lookup(lookupPath).found;
+                    if (refField) {
+                        const typeDesc = refField.typeDesc();
+                        fieldType = typeDesc.type;
+                        fieldAggregate = (0, malloy_types_1.expressionIsAggregate)(typeDesc.expressionType);
+                        fieldAnalytic = (0, malloy_types_1.expressionIsAnalytic)(typeDesc.expressionType);
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                else {
+                    fieldType = field.type;
+                    fieldAggregate =
+                        (0, malloy_types_1.hasExpression)(field) && (0, malloy_types_1.expressionIsAggregate)(field.expressionType);
+                    fieldAnalytic =
+                        (0, malloy_types_1.hasExpression)(field) && (0, malloy_types_1.expressionIsAnalytic)(field.expressionType);
+                }
+                if ((0, malloy_types_1.isTemporalField)(fieldType) || fieldAggregate) {
+                    reduceSegment.defaultOrderBy = true;
+                    reduceSegment.orderBy = [{ field: fieldName, dir: 'desc' }];
+                    usableDefaultOrderField = undefined;
+                    break;
+                }
+                if ((0, malloy_types_1.canOrderBy)(fieldType) &&
+                    !fieldAnalytic &&
+                    !usableDefaultOrderField) {
+                    usableDefaultOrderField = fieldName;
+                }
+            }
+            if (usableDefaultOrderField) {
+                reduceSegment.defaultOrderBy = true;
+                reduceSegment.orderBy = [{ field: usableDefaultOrderField, dir: 'asc' }];
+            }
+        }
         return reduceSegment;
     }
 }

package/dist/lang/ast/view-elements/refine-utils.js

@@ -48,14 +48,9 @@ function refine(logTo, refineTo, refineFrom) {
             logTo.logError('mismatched-view-types-for-refinement', `cannot refine ${to.type} view with ${from.type} view`);
         }
         if (from.type !== 'index' && to.type !== 'index' && from.type !== 'raw') {
-            if (from.orderBy !== undefined || from.by !== undefined) {
-                if (to.orderBy === undefined && to.by === undefined) {
-                    if (from.orderBy) {
-                        to.orderBy = from.orderBy;
-                    }
-                    else if (from.by) {
-                        to.by = from.by;
-                    }
+            if (from.orderBy !== undefined && !from.defaultOrderBy) {
+                if (to.orderBy === undefined || to.defaultOrderBy) {
+                    to.orderBy = from.orderBy;
                 }
                 else {
                     logTo.logError('ordering-overridden-in-refinement', 'refinement cannot override existing ordering');

package/dist/lang/lib/Malloy/MalloyParser.d.ts

@@ -1712,7 +1712,6 @@ export declare class BySpecContext extends ParserRuleContext {
 export declare class TopStatementContext extends ParserRuleContext {
     TOP(): TerminalNode;
     INTEGER_LITERAL(): TerminalNode;
-    bySpec(): BySpecContext | undefined;
     constructor(parent: ParserRuleContext | undefined, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: MalloyParserListener): void;