@malloydata/malloy 0.0.182-dev240911142514 → 0.0.182-dev240911163224

package/dist/dialect/functions/util.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overload = exports.minAnalytic = exports.minAggregate = exports.minScalar = exports.maxAnalytic = exports.maxUngroupedAggregate = exports.anyExprType = exports.maxAggregate = exports.maxScalar = exports.makeParam = exports.param = exports.params = exports.literal = exports.output = exports.constant = exports.sql = exports.spread = exports.arg = void 0;
+exports.expandOverrideMapFromBase = exports.expandBlueprintMap = exports.overload = exports.minAnalytic = exports.minAggregate = exports.minScalar = exports.maxAnalytic = exports.maxUngroupedAggregate = exports.anyExprType = exports.maxAggregate = exports.maxScalar = exports.makeParam = exports.param = exports.variadicParam = exports.literal = exports.output = exports.constant = exports.sql = exports.spread = exports.arg = void 0;
 function arg(name) {
     return { node: 'function_parameter', name };
 }
@@ -80,14 +80,14 @@ function literal(type) {
     };
 }
 exports.literal = literal;
-function params(name, ...allowedTypes) {
+function variadicParam(name, ...allowedTypes) {
     return {
         name,
         isVariadic: true,
         allowedTypes,
     };
 }
-exports.params = params;
+exports.variadicParam = variadicParam;
 /**
  * Prefer `makeParam` for future function definitions
  */
@@ -181,4 +181,258 @@ function overload(returnType, params, e, options) {
     };
 }
 exports.overload = overload;
