@malloydata/malloy 0.0.182-dev240911142514 → 0.0.182-dev240911163224

package/dist/dialect/functions/malloy_standard_functions.js

@@ -0,0 +1,612 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandOverrideMap = exports.getMalloyStandardFunctions = exports.MALLOY_STANDARD_FUNCTIONS = void 0;
+const util_1 = require("./util");
+const abs = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'ABS' },
+};
+const acos = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'ACOS' },
+};
+const ascii = {
+    takes: { 'value': 'string' },
+    returns: 'number',
+    impl: { function: 'ASCII' },
+};
+const asin = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'ASIN' },
+};
+const atan2 = {
+    takes: { 'y': 'number', 'x': 'number' },
+    returns: 'number',
+    impl: { function: 'ATAN2' },
+};
+const atan = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'ATAN' },
+};
+const byte_length = {
+    takes: { 'value': 'string' },
+    returns: 'number',
+    impl: { function: 'BYTE_LENGTH' },
+};
+const ceil = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'CEIL' },
+};
+const chr = {
+    takes: { 'value': 'number' },
+    returns: 'string',
+    impl: { sql: "CASE WHEN ${value} = 0 THEN '' ELSE CHR(${value}) END" },
+};
+const coalesce = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    takes: { 'value': { variadic: { generic: 'T' } } },
+    returns: { generic: 'T' },
+    impl: { function: 'COALESCE' },
+};
+const concat = {
+    'empty': {
+        takes: {},
+        returns: 'string',
+        impl: { expr: { node: 'stringLiteral', literal: '' } },
+    },
+    'variadic': {
+        takes: {
+            'values': {
+                variadic: ['string', 'number', 'date', 'timestamp', 'boolean'],
+            },
+        },
+        returns: 'string',
+        impl: { function: 'CONCAT' },
+    },
+};
+const cos = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'COS' },
+};
+const div = {
+    takes: { 'dividend': 'number', 'divisor': 'number' },
+    returns: 'number',
+    impl: { function: 'DIV' },
+};
+const ends_with = {
+    takes: { 'value': 'string', 'suffix': 'string' },
+    returns: 'boolean',
+    impl: { sql: 'COALESCE(ENDS_WITH(${value}, ${suffix}), false)' },
+};
+const exp = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'EXP' },
+};
+const floor = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'FLOOR' },
+};
+const greatest = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    takes: { 'values': { variadic: { generic: 'T' } } },
+    returns: { generic: 'T' },
+    impl: { function: 'GREATEST' },
+};
+const ifnull = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    takes: { 'value': { generic: 'T' }, 'default': { generic: 'T' } },
+    returns: { generic: 'T' },
+    impl: { function: 'IFNULL' },
+};
+const is_inf = {
+    takes: { 'value': 'number' },
+    returns: 'boolean',
+    impl: { sql: 'COALESCE(IS_INF(${value}), false)' },
+};
+const is_nan = {
+    takes: { 'value': 'number' },
+    returns: 'boolean',
+    impl: { sql: 'COALESCE(IS_NAN(${value}), false)' },
+};
+const least = {
+    ...greatest,
+    impl: { function: 'LEAST' },
+};
+const length = {
+    takes: { 'value': 'string' },
+    returns: 'number',
+    impl: { function: 'LENGTH' },
+};
+const ln = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'LN' },
+};
+const log = {
+    takes: {
+        'value': 'number',
+        'base': 'number',
+    },
+    returns: 'number',
+    impl: { function: 'LOG' },
+};
+const lower = {
+    takes: { 'value': 'string' },
+    returns: 'string',
+    impl: { function: 'LOWER' },
+};
+const ltrim = {
+    'whitespace': {
+        takes: { 'value': 'string' },
+        returns: 'string',
+        impl: { function: 'LTRIM' },
+    },
+    'characters': {
+        takes: { 'value': 'string', 'trim_characters': 'string' },
+        returns: 'string',
+        impl: { function: 'LTRIM' },
+    },
+};
+const nullif = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    takes: { 'value1': { generic: 'T' }, 'value2': { generic: 'T' } },
+    returns: { generic: 'T' },
+    impl: { function: 'NULLIF' },
+};
+const pi = {
+    takes: {},
+    returns: 'number',
+    impl: { function: 'PI' },
+};
+const pow = {
+    takes: { 'base': 'number', 'exponent': 'number' },
+    returns: 'number',
+    impl: { function: 'POW' },
+};
+const rand = {
+    takes: {},
+    returns: 'number',
+    impl: { function: 'RAND' },
+};
+const regexp_extract = {
+    // TODO consider supporting these parameters
+    // 'position': 'number',
+    // 'occurrence': 'number',
+    takes: { 'value': 'string', 'pattern': 'regular expression' },
+    returns: 'string',
+    impl: { function: 'REGEXP_EXTRACT' },
+};
+const repeat = {
+    takes: { 'value': 'string', 'count': 'number' },
+    returns: 'string',
+    impl: { function: 'REPEAT' },
+};
+// TODO maybe we need to have a parameter to say whether it's a global replacement or not...
+const replace = {
+    'string': {
+        takes: { 'value': 'string', 'pattern': 'string', 'replacement': 'string' },
+        returns: 'string',
+        impl: { function: 'REPLACE' },
+    },
+    // TODO perhaps this should be a separate `regexp_replace` function.
+    // Which would better match BQ, but I think it should be just a different
+    // overload of `replace` (how it is here):
+    'regular_expression': {
+        takes: {
+            'value': 'string',
+            'pattern': 'regular expression',
+            'replacement': 'string',
+        },
+        returns: 'string',
+        impl: { function: 'REGEXP_REPLACE' },
+    },
+};
+const reverse = {
+    takes: { 'value': 'string' },
+    returns: 'string',
+    impl: { function: 'REVERSE' },
+};
+const round = {
+    'to_integer': {
+        takes: { 'value': 'number' },
+        returns: 'number',
+        impl: { function: 'ROUND' },
+    },
+    // TODO Consider adding a third overload for round(x, y, mode), where
+    // "mode" is "ROUND_HALF_AWAY_FROM_ZERO" or "ROUND_HALF_EVEN"
+    // TODO precision should only accept integers, but we don't have a good
+    // way of expressing that constraint at the moment
+    'to_precision': {
+        takes: { 'value': 'number', 'precision': 'number' },
+        returns: 'number',
+        impl: { function: 'ROUND' },
+    },
+};
+const rtrim = {
+    'whitespace': {
+        ...ltrim['whitespace'],
+        impl: { function: 'RTRIM' },
+    },
+    'characters': {
+        ...ltrim['characters'],
+        impl: { function: 'RTRIM' },
+    },
+};
+const sign = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'SIGN' },
+};
+const sin = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'SIN' },
+};
+const sqrt = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'SQRT' },
+};
+const starts_with = {
+    takes: { 'value': 'string', 'prefix': 'string' },
+    returns: 'boolean',
+    impl: { sql: 'COALESCE(STARTS_WITH(${value}, ${prefix}), false)' },
+};
+const strpos = {
+    takes: { 'test_string': 'string', 'search_string': 'string' },
+    returns: 'number',
+    impl: { function: 'STRPOS' },
+};
+const substr = {
+    'position_only': {
+        takes: { 'value': 'string', 'position': 'number' },
+        returns: 'string',
+        impl: { function: 'SUBSTR' },
+    },
+    'with_length': {
+        takes: { 'value': 'string', 'position': 'number', 'length': 'number' },
+        returns: 'string',
+        impl: { function: 'SUBSTR' },
+    },
+};
+const tan = {
+    takes: { 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'TAN' },
+};
+const trim = {
+    'whitespace': {
+        ...ltrim['whitespace'],
+        impl: { function: 'TRIM' },
+    },
+    'characters': {
+        ...ltrim['characters'],
+        impl: { function: 'TRIM' },
+    },
+};
+const trunc = {
+    'to_integer': {
+        takes: { 'value': 'number' },
+        returns: 'number',
+        impl: { function: 'TRUNC' },
+    },
+    // TODO precision should only accept integers, but we don't have a good
+    // way of expressing that constraint at the moment
+    'to_precision': {
+        takes: { 'value': 'number', 'precision': 'number' },
+        returns: 'number',
+        impl: { function: 'TRUNC' },
+    },
+};
+const unicode = {
+    takes: { 'value': 'string' },
+    returns: 'number',
+    impl: { function: 'UNICODE' },
+};
+const upper = {
+    takes: { 'value': 'string' },
+    returns: 'string',
+    impl: { function: 'UPPER' },
+};
+// Aggregate functions
+const stddev = {
+    takes: { 'value': { dimension: 'number' } },
+    returns: { measure: 'number' },
+    impl: { function: 'STDDEV' },
+};
+// Analytic functions
+const avg_moving = {
+    'preceding': {
+        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+            'preceding': { literal: 'number' },
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: {
+            sql: 'AVG(${value})',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 0 },
+        },
+    },
+    'following': {
+        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+            'preceding': { literal: 'number' },
+            'following': { literal: 'number' },
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: {
+            sql: 'AVG(${value})',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 'following' },
+        },
+    },
+};
+const first_value = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'FIRST_VALUE', needsWindowOrderBy: true },
+};
+const LAG_TYPES = [
+    'string',
+    'number',
+    'timestamp',
+    'date',
+    'json',
+    'boolean',
+];
+const lag = {
+    'bare': {
+        generic: ['T', LAG_TYPES],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: { function: 'LAG', needsWindowOrderBy: true },
+    },
+    'with_offset': {
+        generic: ['T', LAG_TYPES],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+            'offset': { literal: 'number' },
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: { function: 'LAG', needsWindowOrderBy: true },
+    },
+    'with_default': {
+        generic: ['T', LAG_TYPES],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+            'offset': { literal: 'number' },
+            'default': { constant: { generic: 'T' } }, // TODO needs to be constant max aggregate?
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: { function: 'LAG', needsWindowOrderBy: true },
+    },
+};
+const last_value = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date', 'json']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: {
+        function: 'LAST_VALUE',
+        needsWindowOrderBy: true,
+        between: { preceding: -1, following: -1 },
+    },
+};
+const lead = {
+    'bare': {
+        ...lag['bare'],
+        impl: { function: 'LEAD', needsWindowOrderBy: true },
+    },
+    'with_offset': {
+        ...lag['with_offset'],
+        impl: { function: 'LEAD', needsWindowOrderBy: true },
+    },
+    'with_default': {
+        ...lag['with_default'],
+        impl: { function: 'LEAD', needsWindowOrderBy: true },
+    },
+};
+const max_cumulative = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'MAX', needsWindowOrderBy: true },
+};
+const max_window = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'MAX', needsWindowOrderBy: false },
+};
+const min_cumulative = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'MIN', needsWindowOrderBy: true },
+};
+const min_window = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'MIN', needsWindowOrderBy: false },
+};
+// TODO would you ever want to rank by a different thing than the order by?
+const rank = {
+    takes: {},
+    returns: { calculation: 'number' },
+    impl: { function: 'RANK', needsWindowOrderBy: true },
+};
+const row_number = {
+    takes: {},
+    returns: { calculation: 'number' },
+    impl: { function: 'ROW_NUMBER', needsWindowOrderBy: true },
+};
+const sum_cumulative = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'SUM', needsWindowOrderBy: true },
+};
+const sum_moving = {
+    'preceding': {
+        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+            'preceding': { literal: 'number' },
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: {
+            sql: 'SUM(${value})',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 0 },
+        },
+    },
+    'following': {
+        generic: ['T', ['string', 'number', 'timestamp', 'date']],
+        takes: {
+            'value': { measure: { generic: 'T' } },
+            'preceding': { literal: 'number' },
+            'following': { literal: 'number' },
+        },
+        returns: { calculation: { generic: 'T' } },
+        impl: {
+            sql: 'SUM(${value})',
+            needsWindowOrderBy: true,
+            between: { preceding: 'preceding', following: 'following' },
+        },
+    },
+};
+const sum_window = {
+    generic: ['T', ['string', 'number', 'timestamp', 'date']],
+    takes: { 'value': { measure: { generic: 'T' } } },
+    returns: { calculation: { generic: 'T' } },
+    impl: { function: 'SUM', needsWindowOrderBy: false },
+};
+// SQL functions
+const sql_boolean = {
+    takes: { 'value': { literal: 'string' } },
+    returns: 'boolean',
+    impl: { expr: { node: 'function_parameter', name: 'value' } },
+};
+const sql_date = {
+    takes: { 'value': { literal: 'string' } },
+    returns: 'date',
+    impl: { expr: { node: 'function_parameter', name: 'value' } },
+};
+const sql_number = {
+    takes: { 'value': { literal: 'string' } },
+    returns: 'number',
+    impl: { expr: { node: 'function_parameter', name: 'value' } },
+};
+const sql_string = {
+    takes: { 'value': { literal: 'string' } },
+    returns: 'string',
+    impl: { expr: { node: 'function_parameter', name: 'value' } },
+};
+const sql_timestamp = {
+    takes: { 'value': { literal: 'string' } },
+    returns: 'timestamp',
+    impl: { expr: { node: 'function_parameter', name: 'value' } },
+};
+exports.MALLOY_STANDARD_FUNCTIONS = {
+    abs,
+    acos,
+    ascii,
+    asin,
+    atan2,
+    atan,
+    byte_length,
+    ceil,
+    chr,
+    coalesce,
+    concat,
+    cos,
+    div,
+    ends_with,
+    exp,
+    floor,
+    greatest,
+    ifnull,
+    is_inf,
+    is_nan,
+    least,
+    length,
+    ln,
+    log,
+    lower,
+    ltrim,
+    nullif,
+    pi,
+    pow,
+    rand,
+    regexp_extract,
+    repeat,
+    replace,
+    reverse,
+    round,
+    rtrim,
+    sign,
+    sin,
+    sqrt,
+    starts_with,
+    strpos,
+    substr,
+    tan,
+    trim,
+    trunc,
+    unicode,
+    upper,
+    // Aggregate functions
+    stddev,
+    // string_agg,
+    // string_agg_distinct,
+    // Analytic functions
+    avg_moving,
+    first_value,
+    lag,
+    last_value,
+    lead,
+    max_cumulative,
+    max_window,
+    min_cumulative,
+    min_window,
+    rank,
+    row_number,
+    sum_cumulative,
+    sum_moving,
+    sum_window,
+    // SQL functions
+    sql_boolean,
+    sql_date,
+    sql_number,
+    sql_string,
+    sql_timestamp,
+};
+function getMalloyStandardFunctions() {
+    return (0, util_1.expandBlueprintMap)(exports.MALLOY_STANDARD_FUNCTIONS);
+}
+exports.getMalloyStandardFunctions = getMalloyStandardFunctions;
+function expandOverrideMap(overrides) {
+    return (0, util_1.expandOverrideMapFromBase)(exports.MALLOY_STANDARD_FUNCTIONS, overrides);
+}
+exports.expandOverrideMap = expandOverrideMap;
+//# sourceMappingURL=malloy_standard_functions.js.map

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

