@malloydata/malloy 0.0.182-dev240911155850 → 0.0.182-dev240911163224

package/dist/dialect/dialect.d.ts

@@ -59,7 +59,9 @@ export declare abstract class Dialect {
     hasModOperator: boolean;
     supportsLeftJoinUnnest: boolean;
     supportsCountApprox: boolean;
-    abstract getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
+    abstract getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
     abstract getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };

package/dist/dialect/dialect_map.d.ts

@@ -1,5 +1,4 @@
 import { Dialect } from './dialect';
-import { FunctionDef } from '../model/malloy_types';
 export declare function getDialect(name: string): Dialect;
 export declare function registerDialect(d: Dialect): void;
-export declare function getDialectFunction(name: string): FunctionDef | undefined;
+export declare function getDialects(): Dialect[];

package/dist/dialect/dialect_map.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDialectFunction = exports.registerDialect = exports.getDialect = void 0;
+exports.getDialects = exports.registerDialect = exports.getDialect = void 0;
 const duckdb_1 = require("./duckdb");
 const postgres_1 = require("./postgres");
 const snowflake_1 = require("./snowflake");
@@ -41,83 +41,14 @@ function registerDialect(d) {
     dialectMap.set(d.name, d);
 }
 exports.registerDialect = registerDialect;
+function getDialects() {
+    return [...dialectMap.values()];
+}
+exports.getDialects = getDialects;
 registerDialect(new postgres_1.PostgresDialect());
 registerDialect(new standardsql_1.StandardSQLDialect());
 registerDialect(new duckdb_1.DuckDBDialect());
 registerDialect(new snowflake_1.SnowflakeDialect());
 registerDialect(new trino_1.TrinoDialect());
 registerDialect(new trino_1.PrestoDialect());
-function paramsEqual(a, b) {
-    return (a.params.length === b.params.length &&
-        a.params.every((param, i) => {
-            const otherParam = b.params[i];
-            return (param.isVariadic === otherParam.isVariadic &&
-                param.name === otherParam.name &&
-                param.allowedTypes.length === otherParam.allowedTypes.length &&
-                param.allowedTypes.every(t => otherParam.allowedTypes.some(ot => t.dataType === ot.dataType &&
-                    t.expressionType === ot.expressionType)));
-        }));
-}
-function paramsCompatible(a, b) {
-    // TODO detect when parameters are not exactly equal, but would cause collision issues...
-    return paramsEqual(a, b);
-}
-function returnEqual(a, b) {
-    return (a.returnType.dataType === b.returnType.dataType &&
-        a.returnType.expressionType === b.returnType.expressionType);
-}
-function getDialectFunction(name) {
-    const func = {
-        type: 'function',
-        name,
-        overloads: [],
-    };
-    let found = false;
-    for (const dialect of dialectMap.values()) {
-        const overloads = dialect.getGlobalFunctionDef(name);
-        if (overloads) {
-            for (const overload of overloads) {
-                let handled = false;
-                for (const existingOverload of func.overloads) {
-                    if (!paramsCompatible(overload, existingOverload)) {
-                        continue;
-                    }
-                    if (!paramsEqual(overload, existingOverload)) {
-                        throw new Error('params are compatible but not equal');
-                    }
-                    if (!returnEqual(overload, existingOverload)) {
-                        throw new Error('params match but return types differ!');
-                    }
-                    existingOverload.dialect[dialect.name] = {
-                        e: overload.e,
-                        supportsOrderBy: overload.supportsOrderBy,
-                        defaultOrderByArgIndex: overload.defaultOrderByArgIndex,
-                        supportsLimit: overload.supportsLimit,
-                    };
-                    handled = true;
-                }
-                if (!handled) {
-                    func.overloads.push({
-                        returnType: overload.returnType,
-                        params: overload.params,
-                        dialect: {
-                            [dialect.name]: {
-                                e: overload.e,
-                                supportsOrderBy: overload.supportsOrderBy,
-                                defaultOrderByArgIndex: overload.defaultOrderByArgIndex,
-                                supportsLimit: overload.supportsLimit,
-                            },
-                        },
-                        needsWindowOrderBy: overload.needsWindowOrderBy,
-                        between: overload.between,
-                        isSymmetric: overload.isSymmetric,
-                    });
-                }
-            }
-            found = true;
-        }
-    }
-    return found ? func : undefined;
-}
-exports.getDialectFunction = getDialectFunction;
 //# sourceMappingURL=dialect_map.js.map

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