+function removeGeneric(type, generic) {
+    if (typeof type === 'string') {
+        return type;
+    }
+    if (type.generic !== (generic === null || generic === void 0 ? void 0 : generic.name)) {
+        throw new Error(`Cannot expand generic name ${type.generic}`);
+    }
+    return generic.type;
+}
+function expandReturnTypeBlueprint(blueprint, generic) {
+    if (typeof blueprint === 'string') {
+        return minScalar(blueprint);
+    }
+    else if ('generic' in blueprint) {
+        return minScalar(removeGeneric(blueprint, generic));
+    }
+    else if ('literal' in blueprint) {
+        return literal(minScalar(removeGeneric(blueprint.literal, generic)));
+    }
+    else if ('constant' in blueprint) {
+        return constant(minScalar(removeGeneric(blueprint.constant, generic)));
+    }
+    else if ('dimension' in blueprint) {
+        return minScalar(removeGeneric(blueprint.dimension, generic));
+    }
+    else if ('measure' in blueprint) {
+        return minAggregate(removeGeneric(blueprint.measure, generic));
+    }
+    else {
+        return minAnalytic(removeGeneric(blueprint.calculation, generic));
+    }
+}
+function isTypeDescBlueprint(blueprint) {
+    return (typeof blueprint === 'string' ||
+        'generic' in blueprint ||
+        'literal' in blueprint ||
+        'constant' in blueprint ||
+        'dimension' in blueprint ||
+        'measure' in blueprint ||
+        'calculation' in blueprint);
+}
+function extractParamTypeBlueprints(blueprint) {
+    if (isTypeDescBlueprint(blueprint)) {
+        return [blueprint];
+    }
+    else if (Array.isArray(blueprint)) {
+        return blueprint;
+    }
+    else if (isTypeDescBlueprint(blueprint.variadic)) {
+        return [blueprint.variadic];
+    }
+    else {
+        return blueprint.variadic;
+    }
+}
+function expandParamTypeBlueprint(blueprint, generic) {
+    if (typeof blueprint === 'string') {
+        return anyExprType(blueprint);
+    }
+    else if ('generic' in blueprint) {
+        return anyExprType(removeGeneric(blueprint, generic));
+    }
+    else if ('literal' in blueprint) {
+        return literal(maxScalar(removeGeneric(blueprint.literal, generic)));
+    }
+    else if ('constant' in blueprint) {
+        return constant(maxScalar(removeGeneric(blueprint.constant, generic)));
+    }
+    else if ('dimension' in blueprint) {
+        return maxScalar(removeGeneric(blueprint.dimension, generic));
+    }
+    else if ('measure' in blueprint) {
+        return maxAggregate(removeGeneric(blueprint.measure, generic));
+    }
+    else {
+        return maxAnalytic(removeGeneric(blueprint.calculation, generic));
+    }
+}
+function expandParamTypeBlueprints(blueprints, generic) {
+    return blueprints.map(blueprint => expandParamTypeBlueprint(blueprint, generic));
+}
+function isVariadicParamBlueprint(blueprint) {
+    return typeof blueprint !== 'string' && 'variadic' in blueprint;
+}
+function expandParamBlueprint(name, blueprint, generic) {
+    return {
+        name,
+        allowedTypes: expandParamTypeBlueprints(extractParamTypeBlueprints(blueprint), generic),
+        isVariadic: isVariadicParamBlueprint(blueprint),
+    };
+}
+function expandParamsBlueprints(blueprints, generic) {
+    const paramsArray = Object.entries(blueprints);
+    return paramsArray.map(blueprint => expandParamBlueprint(blueprint[0], blueprint[1], generic));
+}
+function expandBlueprintSqlInterpolation(sql) {
+    const src = [];
+    const args = [];
+    let current = sql;
+    while (current.length > 0) {
+        const start = current.indexOf('${');
+        if (start === -1) {
+            src.push(current);
+            break;
+        }
+        const left = current.slice(0, start);
+        current = current.slice(start);
+        const end = current.indexOf('}');
+        if (end === -1) {
+            src.push(left + current);
+            break;
+        }
+        const arg = current.slice(2, end);
+        current = current.slice(end + 1);
+        const isSpread = arg.startsWith('...');
+        const isSpecial = arg.endsWith(':');
+        const name = isSpread ? arg.slice(3) : isSpecial ? arg.slice(0, -1) : arg;
+        const param = { node: 'function_parameter', name };
+        src.push(left);
+        // TODO validate that there is a param with this name?
+        if (isSpread) {
+            args.push({ node: 'spread', e: param, prefix: '', suffix: '' });
+        }
+        else if (isSpecial && name === 'order_by') {
+            args.push({ node: 'aggregate_order_by' });
+        }
+        else if (isSpecial && name === 'limit') {
+            args.push({ node: 'aggregate_limit' });
+        }
+        else {
+            args.push(param);
+        }
+    }
+    const node = {
+        node: 'genericSQLExpr',
+        kids: { args },
+        src,
+    };
+    return node;
+}
+function makeParamReplacement(name, blueprint) {
+    if (isVariadicParamBlueprint(blueprint)) {
+        return {
+            node: 'spread',
+            e: { node: 'function_parameter', name },
+            prefix: '',
+            suffix: '',
+        };
+    }
+    return { node: 'function_parameter', name };
+}
+function expandBlueprintFunction(name, blueprint) {
+    const takesArray = Object.entries(blueprint.takes);
+    const numCommas = takesArray.length > 0 ? takesArray.length - 1 : 0;
+    return {
+        node: 'genericSQLExpr',
+        kids: {
+            args: takesArray.map(param => makeParamReplacement(param[0], param[1])),
+        },
+        src: [`${name}(`, ...Array(numCommas).fill(','), ')'],
+    };
+}
+function expendImplExprBlueprint(blueprint) {
+    if ('sql' in blueprint.impl) {
+        return expandBlueprintSqlInterpolation(blueprint.impl.sql);
+    }
+    else if ('expr' in blueprint.impl) {
+        return blueprint.impl.expr;
+    }
+    else {
+        return expandBlueprintFunction(blueprint.impl.function, blueprint);
+    }
+}
+function expandImplBlueprint(blueprint) {
+    return {
+        e: expendImplExprBlueprint(blueprint),
+        between: blueprint.impl.between,
+        needsWindowOrderBy: blueprint.impl.needsWindowOrderBy,
+        defaultOrderByArgIndex: blueprint.impl.defaultOrderByArgIndex,
+    };
+}
+function expandOneBlueprint(blueprint, generic) {
+    return {
+        returnType: expandReturnTypeBlueprint(blueprint.returns, generic),
+        params: expandParamsBlueprints(blueprint.takes, generic),
+        isSymmetric: blueprint.isSymmetric,
+        supportsOrderBy: blueprint.supportsOrderBy,
+        supportsLimit: blueprint.supportsLimit,
+        ...expandImplBlueprint(blueprint),
+    };
+}
+function expandBlueprint(blueprint) {
+    if (blueprint.generic !== undefined) {
+        const name = blueprint.generic[0];
+        return blueprint.generic[1].map(type => expandOneBlueprint(blueprint, { name, type }));
+    }
+    return [expandOneBlueprint(blueprint)];
+}
+function isDefinitionBlueprint(blueprint) {
+    return 'takes' in blueprint && 'returns' in blueprint && 'impl' in blueprint;
+}
+function isImplementationBlueprint(blueprint) {
+    return 'function' in blueprint || 'sql' in blueprint || 'expr' in blueprint;
+}
+function expandOverloadedBlueprint(blueprint) {
+    if (isDefinitionBlueprint(blueprint)) {
+        return expandBlueprint(blueprint);
+    }
+    else {
+        return Object.values(blueprint).flatMap(overload => expandBlueprint(overload));
+    }
+}
+function expandBlueprintMap(blueprints) {
+    const map = {};
+    for (const name in blueprints) {
+        map[name] = expandOverloadedBlueprint(blueprints[name]);
+    }
+    return map;
+}
+exports.expandBlueprintMap = expandBlueprintMap;
+function expandImplementationBlueprint(base, impl) {
+    return expandBlueprint({ ...base, impl });
+}
+function expandOverloadedOverrideBlueprint(name, base, blueprint) {
+    if (isImplementationBlueprint(blueprint)) {
+        if (!isDefinitionBlueprint(base)) {
+            throw new Error(`Malformed function override: ${name}. Attempt to override multiple overloads with a single overload (missing: ${Object.keys(base)})`);
+        }
+        return expandImplementationBlueprint(base, blueprint);
+    }
+    else {
+        if (isDefinitionBlueprint(base)) {
+            throw new Error(`Malformed function override: ${name}. Attempt to override a single overload with multiple overloads (extraneous: ${Object.keys(blueprint)})`);
+        }
+        return Object.entries(blueprint).flatMap(([overloadName, overload]) => {
+            const baseOverload = base[overloadName];
+            if (baseOverload === undefined) {
+                throw new Error(`Malformed function override: ${name}. No overload named ${overloadName}`);
+            }
+            return expandImplementationBlueprint(baseOverload, overload);
+        });
+    }
+}
+function expandOverrideMapFromBase(base, overrides) {
+    const map = {};
+    for (const name in overrides) {
+        if (!(name in base)) {
+            throw new Error(`Malformed function override: ${name}. No such function in Malloy standard`);
+        }
+        map[name] = expandOverloadedOverrideBlueprint(name, base[name], overrides[name]);
+    }
+    return map;
+}
+exports.expandOverrideMapFromBase = expandOverrideMapFromBase;
 //# sourceMappingURL=util.js.map

