@malloydata/malloy 0.0.39-dev230613161129 → 0.0.39

package/dist/model/malloy_query.js

@@ -28,7 +28,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flattenQuery = exports.QueryModel = exports.Segment = void 0;
 const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
 const dialect_1 = require("../dialect");
-const standardsql_1 = require("../dialect/standardsql");
+const standardsql_1 = require("../dialect/standardsql/standardsql");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 // quote a string for SQL use.  Perhaps should be in dialect.
@@ -223,6 +223,101 @@ class QueryField extends QueryNode {
             return field.generateExpression(resultSet);
         }
     }
+    generateOutputFieldFragment(resultSet, _context, frag, _state) {
+        return resultSet.getField(frag.name).getAnalyticalSQL(false);
+    }
+    generateSQLExpression(resultSet, context, frag, state) {
+        return this.generateExpressionFromExpr(resultSet, context, frag.e, state);
+    }
+    getParameterMap(overload, numArgs) {
+        return new Map(overload.params.map((param, paramIndex) => {
+            const argIndexes = param.isVariadic
+                ? (0, utils_1.range)(paramIndex, numArgs)
+                : [paramIndex];
+            return [param.name, { param, argIndexes }];
+        }));
+    }
+    expandFunctionCall(dialect, overload, args) {
+        const paramMap = this.getParameterMap(overload, args.length);
+        if (overload.dialect[dialect] === undefined) {
+            throw new Error(`Function is not defined for dialect ${dialect}`);
+        }
+        return (0, utils_1.exprMap)(overload.dialect[dialect], fragment => {
+            if (typeof fragment === 'string') {
+                return [fragment];
+            }
+            else if (fragment.type === 'spread') {
+                const param = fragment.e[0];
+                if (fragment.e.length !== 1 ||
+                    typeof param === 'string' ||
+                    param.type !== 'function_parameter') {
+                    throw new Error('Invalid function definition. Argument to spread must be a function parameter.');
+                    return [];
+                }
+                const entry = paramMap.get(param.name);
+                if (entry === undefined) {
+                    return [fragment];
+                }
+                else {
+                    return (0, utils_1.joinWith)(entry.argIndexes.map(argIndex => args[argIndex]), ',');
+                }
+            }
+            else if (fragment.type === 'function_parameter') {
+                const entry = paramMap.get(fragment.name);
+                if (entry === undefined) {
+                    return [fragment];
+                }
+                else if (entry.param.isVariadic) {
+                    const spread = (0, utils_1.joinWith)(entry.argIndexes.map(argIndex => args[argIndex]), ',');
+                    return ['[', ...spread, ']'];
+                }
+                else {
+                    return args[entry.argIndexes[0]];
+                }
+            }
+            return [fragment];
+        });
+    }
+    generateFunctionCallExpression(resultSet, context, frag, state) {
+        const overload = frag.overload;
+        const args = frag.args;
+        const distinctKey = (0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType) &&
+            this.generateDistinctKeyIfNecessary(resultSet, context, frag.structPath);
+        if (distinctKey) {
+            if (!context.dialect.supportsAggDistinct) {
+                throw new Error(`Asymmetric aggregates are not supported for custom functions in ${context.dialect.name}.`);
+            }
+            const argsExpressions = args.map(arg => {
+                return this.generateDimFragment(resultSet, context, arg, state);
+            });
+            return context.dialect.sqlAggDistinct(distinctKey, argsExpressions, valNames => {
+                const funcCall = this.expandFunctionCall(context.dialect.name, overload, valNames.map(v => [v]));
+                return this.generateExpressionFromExpr(resultSet, context, funcCall, state);
+            });
+        }
+        else {
+            const mappedArgs = (0, malloy_types_1.expressionIsAggregate)(overload.returnType.expressionType)
+                ? args.map(arg => {
+                    // TODO We assume that all arguments to this aggregate-returning function need to
+                    // have filters applied to them. This is not necessarily true in the general case,
+                    // e.g. in a function `avg_plus(a, b) = avg(a) + b` -- here, `b` should not be
+                    // be filtered. But since there aren't any aggregate functions like this in the
+                    // standard library we have planned, we ignore this for now.
+                    return [this.generateDimFragment(resultSet, context, arg, state)];
+                })
+                : args;
+            const funcCall = this.expandFunctionCall(context.dialect.name, overload, mappedArgs);
+            if ((0, malloy_types_1.expressionIsAnalytic)(overload.returnType.expressionType)) {
+                // TODO probably need to pass in the function and arguments separately
+                // in order to generate parameter SQL correctly in BQ re: partition
+                return this.generateAnalyticFragment(resultSet, context, funcCall, overload, state, args);
+            }
+            return this.generateExpressionFromExpr(resultSet, context, funcCall, state);
+        }
+    }
+    generateSpread(_resultSet, _context, _frag, _state) {
+        throw new Error('Unexpanded spread encountered during SQL generation');
+    }
     generateParameterFragment(resultSet, context, expr, state) {
         // find the structDef and return the path to the field...
         const param = context.parameters()[expr.path];
@@ -244,7 +339,7 @@ class QueryField extends QueryNode {
         return this.generateExpressionFromExpr(resultSet, context, expr.e, state.withWhere(allWhere.sql()));
     }
     generateDimFragment(resultSet, context, expr, state) {
-        let dim = this.generateExpressionFromExpr(resultSet, context, expr.e, state);
+        let dim = this.generateExpressionFromExpr(resultSet, context, expr, state);
         if (state.whereSQL) {
             dim = `CASE WHEN ${state.whereSQL} THEN ${dim} END`;
         }
@@ -270,7 +365,7 @@ class QueryField extends QueryNode {
         const s = this.generateExpressionFromExpr(resultSet, context, expr.e, state.withTotal(totalGroupSet));
         const fields = resultSet.getUngroupPartitions(ungroupSet);
         let partitionBy = '';
-        const fieldsString = fields.map(f => f.getPartitionSQL()).join(', ');
+        const fieldsString = fields.map(f => f.getAnalyticalSQL(true)).join(', ');
         if (fieldsString.length > 0) {
             partitionBy = `PARTITION BY ${fieldsString}`;
         }
@@ -289,7 +384,7 @@ class QueryField extends QueryNode {
         }
     }
     generateSumFragment(resultSet, context, expr, state) {
-        const dimSQL = this.generateDimFragment(resultSet, context, expr, state);
+        const dimSQL = this.generateDimFragment(resultSet, context, expr.e, state);
         const distinctKeySQL = this.generateDistinctKeyIfNecessary(resultSet, context, expr.structPath);
         let ret;
         if (distinctKeySQL) {
@@ -306,7 +401,7 @@ class QueryField extends QueryNode {
         return `COALESCE(${ret},0)`;
     }
     generateSymmetricFragment(resultSet, context, expr, state) {
-        const dimSQL = this.generateDimFragment(resultSet, context, expr, state);
+        const dimSQL = this.generateDimFragment(resultSet, context, expr.e, state);
         const f = expr.function === 'count_distinct'
             ? 'count(distinct '
             : expr.function + '(';
@@ -314,7 +409,7 @@ class QueryField extends QueryNode {
     }
     generateAvgFragment(resultSet, context, expr, state) {
         // find the structDef and return the path to the field...
-        const dimSQL = this.generateDimFragment(resultSet, context, expr, state);
+        const dimSQL = this.generateDimFragment(resultSet, context, expr.e, state);
         const distinctKeySQL = this.generateDistinctKeyIfNecessary(resultSet, context, expr.structPath);
         if (distinctKeySQL) {
             let countDistinctKeySQL = distinctKeySQL;
@@ -355,60 +450,93 @@ class QueryField extends QueryNode {
     generateDialect(resultSet, context, expr, state) {
         return this.generateExpressionFromExpr(resultSet, context, context.dialect.dialectExpr(resultSet.getQueryInfo(), expr), state);
     }
-    generateAnalyticFragment(resultStruct, context, expr, state) {
-        const fields = resultStruct.getUngroupPartitions(undefined);
-        let partitionBy = '';
-        const fieldsString = fields.map(f => f.getPartitionSQL()).join(', ');
-        if (fieldsString.length > 0) {
-            partitionBy = `PARTITION BY ${fieldsString}`;
+    getAnalyticPartitions(resultStruct) {
+        const ret = [];
+        let p = resultStruct.parent;
+        while (p !== undefined) {
+            const scalars = p.fields(fi => isScalarField(fi.f) && fi.fieldUsage.type === 'result');
+            const partitionSQLs = scalars.map(fi => fi.getAnalyticalSQL(true));
+            ret.push(...partitionSQLs);
+            p = p.parent;
         }
-        let orderBy = '';
-        // calculate the ordering.
-        const obSQL = [];
-        let orderingField;
-        const orderByDef = resultStruct.firstSegment.orderBy ||
-            resultStruct.calculateDefaultOrderBy();
-        for (const ordering of orderByDef) {
-            if (typeof ordering.field === 'string') {
-                orderingField = {
-                    name: ordering.field,
-                    fif: resultStruct.getField(ordering.field),
-                };
-            }
-            else {
-                orderingField = resultStruct.getFieldByNumber(ordering.field);
-            }
-            if (resultStruct.firstSegment.type === 'reduce') {
-                obSQL.push(` ${orderingField.fif.getSQL()}` +
-                    // this.parent.dialect.sqlMaybeQuoteIdentifier(
-                    //   `${orderingField.name}__${resultStruct.groupSet}`
-                    // ) +
-                    ` ${ordering.dir || 'ASC'}`);
+        return ret.join(', ');
+    }
+    generateAnalyticFragment(resultStruct, context, expr, overload, state, args) {
+        let partitionBy = '';
+        const isComplex = resultStruct.root().isComplexQuery;
+        const fieldsString = this.getAnalyticPartitions(resultStruct);
+        if (isComplex || fieldsString.length > 0) {
+            partitionBy = 'PARTITION BY ';
+            if (isComplex) {
+                partitionBy += 'group_set';
             }
-            else if (resultStruct.firstSegment.type === 'project') {
-                obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || 'ASC'}`);
+            if (fieldsString.length > 0) {
+                partitionBy += `, ${fieldsString}`;
             }
         }
-        const func = malloy_types_1.malloyFunctions[expr.function];
-        const paramSQL = [];
-        if (expr.parameters !== undefined) {
-            for (const e of expr.parameters) {
-                if (typeof e === 'string') {
-                    paramSQL.push(e); // need to map to dimensional expression.
-                }
-                else if (typeof e === 'number') {
-                    paramSQL.push(e.toString());
+        let orderBy = '';
+        if (overload.needsWindowOrderBy) {
+            // calculate the ordering.
+            const obSQL = [];
+            let orderingField;
+            const orderByDef = resultStruct.firstSegment.orderBy ||
+                resultStruct.calculateDefaultOrderBy();
+            for (const ordering of orderByDef) {
+                if (typeof ordering.field === 'string') {
+                    orderingField = {
+                        name: ordering.field,
+                        fif: resultStruct.getField(ordering.field),
+                    };
                 }
                 else {
-                    paramSQL.push(this.generateExpressionFromExpr(resultStruct, context, e, state));
+                    orderingField = resultStruct.getFieldByNumber(ordering.field);
+                }
+                const exprType = orderingField.fif.f.fieldDef.expressionType;
+                // TODO today we do not support ordering by analytic functions at all, so this works
+                // but eventually we will, and this check will just want to ensure that the order field
+                // isn't the same as the field we're currently compiling (otherwise we will loop infintely)
+                if ((0, malloy_types_1.expressionIsAnalytic)(exprType)) {
+                    continue;
+                }
+                if (resultStruct.firstSegment.type === 'reduce') {
+                    const orderSQL = orderingField.fif.getAnalyticalSQL(false);
+                    obSQL.push(` ${orderSQL} ${ordering.dir || 'ASC'}`);
                 }
+                else if (resultStruct.firstSegment.type === 'project') {
+                    obSQL.push(` ${orderingField.fif.f.generateExpression(resultStruct)} ${ordering.dir || 'ASC'}`);
+                }
+            }
+            if (obSQL.length > 0) {
+                orderBy = ' ' + this.parent.dialect.sqlOrderBy(obSQL);
             }
         }
-        if (obSQL.length > 0) {
-            orderBy = ' ' + this.parent.dialect.sqlOrderBy(obSQL);
+        let between = '';
+        if (overload.between) {
+            const [preceding, following] = [
+                overload.between.preceding,
+                overload.between.following,
+            ].map(value => {
+                if (value === -1) {
+                    return 'UNBOUNDED';
+                }
+                if (typeof value === 'number') {
+                    return value;
+                }
+                const argIndex = overload.params.findIndex(param => param.name === value);
+                const arg = args[argIndex];
+                if (arg.length !== 1 ||
+                    typeof arg[0] === 'string' ||
+                    arg[0].type !== 'dialect' ||
+                    arg[0].function !== 'numberLiteral') {
+                    throw new Error('Invalid number of rows for window spec');
+                }
+                // TODO this does not handle float literals correctly
+                return arg[0].literal;
+            });
+            between = `ROWS BETWEEN ${preceding} PRECEDING AND ${following} FOLLOWING`;
         }
-        const sqlName = func.sqlName || expr.function;
-        return `${sqlName}(${paramSQL.join(', ')}) OVER(${partitionBy} ${orderBy} )`;
+        const funcSQL = this.generateExpressionFromExpr(resultStruct, context, expr, state);
+        return `${funcSQL} OVER(${partitionBy} ${orderBy} ${between})`;
     }
     generateExpressionFromExpr(resultSet, context, e, state = new GenerateState()) {
         let s = '';
@@ -428,9 +556,6 @@ class QueryField extends QueryNode {
             else if ((0, malloy_types_1.isUngroupFragment)(expr)) {
                 s += this.generateUngroupedFragment(resultSet, context, expr, state);
             }
-            else if ((0, malloy_types_1.isAnalyticFragment)(expr)) {
-                s += this.generateAnalyticFragment(resultSet, context, expr, state);
-            }
             else if ((0, malloy_types_1.isAggregateFragment)(expr)) {
                 let agg;
                 if (expr.function === 'sum') {
@@ -471,6 +596,21 @@ class QueryField extends QueryNode {
                     throw new Error('Internal Error: Partial application value referenced but not provided');
                 }
             }
+            else if ((0, malloy_types_1.isFunctionParameterFragment)(expr)) {
+                throw new Error('Internal Error: Function parameter fragment remaining during SQL generation');
+            }
+            else if ((0, malloy_types_1.isOutputFieldFragment)(expr)) {
+                s += this.generateOutputFieldFragment(resultSet, context, expr, state);
+            }
+            else if ((0, malloy_types_1.isSQLExpressionFragment)(expr)) {
+                s += this.generateSQLExpression(resultSet, context, expr, state);
+            }
+            else if ((0, malloy_types_1.isFunctionCallFragment)(expr)) {
+                s += this.generateFunctionCallExpression(resultSet, context, expr, state);
+            }
+            else if ((0, malloy_types_1.isSpreadFragment)(expr)) {
+                s += this.generateSpread(resultSet, context, expr, state);
+            }
             else if (expr.type === 'dialect') {
                 s += this.generateDialect(resultSet, context, expr, state);
             }
@@ -499,6 +639,9 @@ class QueryField extends QueryNode {
 function isCalculatedField(f) {
     return f instanceof QueryAtomicField && f.isCalculated();
 }
+function isAggregateField(f) {
+    return f instanceof QueryAtomicField && f.isAggregate();
+}
 function isScalarField(f) {
     return f instanceof QueryAtomicField && !f.isCalculated();
 }
@@ -509,6 +652,9 @@ class QueryAtomicField extends QueryField {
     isCalculated() {
         return (0, malloy_types_1.expressionIsCalculation)(this.fieldDef.expressionType);
     }
+    isAggregate() {
+        return (0, malloy_types_1.expressionIsAggregate)(this.fieldDef.expressionType);
+    }
     getFilterList() {
         return [];
     }
@@ -640,19 +786,22 @@ class FieldInstanceField {
     getSQL() {
         let exp = this.f.generateExpression(this.parent);
         if (isScalarField(this.f)) {
-            exp = this.f.caseGroup(this.parent.childGroups.concat(this.additionalGroupSets), 
-            // this.parent.groupSet > 0 ? this.parent.childGroups : [],
-            exp);
+            exp = this.f.caseGroup(this.parent.groupSet > 0
+                ? this.parent.childGroups.concat(this.additionalGroupSets)
+                : [], exp);
         }
         return exp;
     }
-    getPartitionSQL() {
-        if (this.partitionSQL === undefined) {
+    getAnalyticalSQL(forPartition) {
+        if (this.analyticalSQL === undefined) {
             return this.getSQL();
         }
-        else {
+        else if (forPartition && this.partitionSQL) {
             return this.partitionSQL;
         }
+        else {
+            return this.analyticalSQL;
+        }
     }
 }
 class FieldInstanceResult {
@@ -839,7 +988,7 @@ class FieldInstanceResult {
                     if (['date', 'timestamp'].indexOf(fi.f.fieldDef.type) > -1) {
                         return [{ dir: 'desc', field: fi.fieldUsage.resultIndex }];
                     }
-                    else if (isCalculatedField(fi.f)) {
+                    else if (isAggregateField(fi.f)) {
                         return [{ dir: 'desc', field: fi.fieldUsage.resultIndex }];
                     }
                 }
@@ -1319,6 +1468,13 @@ class QueryQuery extends QueryField {
     }
     addDependantExpr(resultStruct, context, e, joinStack) {
         for (const expr of e) {
+            if ((0, malloy_types_1.isFunctionCallFragment)(expr) &&
+                (0, malloy_types_1.expressionIsAnalytic)(expr.overload.returnType.expressionType) &&
+                this.parent.dialect.name === 'standardsql') {
+                // force the use of a lateral_join_bag
+                resultStruct.root().isComplexQuery = true;
+                resultStruct.root().queryUsesPartitioning = true;
+            }
             if ((0, malloy_types_1.isUngroupFragment)(expr)) {
                 resultStruct.resultUsesUngrouped = true;
                 resultStruct.root().isComplexQuery = true;
@@ -1352,6 +1508,7 @@ class QueryQuery extends QueryField {
                     this.addDependantExpr(resultStruct, context, filterCond.expression, joinStack);
                     this.addDependantExpr(resultStruct, context, expr.e, joinStack);
                 }
+                this.addDependantExpr(resultStruct, context, expr.e, joinStack);
             }
             else if ((0, malloy_types_1.isDialectFragment)(expr)) {
                 const expressions = [];
@@ -1362,9 +1519,10 @@ class QueryQuery extends QueryField {
                         expressions.push(expr.denominator);
                         expressions.push(expr.numerator);
                         break;
+                    case 'numberLiteral':
                     case 'timeLiteral':
-                        break;
                     case 'stringLiteral':
+                    case 'regexpLiteral':
                         break;
                     case 'timeDiff':
                         expressions.push(expr.left.value, expr.right.value);
@@ -1399,8 +1557,18 @@ class QueryQuery extends QueryField {
                 }
                 this.addDependantExpr(resultStruct, context, expr.e, joinStack);
             }
-            else if ((0, malloy_types_1.isAnalyticFragment)(expr)) {
-                resultStruct.root().queryUsesPartitioning = true;
+            else if ((0, malloy_types_1.isFunctionCallFragment)(expr)) {
+                if (expr.structPath) {
+                    this.addDependantPath(resultStruct, context, expr.structPath, true, joinStack);
+                }
+                // TODO Do we need to call `addStructToJoin` here in the case when there is no `structPath`
+                // and the function is an aggregate function?
+                for (const e of expr.args) {
+                    this.addDependantExpr(resultStruct, context, e, joinStack);
+                }
+                if ((0, malloy_types_1.expressionIsAnalytic)(expr.overload.returnType.expressionType)) {
+                    resultStruct.root().queryUsesPartitioning = true;
+                }
             }
         }
     }
@@ -1427,7 +1595,7 @@ class QueryQuery extends QueryField {
                     type: 'result',
                 });
                 this.addDependancies(resultStruct, field);
-                if (isCalculatedField(field)) {
+                if (isAggregateField(field)) {
                     if (this.firstSegment.type === 'project') {
                         throw new Error(`Aggregate Fields cannot be used in PROJECT - '${field.fieldDef.name}'`);
                     }
@@ -1486,7 +1654,7 @@ class QueryQuery extends QueryField {
         for (const cond of list || []) {
             const context = this.parent;
             if ((which === 'having' && (0, malloy_types_1.expressionIsCalculation)(cond.expressionType)) ||
-                (which === 'where' && cond.expressionType === 'scalar')) {
+                (which === 'where' && (0, malloy_types_1.expressionIsScalar)(cond.expressionType))) {
                 const sqlClause = this.generateExpressionFromExpr(resultStruct, context, cond.expression, undefined);
                 resultFilters.add(sqlClause);
             }
@@ -1878,20 +2046,16 @@ class QueryQuery extends QueryField {
                             // BigQuery can't partition aggregate function except when the field has no
                             //  expression.  Additionally it can't partition by floats.  We stuff expressions
                             //  and numbers as strings into a lateral join when the query has ungrouped expressions
+                            const outputFieldName = `__lateral_join_bag.${outputName}`;
+                            fi.analyticalSQL = outputFieldName;
+                            output.lateralJoinSQLExpressions.push(`${exp} as ${outputName}`);
+                            output.sql.push(outputFieldName);
                             if (fi.f.fieldDef.type === 'number') {
-                                // make an extra dimension as a string
-                                output.sql.push(`${exp} as ${outputName}`);
-                                const outputFieldName = `__lateral_join_bag.${outputName}_string`;
-                                output.sql.push(outputFieldName);
+                                const outputFieldNameString = `${outputFieldName}_string`;
+                                output.sql.push(outputFieldNameString);
                                 output.dimensionIndexes.push(output.fieldIndex++);
                                 output.lateralJoinSQLExpressions.push(`CAST(${exp} as STRING) as ${outputName}_string`);
-                                fi.partitionSQL = outputFieldName;
-                            }
-                            else {
-                                const outputFieldName = `__lateral_join_bag.${outputName}`;
-                                fi.partitionSQL = outputFieldName;
-                                output.lateralJoinSQLExpressions.push(`${exp} as ${outputName}`);
-                                output.sql.push(outputFieldName);
+                                fi.partitionSQL = outputFieldNameString;
                             }
                         }
                         else {

package/dist/model/malloy_types.d.ts

@@ -90,6 +90,11 @@ export interface ResultMetadata {
 export interface ResultStructMetadata {
     resultMetadata?: ResultStructMetadataDef;
 }
+export interface OutputFieldFragment {
+    type: 'outputField';
+    name: string;
+}
+export declare function isOutputFieldFragment(f: Fragment): f is OutputFieldFragment;
 export interface FilterFragment {
     type: 'filterExpression';
     filterList: FilterExpression[];
@@ -111,20 +116,29 @@ export interface UngroupFragment {
     fields?: string[];
 }
 export declare function isUngroupFragment(f: Fragment): f is UngroupFragment;
-export declare type MalloyFunctionParam = AtomicFieldType | 'any' | 'nconst' | 'regexp';
-export interface MalloyFunctionInfo {
-    returnType: AtomicFieldType;
-    parameters: 'any' | 'none' | MalloyFunctionParam[];
-    expressionType?: 'aggregate' | 'analytic';
-    sqlName?: string;
-}
-export declare const malloyFunctions: Record<string, MalloyFunctionInfo>;
-export interface AnalyticFragment {
-    type: 'analytic';
-    function: string;
-    parameters?: (string | number | Expr)[];
+export interface FunctionParameterFragment {
+    type: 'function_parameter';
+    name: string;
+}
+export declare function isFunctionParameterFragment(f: Fragment): f is FunctionParameterFragment;
+export interface FunctionCallFragment {
+    type: 'function_call';
+    overload: FunctionOverloadDef;
+    expressionType: ExpressionType;
+    args: Expr[];
+    structPath?: string;
+}
+export declare function isFunctionCallFragment(f: Fragment): f is FunctionCallFragment;
+export interface SQLExpressionFragment {
+    type: 'sql_expression';
+    e: Expr;
 }
-export declare function isAnalyticFragment(f: Fragment): f is AnalyticFragment;
+export declare function isSQLExpressionFragment(f: Fragment): f is SQLExpressionFragment;
+export interface SpreadFragment {
+    type: 'spread';
+    e: Expr;
+}
+export declare function isSpreadFragment(f: Fragment): f is SpreadFragment;
 export interface FieldFragment {
     type: 'field';
     path: string;
@@ -185,7 +199,7 @@ export interface TypecastFragment extends DialectFragmentBase {
 export interface RegexpMatchFragment extends DialectFragmentBase {
     function: 'regexpMatch';
     expr: Expr;
-    regexp: string;
+    regexp: Expr;
 }
 export interface DivFragment extends DialectFragmentBase {
     function: 'div';
@@ -202,8 +216,16 @@ export interface StringLiteralFragment extends DialectFragmentBase {
     function: 'stringLiteral';
     literal: string;
 }
-export declare type DialectFragment = DivFragment | TimeLiteralFragment | NowFragment | TimeDeltaFragment | TimeDiffFragment | TimeTruncFragment | TypecastFragment | TimeExtractFragment | StringLiteralFragment | RegexpMatchFragment;
-export declare type Fragment = string | ApplyFragment | ApplyValueFragment | FieldFragment | ParameterFragment | FilterFragment | AggregateFragment | UngroupFragment | DialectFragment | AnalyticFragment;
+export interface RegexpLiteralFragment extends DialectFragmentBase {
+    function: 'regexpLiteral';
+    literal: string;
+}
+export interface NumberLiteralFragment extends DialectFragmentBase {
+    function: 'numberLiteral';
+    literal: string;
+}
+export declare type DialectFragment = DivFragment | TimeLiteralFragment | NowFragment | TimeDeltaFragment | TimeDiffFragment | TimeTruncFragment | TypecastFragment | TimeExtractFragment | StringLiteralFragment | RegexpLiteralFragment | NumberLiteralFragment | RegexpMatchFragment;
+export declare type Fragment = string | ApplyFragment | ApplyValueFragment | FieldFragment | ParameterFragment | FilterFragment | OutputFieldFragment | AggregateFragment | UngroupFragment | DialectFragment | FunctionParameterFragment | FunctionCallFragment | SQLExpressionFragment | SpreadFragment;
 export declare type Expr = Fragment[];
 export interface TypedValue {
     value: Expr;
@@ -224,15 +246,21 @@ declare type TagElement = Expr | string;
  * ```
  */
 export declare function mkExpr(src: TemplateStringsArray, ...exprs: TagElement[]): Expr;
-export declare type ExpressionType = 'scalar' | 'aggregate' | 'analytic';
+export declare type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
 export interface Expression {
     e?: Expr;
     expressionType?: ExpressionType;
     code?: string;
 }
+export declare function expressionIsScalar(e: ExpressionType | undefined): boolean;
 export declare function expressionIsAggregate(e: ExpressionType | undefined): boolean;
+export declare function expressionIsUngroupedAggregate(e: ExpressionType | undefined): boolean;
+export declare function expressionInvolvesAggregate(e: ExpressionType | undefined): boolean;
 export declare function expressionIsCalculation(e: ExpressionType | undefined): boolean;
+export declare function expressionIsAnalytic(e: ExpressionType | undefined): boolean;
+export declare function isExpressionTypeLEQ(e1: ExpressionType, e2: ExpressionType): boolean;
 export declare function maxExpressionType(e1: ExpressionType, e2: ExpressionType): ExpressionType;
+export declare function maxOfExpressionTypes(types: ExpressionType[]): ExpressionType;
 interface JustExpression {
     e: Expr;
 }
@@ -452,6 +480,48 @@ export interface StructDef extends NamedObject, ResultStructMetadata, Filtered {
     queryTimezone?: string;
     dialect: string;
 }
+export declare type ExpressionValueType = AtomicFieldType | 'null' | 'unknown' | 'duration' | 'any' | 'regular expression';
+export declare type FieldValueType = ExpressionValueType | 'turtle' | 'struct';
+export interface ExpressionTypeDesc {
+    dataType: FieldValueType;
+    expressionType: ExpressionType;
+    rawType?: string;
+    evalSpace: EvalSpace;
+}
+export interface FunctionParamTypeDesc {
+    dataType: FieldValueType;
+    expressionType: ExpressionType | undefined;
+    evalSpace: EvalSpace;
+}
+export declare type EvalSpace = 'constant' | 'input' | 'output' | 'literal';
+export declare function mergeEvalSpaces(...evalSpaces: EvalSpace[]): EvalSpace;
+export interface TypeDesc {
+    dataType: FieldValueType;
+    expressionType: ExpressionType;
+    rawType?: string;
+    evalSpace: EvalSpace;
+}
+export interface FunctionParameterDef {
+    name: string;
+    allowedTypes: FunctionParamTypeDesc[];
+    isVariadic: boolean;
+}
+export interface FunctionOverloadDef {
+    returnType: TypeDesc;
+    needsWindowOrderBy?: boolean;
+    between?: {
+        preceding: number | string;
+        following: number | string;
+    };
+    params: FunctionParameterDef[];
+    dialect: {
+        [dialect: string]: Expr;
+    };
+}
+export interface FunctionDef extends NamedObject {
+    type: 'function';
+    overloads: FunctionOverloadDef[];
+}
 export interface SQLBlockStructDef extends StructDef {
     structSource: SubquerySource;
     declaredSQLBlock?: boolean;
@@ -480,7 +550,7 @@ export interface FilterExpression {
 }
 /** Get the output name for a NamedObject */
 export declare function getIdentifier(n: AliasedName): string;
-export declare type NamedModelObject = StructDef | NamedQuery;
+export declare type NamedModelObject = StructDef | NamedQuery | FunctionDef;
 /** Result of parsing a model file */
 export interface ModelDef {
     name: string;
@@ -489,6 +559,7 @@ export interface ModelDef {
 }
 /** Very common record type */
 export declare type NamedStructDefs = Record<string, StructDef>;
+export declare type NamedModelObjects = Record<string, NamedModelObject>;
 export declare type QueryScalar = string | boolean | number | Date | Buffer | null;
 /** One value in one column of returned data. */
 export declare type QueryValue = QueryScalar | QueryData | QueryDataRow;