@@ -0,0 +1,2 @@
+import { DefinitionBlueprintMap } from '../functions/util';
+export declare const DUCKDB_DIALECT_FUNCTIONS: DefinitionBlueprintMap;

package/dist/dialect/duckdb/dialect_functions.js

@@ -0,0 +1,67 @@
+"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.DUCKDB_DIALECT_FUNCTIONS = void 0;
+const to_timestamp = {
+    takes: { 'epoch_seconds': 'number' },
+    returns: 'timestamp',
+    impl: { function: 'TO_TIMESTAMP' },
+};
+const count_approx = {
+    takes: { 'value': { dimension: 'any' } },
+    returns: { measure: 'number' },
+    impl: { function: 'APPROX_COUNT_DISTINCT' },
+};
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            sql: 'STRING_AGG(${value}${order_by:})',
+            defaultOrderByArgIndex: 0,
+        },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            sql: 'STRING_AGG(${value}, ${separator}${order_by:})',
+            defaultOrderByArgIndex: 0,
+        },
+    },
+};
+const string_agg_distinct = {
+    default_separator: {
+        ...string_agg['default_separator'],
+        isSymmetric: true,
+        impl: {
+            sql: 'STRING_AGG(DISTINCT ${value}${order_by:})',
+            defaultOrderByArgIndex: 0,
+        },
+    },
+    with_separator: {
+        ...string_agg['with_separator'],
+        isSymmetric: true,
+        impl: {
+            sql: 'STRING_AGG(DISTINCT ${value}, ${separator}${order_by:})',
+            defaultOrderByArgIndex: 0,
+        },
+    },
+};
+exports.DUCKDB_DIALECT_FUNCTIONS = {
+    count_approx,
+    to_timestamp,
+    string_agg,
+    string_agg_distinct,
+};
+//# sourceMappingURL=dialect_functions.js.map

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