package/dist/dialect/index.d.ts

@@ -1,5 +1,5 @@
-export type { DialectFunctionOverloadDef } from './functions/util';
-export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, param, params, literal, sql, } from './functions/util';
+export type { DialectFunctionOverloadDef, DefinitionBlueprint, DefinitionBlueprintMap, OverloadedDefinitionBlueprint, } from './functions/util';
+export { arg, anyExprType, makeParam, overload, minScalar, minAggregate, maxScalar, spread, param, variadicParam, literal, sql, } from './functions/util';
 export { Dialect, qtz } from './dialect';
 export type { DialectFieldList, QueryInfo } from './dialect';
 export { StandardSQLDialect } from './standardsql';
@@ -7,5 +7,6 @@ export { PostgresDialect } from './postgres';
 export { DuckDBDialect } from './duckdb';
 export { SnowflakeDialect } from './snowflake';
 export { TrinoDialect } from './trino';
-export { getDialect, registerDialect, getDialectFunction } from './dialect_map';
-export { FUNCTIONS } from './functions';
+export { getDialect, registerDialect } from './dialect_map';
+export { getMalloyStandardFunctions } from './functions';
+export type { MalloyStandardFunctionImplementations } from './functions';

package/dist/dialect/index.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+exports.getMalloyStandardFunctions = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.variadicParam = exports.param = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
 var util_1 = require("./functions/util");
 Object.defineProperty(exports, "arg", { enumerable: true, get: function () { return util_1.arg; } });
 Object.defineProperty(exports, "anyExprType", { enumerable: true, get: function () { return util_1.anyExprType; } });