@@ -1,4 +1,4 @@
-import { FunctionParameterDef, FieldValueType, TypeDesc, Expr, FunctionParamTypeDesc } from '../../model/malloy_types';
+import { FunctionParameterDef, FieldValueType, TypeDesc, Expr, FunctionParamTypeDesc, ExpressionValueType } from '../../model/malloy_types';
 import { SQLExprElement } from '../../model/utils';
 export interface DialectFunctionOverloadDef {
     returnType: TypeDesc;
@@ -20,7 +20,7 @@ export declare function sql(strings: TemplateStringsArray, ...subExprs: SQLExprE
 export declare function constant(type: TypeDesc): TypeDesc;
 export declare function output(type: TypeDesc): TypeDesc;
 export declare function literal(type: TypeDesc): TypeDesc;
-export declare function params(name: string, ...allowedTypes: FunctionParamTypeDesc[]): FunctionParameterDef;
+export declare function variadicParam(name: string, ...allowedTypes: FunctionParamTypeDesc[]): FunctionParameterDef;
 /**
  * Prefer `makeParam` for future function definitions
  */
@@ -48,3 +48,79 @@ export declare function overload(returnType: TypeDesc, params: FunctionParameter
     defaultOrderByArgIndex?: number;
     supportsOrderBy?: boolean | 'only_default';
 }): DialectFunctionOverloadDef;
+export type TypeDescBlueprint = ExpressionValueType | {
+    generic: string;
+} | {
+    literal: ExpressionValueType | {
+        generic: string;
+    };
+} | {
+    constant: ExpressionValueType | {
+        generic: string;
+    };
+} | {
+    dimension: ExpressionValueType | {
+        generic: string;
+    };
+} | {
+    measure: ExpressionValueType | {
+        generic: string;
+    };
+} | {
+    calculation: ExpressionValueType | {
+        generic: string;
+    };
+};
+type ParamTypeBlueprint = TypeDescBlueprint | TypeDescBlueprint[] | {
+    variadic: TypeDescBlueprint | TypeDescBlueprint[];
+};
+export interface SignatureBlueprint {
+    generic?: [string, ExpressionValueType[]];
+    takes: {
+        [name: string]: ParamTypeBlueprint;
+    };
+    returns: TypeDescBlueprint;
+    supportsOrderBy?: boolean | 'only_default';
+    supportsLimit?: boolean;
+    isSymmetric?: boolean;
+}
+interface ImplementationBlueprintBase {
+    needsWindowOrderBy?: boolean;
+    between?: {
+        preceding: number | string;
+        following: number | string;
+    };
+    defaultOrderByArgIndex?: number;
+}
+interface ImplementationBlueprintSql extends ImplementationBlueprintBase {
+    sql: string;
+}
+interface ImplementationBlueprintExpr extends ImplementationBlueprintBase {
+    expr: Expr;
+}
+interface ImplementationBlueprintFunction extends ImplementationBlueprintBase {
+    function: string;
+}
+export type ImplementationBlueprint = ImplementationBlueprintSql | ImplementationBlueprintExpr | ImplementationBlueprintFunction;
+export interface DefinitionBlueprint extends SignatureBlueprint {
+    impl: ImplementationBlueprint;
+}
+export type OverloadedDefinitionBlueprint = {
+    [signatureName: string]: DefinitionBlueprint;
+};
+export type DefinitionBlueprintMap = {
+    [name: string]: DefinitionBlueprint | OverloadedDefinitionBlueprint;
+};
+export type OverloadedImplementationBlueprint = {
+    [signatureName: string]: ImplementationBlueprint;
+};
+export type OverrideMap = {
+    [name: string]: ImplementationBlueprint | OverloadedImplementationBlueprint;
+};
+export declare function expandBlueprintMap(blueprints: DefinitionBlueprintMap): {
+    [name: string]: DialectFunctionOverloadDef[];
+};
+export declare function expandOverrideMapFromBase(base: DefinitionBlueprintMap, overrides: OverrideMap): {
+    [name: string]: DialectFunctionOverloadDef[];
+};
+export {};