@@ -49,7 +49,9 @@ export declare class DuckDBDialect extends PostgresBase {
     sqlOrderBy(orderTerms: string[]): string;
     sqlLiteralString(literal: string): string;
     sqlLiteralRegexp(literal: string): string;
-    getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
+    getDialectFunctionOverrides(): {
+        [name: string]: DialectFunctionOverloadDef[];
+    };
     getDialectFunctions(): {
         [name: string]: DialectFunctionOverloadDef[];
     };

package/dist/dialect/duckdb/duckdb.js

@@ -25,10 +25,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBDialect = void 0;
 const malloy_types_1 = require("../../model/malloy_types");
 const utils_1 = require("../../model/utils");
-const functions_1 = require("./functions");
+const functions_1 = require("../functions");
 const dialect_1 = require("../dialect");
 const pg_impl_1 = require("../pg_impl");
-const dialect_functions_1 = require("./functions/dialect_functions");
+const dialect_functions_1 = require("./dialect_functions");
+const function_overrides_1 = require("./function_overrides");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
 const duckDBToMalloyTypes = {
@@ -261,11 +262,11 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
     sqlLiteralRegexp(literal) {
         return "'" + literal.replace(/'/g, "''") + "'";
     }
-    getGlobalFunctionDef(name) {
-        return functions_1.DUCKDB_FUNCTIONS.get(name);
+    getDialectFunctionOverrides() {
+        return (0, functions_1.expandOverrideMap)(function_overrides_1.DUCKDB_MALLOY_STANDARD_OVERLOADS);
     }
     getDialectFunctions() {
-        return dialect_functions_1.DUCKDB_DIALECT_FUNCTIONS;
+        return (0, functions_1.expandBlueprintMap)(dialect_functions_1.DUCKDB_DIALECT_FUNCTIONS);
     }
     malloyTypeToSQLType(malloyType) {
         if (malloyType.type === 'number') {

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

@@ -0,0 +1,2 @@
+import { MalloyStandardFunctionImplementations as OverrideMap } from '../functions/malloy_standard_functions';
+export declare const DUCKDB_MALLOY_STANDARD_OVERLOADS: OverrideMap;

package/dist/dialect/duckdb/function_overrides.js

@@ -0,0 +1,55 @@
+"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.DUCKDB_MALLOY_STANDARD_OVERLOADS = void 0;
+function greatestOrLeastSQL(name) {
+    return ('CASE' +
+        ' WHEN LEN(LIST_FILTER([${...values}], x -> x is null)) > 0' +
+        ' THEN NULL' +
+        ' ELSE ' +
+        name +
+        '(${...values})' +
+        ' END');
+}
+exports.DUCKDB_MALLOY_STANDARD_OVERLOADS = {
+    byte_length: { sql: '(BIT_LENGTH(${value}) / 8)' },
+    div: {
+        sql: 'CASE WHEN ${dividend} / ${divisor} < 0 THEN CEIL(${dividend} / ${divisor}) ELSE FLOOR(${dividend} / ${divisor}) END',
+    },
+    ends_with: { sql: 'COALESCE(SUFFIX(${value}, ${suffix}), false)' },
+    greatest: { sql: greatestOrLeastSQL('GREATEST') },
+    is_inf: { sql: 'COALESCE(ISINF(${value}), false)' },
+    is_nan: { sql: 'COALESCE(ISNAN(${value}), false)' },
+    // DuckDB doesn't seem to have a log with base function, so we use the change of base
+    // forumla to implement it.
+    log: { sql: '(LN(${value}) / LN(${base}))' },
+    least: { sql: greatestOrLeastSQL('LEAST') },
+    rand: { function: 'RANDOM' },
+    replace: {
+        // In DuckDB we specifically need to say that the replacement should be global.
+        regular_expression: {
+            sql: "REGEXP_REPLACE(${value}, ${pattern}, ${replacement}, 'g')",
+        },
+    },
+    // Trunc function doesn't exist in DuckDB, so we emulate it.
+    // For both overloads, we switch between CEIL and FLOOR based on the sign of the arugment
+    // For the overload with precision, we multiply by a power of 10 before rounding, then divide.
+    trunc: {
+        to_integer: {
+            sql: 'CASE WHEN ${value} < 0 THEN CEIL(${value}) ELSE FLOOR(${value}) END',
+        },
+        to_precision: {
+            sql: 'CASE WHEN ${value} < 0 THEN CEIL(${value} * POW(10, ${precision})) / POW(10, ${precision}) ELSE FLOOR(${value} * POW(10, ${precision})) / POW(10, ${precision}) END',
+        },
+    },
+    // In DuckDB, `UNICODE('')` gives -1, rather than 0.
+    unicode: {
+        sql: "CASE WHEN ${value} = '' THEN 0 ELSE UNICODE(${value}) END",
+    },
+};
+//# sourceMappingURL=function_overrides.js.map

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

@@ -1,2 +1,4 @@
 export type { DialectFunctionOverloadDef } from './util';
-export { FUNCTIONS } from './all_functions';
+export { expandBlueprintMap } from './util';
+export { getMalloyStandardFunctions, expandOverrideMap, } from './malloy_standard_functions';
+export type { MalloyStandardFunctionImplementations } from './malloy_standard_functions';

package/dist/dialect/functions/index.js

@@ -22,7 +22,10 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FUNCTIONS = void 0;
-var all_functions_1 = require("./all_functions");
-Object.defineProperty(exports, "FUNCTIONS", { enumerable: true, get: function () { return all_functions_1.FUNCTIONS; } });
+exports.expandOverrideMap = exports.getMalloyStandardFunctions = exports.expandBlueprintMap = void 0;
+var util_1 = require("./util");
+Object.defineProperty(exports, "expandBlueprintMap", { enumerable: true, get: function () { return util_1.expandBlueprintMap; } });
+var malloy_standard_functions_1 = require("./malloy_standard_functions");
+Object.defineProperty(exports, "getMalloyStandardFunctions", { enumerable: true, get: function () { return malloy_standard_functions_1.getMalloyStandardFunctions; } });
+Object.defineProperty(exports, "expandOverrideMap", { enumerable: true, get: function () { return malloy_standard_functions_1.expandOverrideMap; } });
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,134 @@
+import { DefinitionBlueprint, DialectFunctionOverloadDef, ImplementationBlueprint } from './util';
+type D = DefinitionBlueprint;
+type I = ImplementationBlueprint;
+type DefinitionsFor<T> = {
+    [key in keyof T]: D;
+};
+type ImplementationsFor<T> = {
+    [key in keyof T]?: I;
+};
+type DefinitionFor<T> = T extends D ? D : DefinitionsFor<T>;
+type ImplementationFor<T> = T extends D ? I : ImplementationsFor<T>;
+type DefinitionMap<T> = {
+    [key in keyof T]: DefinitionFor<T[key]>;
+};
+type ImplementationMap<T> = {
+    [key in keyof T]?: ImplementationFor<T[key]>;
+};
+type Standard = {
+    abs: D;
+    acos: D;
+    ascii: D;
+    asin: D;
+    atan2: D;
+    atan: D;
+    byte_length: D;
+    ceil: D;
+    chr: D;
+    coalesce: D;
+    concat: {
+        empty: D;
+        variadic: D;
+    };
+    cos: D;
+    div: D;
+    ends_with: D;
+    exp: D;
+    floor: D;
+    greatest: D;
+    ifnull: D;
+    is_inf: D;
+    is_nan: D;
+    least: D;
+    length: D;
+    ln: D;
+    log: D;
+    lower: D;
+    ltrim: {
+        whitespace: D;
+        characters: D;
+    };
+    nullif: D;
+    pi: D;
+    pow: D;
+    rand: D;
+    regexp_extract: D;
+    repeat: D;
+    replace: {
+        string: D;
+        regular_expression: D;
+    };
+    reverse: D;
+    round: {
+        to_integer: D;
+        to_precision: D;
+    };
+    rtrim: {
+        whitespace: D;
+        characters: D;
+    };
+    sign: D;
+    sin: D;
+    sqrt: D;
+    starts_with: D;
+    strpos: D;
+    substr: {
+        position_only: D;
+        with_length: D;
+    };
+    tan: D;
+    trim: {
+        whitespace: D;
+        characters: D;
+    };
+    trunc: {
+        to_integer: D;
+        to_precision: D;
+    };
+    unicode: D;
+    upper: D;
+    stddev: D;
+    avg_moving: {
+        preceding: D;
+        following: D;
+    };
+    first_value: D;
+    lag: {
+        bare: D;
+        with_offset: D;
+        with_default: D;
+    };
+    last_value: D;
+    lead: {
+        bare: D;
+        with_offset: D;
+        with_default: D;
+    };
+    max_cumulative: D;
+    max_window: D;
+    min_cumulative: D;
+    min_window: D;
+    rank: D;
+    row_number: D;
+    sum_cumulative: D;
+    sum_moving: {
+        preceding: D;
+        following: D;
+    };
+    sum_window: D;
+    sql_boolean: D;
+    sql_date: D;
+    sql_number: D;
+    sql_string: D;
+    sql_timestamp: D;
+};
+export type MalloyStandardFunctionDefinitions = DefinitionMap<Standard>;
+export type MalloyStandardFunctionImplementations = ImplementationMap<Standard>;
+export declare const MALLOY_STANDARD_FUNCTIONS: MalloyStandardFunctionDefinitions;
+export declare function getMalloyStandardFunctions(): {
+    [name: string]: DialectFunctionOverloadDef[];
+};
+export declare function expandOverrideMap(overrides: MalloyStandardFunctionImplementations): {
+    [name: string]: DialectFunctionOverloadDef[];
+};
+export {};