@@ -33,7 +33,7 @@ Object.defineProperty(exports, "minAggregate", { enumerable: true, get: function
 Object.defineProperty(exports, "maxScalar", { enumerable: true, get: function () { return util_1.maxScalar; } });
 Object.defineProperty(exports, "spread", { enumerable: true, get: function () { return util_1.spread; } });
 Object.defineProperty(exports, "param", { enumerable: true, get: function () { return util_1.param; } });
-Object.defineProperty(exports, "params", { enumerable: true, get: function () { return util_1.params; } });
+Object.defineProperty(exports, "variadicParam", { enumerable: true, get: function () { return util_1.variadicParam; } });
 Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return util_1.literal; } });
 Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return util_1.sql; } });
 var dialect_1 = require("./dialect");
@@ -52,7 +52,6 @@ Object.defineProperty(exports, "TrinoDialect", { enumerable: true, get: function
 var dialect_map_1 = require("./dialect_map");
 Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return dialect_map_1.getDialect; } });
 Object.defineProperty(exports, "registerDialect", { enumerable: true, get: function () { return dialect_map_1.registerDialect; } });
-Object.defineProperty(exports, "getDialectFunction", { enumerable: true, get: function () { return dialect_map_1.getDialectFunction; } });
 var functions_1 = require("./functions");
-Object.defineProperty(exports, "FUNCTIONS", { enumerable: true, get: function () { return functions_1.FUNCTIONS; } });
+Object.defineProperty(exports, "getMalloyStandardFunctions", { enumerable: true, get: function () { return functions_1.getMalloyStandardFunctions; } });
 //# sourceMappingURL=index.js.map

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

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

package/dist/dialect/postgres/dialect_functions.js

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

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

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

package/dist/dialect/postgres/function_overrides.js

