@malloydata/malloy 0.0.120-dev240131220408 → 0.0.120

package/dist/dialect/dialect_map.js

@@ -83,14 +83,24 @@ function getDialectFunction(name) {
                     if (!returnEqual(overload, existingOverload)) {
                         throw new Error('params match but return types differ!');
                     }
-                    existingOverload.dialect[dialect.name] = overload.e;
+                    existingOverload.dialect[dialect.name] = {
+                        e: overload.e,
+                        supportsOrderBy: overload.supportsOrderBy,
+                        supportsLimit: overload.supportsLimit,
+                    };
                     handled = true;
                 }
                 if (!handled) {
                     func.overloads.push({
                         returnType: overload.returnType,
                         params: overload.params,
-                        dialect: { [dialect.name]: overload.e },
+                        dialect: {
+                            [dialect.name]: {
+                                e: overload.e,
+                                supportsOrderBy: overload.supportsOrderBy,
+                                supportsLimit: overload.supportsLimit,
+                            },
+                        },
                         needsWindowOrderBy: overload.needsWindowOrderBy,
                         between: overload.between,
                         isSymmetric: overload.isSymmetric,

package/dist/dialect/functions/all_functions.js

@@ -60,6 +60,7 @@ const simple_numeric_functions_1 = require("./simple_numeric_functions");
 const avg_moving_1 = require("./avg_moving");
 const function_map_1 = require("./function_map");
 const coalesce_1 = require("./coalesce");
+const string_agg_1 = require("./string_agg");
 const sql_1 = require("./sql");
 /**
  * This is a function map containing default implementations of all Malloy
@@ -118,6 +119,8 @@ exports.FUNCTIONS.add('ln', simple_numeric_functions_1.fnLn);
 exports.FUNCTIONS.add('exp', simple_numeric_functions_1.fnExp);
 // Aggregate functions
 exports.FUNCTIONS.add('stddev', stddev_1.fnStddev);
+exports.FUNCTIONS.add('string_agg', string_agg_1.fnStringAgg);
+exports.FUNCTIONS.add('string_agg_distinct', string_agg_1.fnStringAggDistinct);
 // Analytic functions
 exports.FUNCTIONS.add('row_number', row_number_1.fnRowNumber);
 exports.FUNCTIONS.add('lag', lag_1.fnLag);

package/dist/dialect/functions/string_agg.d.ts

@@ -0,0 +1,3 @@
+import { DialectFunctionOverloadDef } from './util';
+export declare function fnStringAgg(): DialectFunctionOverloadDef[];
+export declare function fnStringAggDistinct(): DialectFunctionOverloadDef[];

package/dist/dialect/functions/string_agg.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnStringAggDistinct = exports.fnStringAgg = void 0;
+const util_1 = require("./util");
+function fnStringAgg() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
+    const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
+    const orderBy = { type: 'aggregate_order_by' };
+    return [
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy})`, { supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`, { supportsOrderBy: true }),
+    ];
+}
+exports.fnStringAgg = fnStringAgg;
+function fnStringAggDistinct() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
+    const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
+    const orderBy = { type: 'aggregate_order_by' };
+    return [
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
+    ];
+}
+exports.fnStringAggDistinct = fnStringAggDistinct;
+//# sourceMappingURL=string_agg.js.map

package/dist/dialect/functions/util.d.ts

@@ -5,6 +5,8 @@ export interface DialectFunctionOverloadDef {
     e: Expr;
     needsWindowOrderBy?: boolean;
     isSymmetric?: boolean;
+    supportsOrderBy?: boolean;
+    supportsLimit?: boolean;
     between: {
         preceding: number | string;
         following: number | string;
@@ -43,4 +45,7 @@ export declare function overload(returnType: TypeDesc, params: FunctionParameter
         preceding: number | string;
         following: number | string;
     };
+    isSymmetric?: boolean;
+    supportsLimit?: boolean;
+    supportsOrderBy?: boolean;
 }): DialectFunctionOverloadDef;

package/dist/dialect/functions/util.js

@@ -181,6 +181,9 @@ function overload(returnType, params, e, options) {
         e,
         needsWindowOrderBy: options === null || options === void 0 ? void 0 : options.needsWindowOrderBy,
         between: options === null || options === void 0 ? void 0 : options.between,
+        isSymmetric: options === null || options === void 0 ? void 0 : options.isSymmetric,
+        supportsOrderBy: options === null || options === void 0 ? void 0 : options.supportsOrderBy,
+        supportsLimit: options === null || options === void 0 ? void 0 : options.supportsLimit,
     };
 }
 exports.overload = overload;

package/dist/dialect/postgres/functions/postgres_functions.js

@@ -24,6 +24,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.POSTGRES_FUNCTIONS = void 0;
 const functions_1 = require("../../functions");
+const string_agg_1 = require("./string_agg");
 const byte_length_1 = require("./byte_length");
 const ends_with_1 = require("./ends_with");
 const greatest_and_least_1 = require("./greatest_and_least");
@@ -55,6 +56,8 @@ exports.POSTGRES_FUNCTIONS.add('trunc', trunc_1.fnTrunc);
 exports.POSTGRES_FUNCTIONS.add('substr', substr_1.fnSubstr);
 exports.POSTGRES_FUNCTIONS.add('replace', replace_1.fnReplace);
 exports.POSTGRES_FUNCTIONS.add('ends_with', ends_with_1.fnEndsWith);
+exports.POSTGRES_FUNCTIONS.add('string_agg', string_agg_1.fnStringAgg);
+exports.POSTGRES_FUNCTIONS.add('string_agg_distinct', string_agg_1.fnStringAggDistinct);
 exports.POSTGRES_FUNCTIONS.add('log', log_1.fnLog);
 exports.POSTGRES_FUNCTIONS.seal();
 //# sourceMappingURL=postgres_functions.js.map

package/dist/dialect/postgres/functions/string_agg.d.ts

@@ -0,0 +1,3 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnStringAgg(): DialectFunctionOverloadDef[];
+export declare function fnStringAggDistinct(): DialectFunctionOverloadDef[];

package/dist/dialect/postgres/functions/string_agg.js

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnStringAggDistinct = exports.fnStringAgg = void 0;
+const util_1 = require("../../functions/util");
+function fnStringAgg() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
+    const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
+    const orderBy = { type: 'aggregate_order_by' };
+    return [
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ','${orderBy})`, { supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`, { supportsOrderBy: true }),
+    ];
+}
+exports.fnStringAgg = fnStringAgg;
+function fnStringAggDistinct() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
+    const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
+    const orderBy = { type: 'aggregate_order_by' };
+    return [
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ','${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`, { isSymmetric: true, supportsOrderBy: true }),
+    ];
+}
+exports.fnStringAggDistinct = fnStringAggDistinct;
+//# sourceMappingURL=string_agg.js.map

package/dist/dialect/standardsql/functions/standardsql_functions.js

@@ -24,10 +24,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STANDARDSQL_FUNCTIONS = void 0;
 const functions_1 = require("../../functions");
+const string_agg_1 = require("./string_agg");
 const chr_1 = require("./chr");
 const pi_1 = require("./pi");
 exports.STANDARDSQL_FUNCTIONS = functions_1.FUNCTIONS.clone();
 exports.STANDARDSQL_FUNCTIONS.add('pi', pi_1.fnPi);
 exports.STANDARDSQL_FUNCTIONS.add('chr', chr_1.fnChr);
+exports.STANDARDSQL_FUNCTIONS.add('string_agg', string_agg_1.fnStringAgg);
+exports.STANDARDSQL_FUNCTIONS.add('string_agg_distinct', string_agg_1.fnStringAggDistinct);
 exports.STANDARDSQL_FUNCTIONS.seal();
 //# sourceMappingURL=standardsql_functions.js.map

package/dist/dialect/standardsql/functions/string_agg.d.ts

@@ -0,0 +1,3 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnStringAgg(): DialectFunctionOverloadDef[];
+export declare function fnStringAggDistinct(): DialectFunctionOverloadDef[];

package/dist/dialect/standardsql/functions/string_agg.js

@@ -0,0 +1,49 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnStringAggDistinct = exports.fnStringAgg = void 0;
+const util_1 = require("../../functions/util");
+function fnStringAgg() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
+    const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
+    const orderBy = { type: 'aggregate_order_by' };
+    const limit = { type: 'aggregate_limit' };
+    return [
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(${value.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(${value.arg}, ${separator.arg}${orderBy}${limit})`, { supportsOrderBy: true, supportsLimit: true }),
+    ];
+}
+exports.fnStringAgg = fnStringAgg;
+function fnStringAggDistinct() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.maxScalar)('string'));
+    const separator = (0, util_1.makeParam)('separator', (0, util_1.literal)((0, util_1.maxScalar)('string')));
+    const orderBy = { type: 'aggregate_order_by' };
+    const limit = { type: 'aggregate_limit' };
+    return [
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}${orderBy}${limit})`, { isSymmetric: true, supportsOrderBy: true, supportsLimit: true }),
+        (0, util_1.overload)((0, util_1.minAggregate)('string'), [value.param, separator.param], (0, util_1.sql) `STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy}${limit})`, { isSymmetric: true, supportsOrderBy: true, supportsLimit: true }),
+    ];
+}
+exports.fnStringAggDistinct = fnStringAggDistinct;
+//# sourceMappingURL=string_agg.js.map

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { HighlightType, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
 export { Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, } from './malloy';
 export type { Model, PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentSymbol, DocumentHighlight, ResultJSON, PreparedResultMaterializer, SQLBlockMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, } from './malloy';
-export type { RunSQLOptions } from './run_sql_options';
-export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, InfoConnection, LookupConnection, ModelString, ModelURL, FetchSchemaOptions, PersistSQLResults, PooledConnection, QueryString, QueryURL, TestableConnection, StreamingConnection, URLReader, } from './runtime_types';
+export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
+export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, ModelString, ModelURL, PersistSQLResults, PooledConnection, QueryString, QueryURL, TestableConnection, StreamingConnection, URLReader, } from './runtime_types';
 export { toAsyncGenerator } from './connection_utils';
 export { type TagParse, Tag, type TagDict } from './tags';

package/dist/lang/ast/expressions/expr-func.d.ts

@@ -1,5 +1,8 @@
 import { FieldValueType } from '../../../model/malloy_types';
 import { FieldReference } from '../query-items/field-references';
+import { FunctionOrdering } from './function-ordering';
+import { Limit } from '../query-properties/limit';
+import { PartitionBy } from './partition_by';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import { FieldSpace } from '../types/field-space';
@@ -11,5 +14,13 @@ export declare class ExprFunc extends ExpressionDef {
     readonly source?: FieldReference | undefined;
     elementType: string;
     constructor(name: string, args: ExpressionDef[], isRaw: boolean, rawType: FieldValueType | undefined, source?: FieldReference | undefined);
+    canSupportPartitionBy(): boolean;
+    canSupportOrderBy(): boolean;
+    canSupportLimit(): boolean;
     getExpression(fs: FieldSpace): ExprValue;
+    getPropsExpression(fs: FieldSpace, props?: {
+        partitionBys?: PartitionBy[];
+        orderBys?: FunctionOrdering[];
+        limit?: Limit;
+    }): ExprValue;
 }

package/dist/lang/ast/expressions/expr-func.js

@@ -39,8 +39,20 @@ class ExprFunc extends expression_def_1.ExpressionDef {
         this.elementType = 'function call()';
         this.has({ source: source });
     }
+    canSupportPartitionBy() {
+        return true;
+    }
+    canSupportOrderBy() {
+        return true;
+    }
+    canSupportLimit() {
+        return true;
+    }
     getExpression(fs) {
-        var _a, _b, _c, _d;
+        return this.getPropsExpression(fs);
+    }
+    getPropsExpression(fs, props) {
+        var _a, _b, _c, _d, _e;
         const argExprsWithoutImplicit = this.args.map(arg => arg.getExpression(fs));
         if (this.isRaw) {
             let expressionType = 'scalar';
@@ -161,15 +173,62 @@ class ExprFunc extends expression_def_1.ExpressionDef {
                 .join(', ')}) with source`);
             return (0, ast_utils_1.errorFor)('cannot call with source');
         }
-        let funcCall = [
-            {
-                type: 'function_call',
-                overload,
-                args: argExprs.map(x => x.value),
-                expressionType,
-                structPath,
-            },
-        ];
+        const frag = {
+            type: 'function_call',
+            overload,
+            args: argExprs.map(x => x.value),
+            expressionType,
+            structPath,
+        };
+        let funcCall = [frag];
+        const dialect = (_e = fs.dialectObj()) === null || _e === void 0 ? void 0 : _e.name;
+        const dialectOverload = dialect ? overload.dialect[dialect] : undefined;
+        // TODO add in an error if you use an asymmetric function in BQ
+        // and the function uses joins
+        // TODO add in an error if you use an illegal join pattern
+        if (dialectOverload === undefined) {
+            this.log(`Function ${this.name} is not defined in dialect ${dialect}`);
+        }
+        else {
+            if ((props === null || props === void 0 ? void 0 : props.orderBys) && props.orderBys.length > 0) {
+                const isAnalytic = (0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType);
+                if (dialectOverload.supportsOrderBy || isAnalytic) {
+                    const allObs = props.orderBys.flatMap(orderBy => isAnalytic
+                        ? orderBy.getAnalyticOrderBy(fs)
+                        : orderBy.getAggregateOrderBy(fs));
+                    frag.orderBy = allObs;
+                }
+                else {
+                    props.orderBys[0].log(`Function ${this.name} does not support order_by`);
+                }
+            }
+            if ((props === null || props === void 0 ? void 0 : props.limit) !== undefined) {
+                if (dialectOverload.supportsLimit) {
+                    frag.limit = props.limit.limit;
+                }
+                else {
+                    this.log(`Function ${this.name} does not support limit`);
+                }
+            }
+        }
+        if ((props === null || props === void 0 ? void 0 : props.partitionBys) && props.partitionBys.length > 0) {
+            const partitionByFields = [];
+            for (const partitionBy of props.partitionBys) {
+                for (const partitionField of partitionBy.partitionFields) {
+                    const e = partitionField.getField(fs);
+                    if (e.found === undefined) {
+                        partitionField.log(`${partitionField.refString} is not defined`);
+                    }
+                    else if ((0, malloy_types_1.expressionIsScalar)(e.found.typeDesc().expressionType)) {
+                        partitionByFields.push(partitionField.nameString);
+                    }
+                    else {
+                        partitionField.log('Partition expression must be scalar');
+                    }
+                }
+            }
+            frag.partitionBy = partitionByFields;
+        }
         if ([
             'sql_number',
             'sql_string',

package/dist/lang/ast/expressions/{expr-filter.d.ts → expr-props.d.ts}

@@ -1,12 +1,13 @@
-import { Filter } from '../query-properties/filters';
 import { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
+import { FieldPropStatement } from '../types/field-prop-statement';
 import { FieldSpace } from '../types/field-space';
-export declare class ExprFilter extends ExpressionDef {
+export declare class ExprProps extends ExpressionDef {
     readonly expr: ExpressionDef;
-    readonly filter: Filter;
+    readonly statements: FieldPropStatement[];
     elementType: string;
     legalChildTypes: import("../../../model/malloy_types").TypeDesc[];
-    constructor(expr: ExpressionDef, filter: Filter);
+    constructor(expr: ExpressionDef, statements: FieldPropStatement[]);
+    private getFilteredExpression;
     getExpression(fs: FieldSpace): ExprValue;
 }

package/dist/lang/ast/expressions/expr-props.js

@@ -0,0 +1,122 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExprProps = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const ast_utils_1 = require("../ast-utils");
+const fragtype_utils_1 = require("../fragtype-utils");
+const function_ordering_1 = require("./function-ordering");
+const limit_1 = require("../query-properties/limit");
+const partition_by_1 = require("./partition_by");
+const expression_def_1 = require("../types/expression-def");
+const expr_func_1 = require("./expr-func");
+class ExprProps extends expression_def_1.ExpressionDef {
+    constructor(expr, statements) {
+        super({ expr, statements });
+        this.expr = expr;
+        this.statements = statements;
+        this.elementType = 'expression with props';
+        this.legalChildTypes = fragtype_utils_1.FT.anyAtomicT;
+    }
+    getFilteredExpression(fs, expr, wheres) {
+        if (wheres.length > 0) {
+            if (!this.expr.supportsWhere(expr)) {
+                this.expr.log('Filtered expression requires an aggregate computation');
+                return expr;
+            }
+            const filterList = [];
+            for (const where of wheres) {
+                const testList = where.getFilterList(fs);
+                if (testList.find(cond => (0, malloy_types_1.expressionIsCalculation)(cond.expressionType))) {
+                    where.log('Cannot filter an expresion with an aggregate or analytical computation');
+                    return expr;
+                }
+                filterList.push(...testList);
+            }
+            if (this.typeCheck(this.expr, { ...expr, expressionType: 'scalar' })) {
+                return {
+                    ...expr,
+                    value: [
+                        {
+                            type: 'filterExpression',
+                            e: expr.value,
+                            filterList,
+                        },
+                    ],
+                };
+            }
+            this.expr.log(`Cannot filter '${expr.dataType}' data`);
+            return (0, ast_utils_1.errorFor)('cannot filter type');
+        }
+        return expr;
+    }
+    getExpression(fs) {
+        const partitionBys = [];
+        let limit;
+        const orderBys = [];
+        const wheres = [];
+        for (const statement of this.statements) {
+            if (statement instanceof partition_by_1.PartitionBy) {
+                if (!this.expr.canSupportPartitionBy()) {
+                    statement.log('`partition_by` is not supported for this kind of expression');
+                }
+                else {
+                    partitionBys.push(statement);
+                }
+            }
+            else if (statement instanceof limit_1.Limit) {
+                if (limit) {
+                    statement.log('limit already specified');
+                }
+                else if (!this.expr.canSupportLimit()) {
+                    statement.log('`limit` is not supported for this kind of expression');
+                }
+                else {
+                    limit = statement;
+                }
+            }
+            else if (statement instanceof function_ordering_1.FunctionOrdering) {
+                if (!this.expr.canSupportPartitionBy()) {
+                    statement.log('`order_by` is not supported for this kind of expression');
+                }
+                else {
+                    orderBys.push(statement);
+                }
+            }
+            else {
+                wheres.push(statement);
+            }
+        }
+        const resultExpr = this.expr instanceof expr_func_1.ExprFunc
+            ? this.expr.getPropsExpression(fs, {
+                partitionBys,
+                limit,
+                orderBys,
+            })
+            : this.expr.getExpression(fs);
+        return this.getFilteredExpression(fs, resultExpr, wheres);
+    }
+}
+exports.ExprProps = ExprProps;
+//# sourceMappingURL=expr-props.js.map

package/dist/lang/ast/expressions/function-ordering.d.ts

@@ -0,0 +1,18 @@
+import { FunctionOrderBy as ModelFunctionOrderBy } from '../../../model/malloy_types';
+import { ExpressionDef } from '../types/expression-def';
+import { FieldSpace } from '../types/field-space';
+import { ListOf, MalloyElement } from '../types/malloy-element';
+export declare class FunctionOrderBy extends MalloyElement {
+    readonly field: ExpressionDef;
+    readonly dir?: "asc" | "desc" | undefined;
+    elementType: string;
+    constructor(field: ExpressionDef, dir?: "asc" | "desc" | undefined);
+    getAnalyticOrderBy(fs: FieldSpace): ModelFunctionOrderBy;
+    getAggregateOrderBy(fs: FieldSpace): ModelFunctionOrderBy;
+}
+export declare class FunctionOrdering extends ListOf<FunctionOrderBy> {
+    elementType: string;
+    constructor(list: FunctionOrderBy[]);
+    getAnalyticOrderBy(fs: FieldSpace): ModelFunctionOrderBy[];
+    getAggregateOrderBy(fs: FieldSpace): ModelFunctionOrderBy[];
+}

package/dist/lang/ast/expressions/function-ordering.js

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionOrdering = exports.FunctionOrderBy = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const malloy_element_1 = require("../types/malloy-element");
+const expr_id_reference_1 = require("./expr-id-reference");
+class FunctionOrderBy extends malloy_element_1.MalloyElement {
+    constructor(field, dir) {
+        super();
+        this.field = field;
+        this.dir = dir;
+        this.elementType = 'orderBy';
+        this.has({ field });
+    }
+    getAnalyticOrderBy(fs) {
+        const expr = this.field.getExpression(fs);
+        if ((0, malloy_types_1.expressionIsAggregate)(expr.expressionType)) {
+            // Aggregates are okay
+        }
+        else if ((0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
+            if (!(this.field instanceof expr_id_reference_1.ExprIdReference) ||
+                expr.evalSpace === 'input') {
+                this.field.log('analytic `order_by` must be an aggregate or an output field reference');
+            }
+        }
+        else {
+            this.field.log('analytic `order_by` must be scalar or aggregate');
+        }
+        return { e: expr.value, dir: this.dir };
+    }
+    getAggregateOrderBy(fs) {
+        const expr = this.field.getExpression(fs);
+        if (!(0, malloy_types_1.expressionIsScalar)(expr.expressionType)) {
+            this.field.log('aggregate `order_by` must be scalar');
+        }
+        return { e: expr.value, dir: this.dir };
+    }
+}
+exports.FunctionOrderBy = FunctionOrderBy;
+class FunctionOrdering extends malloy_element_1.ListOf {
+    constructor(list) {
+        super(list);
+        this.elementType = 'function-ordering';
+    }
+    getAnalyticOrderBy(fs) {
+        return this.list.map(el => el.getAnalyticOrderBy(fs));
+    }
+    getAggregateOrderBy(fs) {
+        return this.list.map(el => el.getAggregateOrderBy(fs));
+    }
+}
+exports.FunctionOrdering = FunctionOrdering;
+//# sourceMappingURL=function-ordering.js.map

package/dist/lang/ast/expressions/partition_by.d.ts

@@ -0,0 +1,7 @@
+import { PartitionByFieldReference } from '../query-items/field-references';
+import { ListOf } from '../types/malloy-element';
+export declare class PartitionBy extends ListOf<PartitionByFieldReference> {
+    readonly partitionFields: PartitionByFieldReference[];
+    elementType: string;
+    constructor(partitionFields: PartitionByFieldReference[]);
+}