@@ -0,0 +1,73 @@
+"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.POSTGRES_MALLOY_STANDARD_OVERLOADS = void 0;
+function greatestOrLeastSQL(name) {
+    return ('CASE WHEN NUM_NULLS(${...values}) > 0 THEN NULL ELSE ' +
+        name +
+        '(${...values}) END');
+}
+exports.POSTGRES_MALLOY_STANDARD_OVERLOADS = {
+    byte_length: { function: 'OCTET_LENGTH' },
+    // There's no ENDS_WITH function in Postgres, so we do a hacky check that the last
+    // N characters, where N is the length of the suffix, are equal to the suffix.
+    ends_with: {
+        sql: 'COALESCE(RIGHT(${value}, LENGTH(${suffix})) = ${suffix}, false)',
+    },
+    greatest: { sql: greatestOrLeastSQL('GREATEST') },
+    least: { sql: greatestOrLeastSQL('LEAST') },
+    // Postgres doesn't have an IFNULL function, so we use COALESCE, which is equivalent.
+    ifnull: { sql: 'COALESCE(${value}, ${default})' },
+    is_inf: {
+        sql: "COALESCE(${value} = DOUBLE PRECISION 'Infinity' OR ${value} = DOUBLE PRECISION '-Infinity', false)",
+    },
+    is_nan: { sql: "COALESCE(${value} = NUMERIC 'NaN', false)" },
+    // Parameter order is backwards in Postgres.
+    log: { sql: 'LOG(${base}, ${value})' },
+    rand: { function: 'RANDOM' },
+    regexp_extract: { function: 'SUBSTRING' },
+    replace: {
+        // In Postgres we specifically need to say that the replacement should be global.
+        regular_expression: {
+            sql: "REGEXP_REPLACE(${value}, ${pattern}, ${replacement}, 'g')",
+        },
+    },
+    // Postgres doesn't let you ROUND a FLOAT to a particular number of decimal places,
+    // so we cast to NUMERIC first...
+    // TODO it would be nice not to have to do this cast if it was already NUMERIC type...
+    round: {
+        to_integer: { sql: 'ROUND((${value})::NUMERIC)' },
+        to_precision: { sql: 'ROUND((${value})::NUMERIC, ${precision})' },
+    },
+    // TODO this is a bit of a hack in order to make the arrayAggUnnest work for Postgres,
+    // as we don't currently have a good way of doing this while preserving types
+    stddev: { sql: 'STDDEV(${value}::DOUBLE PRECISION)' },
+    substr: {
+        position_only: {
+            sql: 'SUBSTR(${value}, CASE WHEN ${position} < 0 THEN LENGTH(${value}) + ${position} + 1 ELSE ${position} END)',
+        },
+        with_length: {
+            sql: 'SUBSTR(${value}, CASE WHEN ${position} < 0 THEN LENGTH(${value}) + ${position} + 1 ELSE ${position} END, ${length})',
+        },
+    },
+    // Postgres doesn't let you TRUNC a FLOAT with a precision, so we cast to NUMERIC first
+    // Also, TRUNC(NULL) doesn't compile because PG doesn't know the type of NULL, so we cast to
+    // NUMERIC there too...
+    // TODO Maybe there's a way we don't have to cast to NUMERIC.
+    trunc: {
+        to_integer: {
+            sql: 'TRUNC(${value}::NUMERIC)',
+        },
+        to_precision: {
+            sql: 'TRUNC((${value}::NUMERIC), ${precision})',
+        },
+    },
+    // Aparently the ASCII function also works for unicode code points...
+    unicode: { function: 'ASCII' },
+};
+//# sourceMappingURL=function_overrides.js.map

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

@@ -20,7 +20,6 @@ export declare class PostgresDialect extends PostgresBase {
     supportsSafeCast: boolean;
     dontUnionIndex: boolean;
     supportsQualify: boolean;
-    globalFunctions: import("../functions/function_map").FunctionMap;
     supportsNesting: boolean;
     experimental: boolean;
     readsNestedData: boolean;
@@ -53,7 +52,9 @@ export declare class PostgresDialect 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/postgres/postgres.js

@@ -25,9 +25,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDialect = void 0;
 const utils_1 = require("../../model/utils");
 const malloy_types_1 = require("../../model/malloy_types");
-const functions_1 = require("./functions");
+const functions_1 = require("../functions");
 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");
 const pgMakeIntervalMap = {
     'year': 'years',
     'month': 'months',
@@ -88,7 +89,6 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
         this.supportsSafeCast = false;
         this.dontUnionIndex = false;
         this.supportsQualify = false;
-        this.globalFunctions = functions_1.POSTGRES_FUNCTIONS;
         this.supportsNesting = true;
         this.experimental = false;
         this.readsNestedData = false;
@@ -319,11 +319,11 @@ class PostgresDialect extends pg_impl_1.PostgresBase {
     sqlLiteralRegexp(literal) {
         return "'" + literal.replace(/'/g, "''") + "'";
     }
-    getGlobalFunctionDef(name) {
-        return functions_1.POSTGRES_FUNCTIONS.get(name);
+    getDialectFunctionOverrides() {
+        return (0, functions_1.expandOverrideMap)(function_overrides_1.POSTGRES_MALLOY_STANDARD_OVERLOADS);
     }
     getDialectFunctions() {
-        return dialect_functions_1.POSTGRES_DIALECT_FUNCTIONS;
+        return (0, functions_1.expandBlueprintMap)(dialect_functions_1.POSTGRES_DIALECT_FUNCTIONS);
     }
     malloyTypeToSQLType(malloyType) {
         if (malloyType.type === 'number') {

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

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

package/dist/dialect/snowflake/dialect_functions.js

@@ -0,0 +1,57 @@
+"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.SNOWFLAKE_DIALECT_FUNCTIONS = void 0;
+const util_1 = require("../functions/util");
+const order_by = {
+    node: 'aggregate_order_by',
+    prefix: ' WITHIN GROUP(',
+    suffix: ')',
+};
+const string_agg = {
+    default_separator: {
+        takes: { 'value': { dimension: 'string' } },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `LISTAGG(${(0, util_1.arg)('value')}, ',')${order_by}`,
+        },
+    },
+    with_separator: {
+        takes: {
+            'value': { dimension: 'string' },
+            'separator': { literal: 'string' },
+        },
+        returns: { measure: 'string' },
+        supportsOrderBy: true,
+        impl: {
+            expr: (0, util_1.sql) `LISTAGG(${(0, util_1.arg)('value')}, ${(0, util_1.arg)('separator')})${order_by}`,
+        },
+    },
+};
+const string_agg_distinct = {
+    default_separator: {
+        ...string_agg['default_separator'],
+        isSymmetric: true,
+        impl: {
+            expr: (0, util_1.sql) `LISTAGG(DISTINCT ${(0, util_1.arg)('value')}, ',')${order_by}`,
+        },
+    },
+    with_separator: {
+        ...string_agg['with_separator'],
+        isSymmetric: true,
+        impl: {
+            expr: (0, util_1.sql) `LISTAGG(DISTINCT ${(0, util_1.arg)('value')}, ${(0, util_1.arg)('separator')})${order_by}`,
+        },
+    },
+};
+exports.SNOWFLAKE_DIALECT_FUNCTIONS = {
+    string_agg,
+    string_agg_distinct,
+};
+//# sourceMappingURL=dialect_functions.js.map

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

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

package/dist/dialect/snowflake/function_overrides.js

@@ -0,0 +1,39 @@
+"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.SNOWFLAKE_MALLOY_STANDARD_OVERLOADS = void 0;
+exports.SNOWFLAKE_MALLOY_STANDARD_OVERLOADS = {
+    // Need to explicitly have a case for when the arg is 0, to return ''
+    chr: { sql: "COALESCE(CHR(${value}), '')" },
+    // in Snowflake division is always a float division, so we need this conversion
+    div: {
+        sql: 'CASE WHEN DIV0(${dividend}, ${divisor}) < 0 THEN CEIL(DIV0(${dividend}, ${divisor})) ELSE FLOOR(DIV0(${dividend}, ${divisor})) END',
+    },
+    is_inf: {
+        sql: "COALESCE(${value} = 'inf'::FLOAT OR ${value} = '-inf'::FLOAT, false)",
+    },
+    is_nan: { sql: "COALESCE(${value} = 'NAN'::FLOAT, false)" },
+    length: { function: 'LENGTH' },
+    byte_length: { sql: 'CEIL(BIT_LENGTH(${value}) / 8)' },
+    // Snowflake takes base first, then value.
+    log: { sql: 'LOG(${base}, ${value})' },
+    rand: { sql: 'UNIFORM(0::FLOAT, 1::FLOAT, RANDOM())' },
+    regexp_extract: { sql: "REGEXP_SUBSTR(${value}, ${pattern}, 1, 1, 'e')" },
+    starts_with: { sql: 'COALESCE(STARTSWITH(${value}, ${prefix}), false)' },
+    ends_with: { sql: 'COALESCE(ENDSWITH(${value}, ${suffix}), false)' },
+    strpos: { sql: 'POSITION(${search_string}, ${test_string})' },
+    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',
+        },
+    },
+};
+//# sourceMappingURL=function_overrides.js.map

package/dist/dialect/snowflake/snowflake.d.ts

@@ -15,7 +15,6 @@ export declare class SnowflakeDialect extends Dialect {
     defaultSampling: {
         rows: number;
     };
-    globalFunctions: import("../functions/function_map").FunctionMap;
     unnestWithNumbers: boolean;
     supportUnnestArrayAgg: boolean;
     supportsAggDistinct: boolean;
@@ -57,7 +56,9 @@ export declare class SnowflakeDialect extends Dialect {
     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[];
     };