@malloydata/malloy 0.0.225-dev241220203531 → 0.0.225-dev241221012915

package/dist/dialect/duckdb/dialect_functions.js

@@ -7,11 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DUCKDB_DIALECT_FUNCTIONS = void 0;
-const repeat = {
-    takes: { 'str': 'string', 'n': 'number' },
-    returns: 'string',
-    impl: { function: 'REPEAT' },
-};
+const util_1 = require("../functions/util");
 const list_extract = {
     takes: { 'value': { array: { generic: 'T' } }, 'index': 'number' },
     generic: { 'T': ['any'] },
@@ -90,10 +86,11 @@ exports.DUCKDB_DIALECT_FUNCTIONS = {
     count_approx,
     dayname,
     to_timestamp,
-    repeat,
     string_agg,
     string_agg_distinct,
     to_seconds,
     date_part,
+    ...(0, util_1.def)('repeat', { 'str': 'string', 'n': 'number' }, 'string'),
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
 };
 //# sourceMappingURL=dialect_functions.js.map

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

@@ -58,7 +58,6 @@ type Standard = {
         string: D;
         regular_expression: D;
     };
-    reverse: D;
     round: {
         to_integer: D;
         to_precision: D;

package/dist/dialect/functions/malloy_standard_functions.js

@@ -215,11 +215,6 @@ const replace = {
         impl: { function: 'REGEXP_REPLACE' },
     },
 };
-const reverse = {
-    takes: { 'value': 'string' },
-    returns: 'string',
-    impl: { function: 'REVERSE' },
-};
 const round = {
     'to_integer': {
         takes: { 'value': 'number' },
@@ -560,7 +555,6 @@ exports.MALLOY_STANDARD_FUNCTIONS = {
     rand,
     regexp_extract,
     replace,
-    reverse,
     round,
     rtrim,
     sign,

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

@@ -142,4 +142,27 @@ export declare function expandBlueprintMap(blueprints: DefinitionBlueprintMap):
 export declare function expandOverrideMapFromBase(base: DefinitionBlueprintMap, overrides: OverrideMap): {
     [name: string]: DialectFunctionOverloadDef[];
 };
+/**
+ * Shortcut for non overloaded functions definitions. Default implementation
+ * will be the function name turned to upper case. Default type for
+ * any generics encountered will be `['any']`. Both of these can be over-ridden
+ * in the `options` parameter.
+ *
+ * The two implict defaults (which can be over-ridden) are that the
+ * impl: will be the upper case version of the function name, and that
+ * any generic reference will be of type 'any'.
+ *
+ * USAGE:
+ *
+ *     ...def('func_name', {'arg0': 'type0', 'arg1': 'type1'}, 'return-type')
+ *
+ * @param name name of function
+ * @param takes Record<Argument blueprint>
+ * @param returns Return Blueprint
+ * @param options Everything from a `DefinitionBlueprint` except `takes` and `returns`
+ * @returns dot dot dot able blueprint definition
+ */
+export declare function def(name: string, takes: Record<string, TypeDescBlueprint>, returns: TypeDescBlueprint, options?: Partial<Omit<DefinitionBlueprint, 'takes' | 'returns'>>): {
+    [x: string]: DefinitionBlueprint;
+};
 export {};

package/dist/dialect/functions/util.js

@@ -23,7 +23,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.def = 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;
 const malloy_types_1 = require("../../model/malloy_types");
 function arg(name) {
     return { node: 'function_parameter', name };
@@ -471,4 +471,82 @@ function expandOverrideMapFromBase(base, overrides) {
     return map;
 }
 exports.expandOverrideMapFromBase = expandOverrideMapFromBase;
+/**
+ * Walks a type and returns all the generic references
+ * @param tdbp A type
+ */
+function* findGenerics(tdbp) {
+    if (typeof tdbp !== 'string') {
+        if ('generic' in tdbp) {
+            yield tdbp;
+        }
+        else if ('record' in tdbp) {
+            for (const recType of Object.values(tdbp.record)) {
+                yield* findGenerics(recType);
+            }
+        }
+        else {
+            for (const leaflet of [
+                'array',
+                'literal',
+                'measure',
+                'dimension',
+                'measure',
+                'constant',
+                'cacluation',
+            ]) {
+                if (leaflet in tdbp) {
+                    yield* findGenerics(tdbp[leaflet]);
+                    return;
+                }
+            }
+        }
+    }
+}
+/**
+ * Shortcut for non overloaded functions definitions. Default implementation
+ * will be the function name turned to upper case. Default type for
+ * any generics encountered will be `['any']`. Both of these can be over-ridden
+ * in the `options` parameter.
+ *
+ * The two implict defaults (which can be over-ridden) are that the
+ * impl: will be the upper case version of the function name, and that
+ * any generic reference will be of type 'any'.
+ *
+ * USAGE:
+ *
+ *     ...def('func_name', {'arg0': 'type0', 'arg1': 'type1'}, 'return-type')
+ *
+ * @param name name of function
+ * @param takes Record<Argument blueprint>
+ * @param returns Return Blueprint
+ * @param options Everything from a `DefinitionBlueprint` except `takes` and `returns`
+ * @returns dot dot dot able blueprint definition
+ */
+function def(name, takes, returns, options = {}) {
+    let anyGenerics = false;
+    const generic = {};
+    for (const argType of Object.values(takes)) {
+        for (const genericRef of findGenerics(argType)) {
+            generic[genericRef.generic] = ['any'];
+            anyGenerics = true;
+        }
+    }
+    // We have found all the generic references and given them all
+    // T: ['any']. Use this as a default if the options section
+    // doesn't provide types for the generics.
+    if (anyGenerics) {
+        if (options.generic === undefined) {
+            options.generic = generic;
+        }
+    }
+    const newDef = {
+        takes,
+        returns,
+        impl: { function: name.toUpperCase() },
+        ...options,
+    };
+    return { [name]: newDef };
+}
+exports.def = def;
 //# sourceMappingURL=util.js.map

package/dist/dialect/mysql/dialect_functions.js

@@ -7,11 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MYSQL_DIALECT_FUNCTIONS = void 0;
-const repeat = {
-    takes: { 'str': 'string', 'n': 'number' },
-    returns: 'string',
-    impl: { function: 'REPEAT' },
-};
+const util_1 = require("../functions/util");
 const string_agg = {
     default_separator: {
         takes: { 'value': { dimension: 'string' } },
@@ -52,6 +48,7 @@ const string_agg_distinct = {
 exports.MYSQL_DIALECT_FUNCTIONS = {
     string_agg,
     string_agg_distinct,
-    repeat,
+    ...(0, util_1.def)('repeat', { 'str': 'string', 'n': 'number' }, 'string'),
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/postgres/dialect_functions.js

@@ -7,11 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.POSTGRES_DIALECT_FUNCTIONS = void 0;
-const repeat = {
-    takes: { 'str': 'string', 'n': 'number' },
-    returns: 'string',
-    impl: { function: 'REPEAT' },
-};
+const util_1 = require("../functions/util");
 const string_agg = {
     default_separator: {
         takes: { 'value': { dimension: 'string' } },
@@ -52,6 +48,7 @@ const string_agg_distinct = {
 exports.POSTGRES_DIALECT_FUNCTIONS = {
     string_agg,
     string_agg_distinct,
-    repeat,
+    ...(0, util_1.def)('repeat', { 'str': 'string', 'n': 'number' }, 'string'),
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/snowflake/dialect_functions.js

@@ -8,11 +8,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SNOWFLAKE_DIALECT_FUNCTIONS = void 0;
 const util_1 = require("../functions/util");
-const repeat = {
-    takes: { 'str': 'string', 'n': 'number' },
-    returns: 'string',
-    impl: { function: 'REPEAT' },
-};
 const order_by = {
     node: 'aggregate_order_by',
     prefix: ' WITHIN GROUP(',
@@ -58,6 +53,7 @@ const string_agg_distinct = {
 exports.SNOWFLAKE_DIALECT_FUNCTIONS = {
     string_agg,
     string_agg_distinct,
-    repeat,
+    ...(0, util_1.def)('repeat', { 'str': 'string', 'n': 'number' }, 'string'),
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/standardsql/dialect_functions.js

@@ -7,11 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STANDARDSQL_DIALECT_FUNCTIONS = void 0;
-const repeat = {
-    takes: { 'str': 'string', 'n': 'number' },
-    returns: 'string',
-    impl: { function: 'REPEAT' },
-};
+const util_1 = require("../functions/util");
 const date_from_unix_date = {
     takes: { 'unix_date': 'number' },
     returns: 'date',
@@ -66,6 +62,7 @@ exports.STANDARDSQL_DIALECT_FUNCTIONS = {
     date_from_unix_date,
     string_agg,
     string_agg_distinct,
-    repeat,
+    ...(0, util_1.def)('repeat', { 'str': 'string', 'n': 'number' }, 'string'),
+    ...(0, util_1.def)('reverse', { 'str': 'string' }, 'string'),
 };
 //# sourceMappingURL=dialect_functions.js.map

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

@@ -1,3 +1,12 @@
 import { DefinitionBlueprintMap } from '../functions/util';
+/**
+ * This map is for functions which exist in both Presto and Trino.
+ * If you are adding functions which only exist in Presto, put them in
+ * to PRESTO_DIALECT_FUNCTIONS.
+ *
+ * If you have a function which works differently in each, add them to
+ * both.
+ */
 export declare const TRINO_DIALECT_FUNCTIONS: DefinitionBlueprintMap;
+/******** Presto Only *********/
 export declare const PRESTO_DIALECT_FUNCTIONS: DefinitionBlueprintMap;

package/dist/dialect/trino/dialect_functions.js

@@ -7,120 +7,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRESTO_DIALECT_FUNCTIONS = exports.TRINO_DIALECT_FUNCTIONS = void 0;
+const util_1 = require("../functions/util");
+/*
+ * We are experimenting with the best way to make this file easy for someone
+ * to step in and modify, AND to make it easy to create a new dialect.
+ *
+ * So in this file we are experimenting with various ways to define things.
+ * The most general and powerful is to write a DefinitionBlueprint or
+ * OverloadedDefinitionBlueprint, naming it with the name of the function
+ * you want to add, and then to add that name to the dialcect function list.
+ *
+ * Experimentally, there is also a function def which creates a
+ * DefinitionBlueprint for you. For simple blueprints, you can use the wrapper
+ * definition generator def(), and there are examples in this file
+ * of how to do that, and def() has some hover-documentation.
+ *
+ * It is an experiment so please let us know if you like def(),
+ * or if you prefer editing the Blueprint data structures.
+ */
+// Cute shortcut So you can write things like: {array: T} and {dimension: T}
 const T = { generic: 'T' };
 // Aggregate functions:
-// TODO: Approx percentile can be called with a third argument; we probably
-// want to implement that at some point
-// In Presto, this is an "error" parameter between 0 and 1
-// In Trino, this is a "weight" parameter between 1 and 99
-const approx_percentile = {
-    takes: { 'value': 'number', 'percentage': 'number' },
-    returns: { measure: 'number' },
-    impl: {
-        function: 'APPROX_PERCENTILE',
-    },
-};
-const arbitrary = {
-    generic: { 'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'] },
-    takes: { 'value': { dimension: T } },
-    returns: { measure: T },
-    impl: { function: 'ARBITRARY' },
-};
-const bitwise_and_agg = {
-    takes: { 'value': { dimension: 'number' } },
-    returns: { measure: 'number' },
-    impl: { function: 'BITWISE_OR_AGG' },
-};
-const bitwise_or_agg = {
-    takes: { 'value': { dimension: 'number' } },
-    returns: { measure: 'number' },
-    impl: { function: 'BITWISE_AND_AGG' },
-};
-const bitwise_xor_agg = {
-    takes: { 'value': { dimension: 'number' } },
-    returns: { measure: 'number' },
-    impl: { function: 'BITWISE_XOR_AGG' },
-};
-const bool_and = {
-    takes: { 'value': { dimension: 'boolean' } },
-    returns: { measure: 'boolean' },
-    impl: { function: 'BOOL_AND' },
-};
-const bool_or = {
-    takes: { 'value': { dimension: 'boolean' } },
-    returns: { measure: 'boolean' },
-    impl: { function: 'BOOL_OR' },
-};
-const corr = {
-    takes: { 'y': { dimension: 'number' }, 'x': { dimension: 'number' } },
-    returns: { measure: 'number' },
-    impl: {
-        sql: 'CORR(${y}, ${x})',
-    },
-};
-const count_approx = {
-    takes: { 'value': { dimension: 'any' } },
-    returns: { measure: 'number' },
-    impl: { function: 'APPROX_DISTINCT' },
-    isSymmetric: true,
-};
-const hll_accumulate = {
-    default: {
-        generic: {
-            'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
-        },
-        takes: { 'value': { dimension: { generic: 'T' } } },
-        returns: { measure: { sql_native: 'hyperloglog' } },
-        isSymmetric: true,
-        impl: {
-            function: 'APPROX_SET',
-        },
-    },
-    with_percent: {
-        generic: {
-            'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
-        },
-        takes: { 'value': { dimension: { generic: 'T' } }, 'accuracy': 'number' },
-        returns: { measure: { sql_native: 'hyperloglog' } },
-        isSymmetric: true,
-        impl: {
-            function: 'APPROX_SET',
-        },
-    },
-};
-const hll_combine = {
-    takes: {
-        'value': { sql_native: 'hyperloglog' },
-    },
-    returns: { measure: { sql_native: 'hyperloglog' } },
-    impl: { function: 'MERGE' },
-    isSymmetric: true,
-};
-const hll_estimate = {
-    takes: {
-        'value': { sql_native: 'hyperloglog' },
-    },
-    returns: { dimension: 'number' },
-    impl: { function: 'CARDINALITY' },
-};
-const hll_export = {
-    takes: {
-        'value': { sql_native: 'hyperloglog' },
-    },
-    returns: { dimension: { sql_native: 'varbinary' } },
-    impl: {
-        sql: 'CAST(${value} AS VARBINARY)',
-    },
-};
-const hll_import = {
-    takes: {
-        'value': { sql_native: 'varbinary' },
-    },
-    returns: { dimension: { sql_native: 'hyperloglog' } },
-    impl: {
-        sql: 'CAST(${value} AS HyperLogLog)',
-    },
-};
 const max_by = {
     generic: { 'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'] },
     takes: {
@@ -178,33 +85,7 @@ const string_agg_distinct = {
         },
     },
 };
-const variance = {
-    takes: { 'value': { dimension: 'number' } },
-    returns: { measure: 'number' },
-    impl: { function: 'VARIANCE' },
-};
 // Scalar functions
-const bitwise_and = {
-    takes: { 'val1': 'number', 'val2': 'number' },
-    returns: 'number',
-    impl: {
-        function: 'BITWISE_AND',
-    },
-};
-const bitwise_or = {
-    takes: { 'val1': 'number', 'val2': 'number' },
-    returns: 'number',
-    impl: {
-        function: 'BITWISE_OR',
-    },
-};
-const date_format = {
-    takes: { 'ts_val': 'timestamp', 'format': 'string' },
-    returns: 'string',
-    impl: {
-        function: 'DATE_FORMAT',
-    },
-};
 const date_parse = {
     takes: { 'ts_string': 'string', 'format': 'string' },
     returns: 'timestamp',
@@ -212,11 +93,6 @@ const date_parse = {
         sql: 'DATE_PARSE(${ts_string}, ${format})',
     },
 };
-const from_unixtime = {
-    takes: { 'unixtime': 'number' },
-    returns: 'timestamp',
-    impl: { function: 'FROM_UNIXTIME' },
-};
 // TODO: support Presto JSON types
 // eventually, this should take 'json_val': ['string', 'json']
 const json_extract_scalar = {
@@ -252,55 +128,15 @@ const regexp_replace = {
         },
     },
 };
-const to_unixtime = {
-    takes: { 'ts_val': 'timestamp' },
-    returns: 'number',
-    impl: { function: 'TO_UNIXTIME' },
-};
 const percent_rank = {
     takes: {},
     returns: { calculation: 'number' },
     impl: { function: 'PERCENT_RANK', needsWindowOrderBy: true },
 };
-const url_extract_fragment = {
-    takes: { 'url': 'string' },
-    returns: 'string',
-    impl: { function: 'URL_EXTRACT_FRAGMENT' },
-};
-const url_extract_host = {
-    takes: { 'url': 'string' },
-    returns: 'string',
-    impl: { function: 'URL_EXTRACT_HOST' },
-};
-const url_extract_parameter = {
-    takes: { 'url': 'string', 'parameter': 'string' },
-    returns: 'string',
-    impl: { function: 'URL_EXTRACT_PARAMETER' },
-};
-const url_extract_path = {
-    takes: { 'url': 'string' },
-    returns: 'string',
-    impl: { function: 'URL_EXTRACT_PATH' },
-};
-const url_extract_port = {
-    takes: { 'url': 'string' },
-    returns: 'number',
-    impl: { function: 'URL_EXTRACT_PORT' },
-};
-const url_extract_protocol = {
-    takes: { 'url': 'string' },
-    returns: 'string',
-    impl: { function: 'URL_EXTRACT_PROTOCOL' },
-};
-const url_extract_query = {
-    takes: { 'url': 'string' },
-    returns: 'string',
-    impl: { function: 'URL_EXTRACT_QUERY' },
-};
 const array_join = {
     skip_nulls: {
         takes: {
-            'theArray': { array: T },
+            'array_v': { array: T },
             'sep': 'string',
         },
         generic: { T: ['any'] },
@@ -309,7 +145,7 @@ const array_join = {
     },
     null_aware: {
         takes: {
-            'theArray': T,
+            'array_v': T,
             'sep': 'string',
             'nullStr': 'string',
         },
@@ -321,179 +157,189 @@ const array_join = {
 const sequence = {
     num_to_num: {
         takes: { 'start': 'number', 'stop': 'number' },
-        generic: { 'T': ['any'] },
         returns: { array: 'number' },
         impl: { function: 'SEQUENCE' },
     },
     num_to_num_step: {
         takes: { 'start': 'number', 'stop': 'number', 'step': 'number' },
-        generic: { 'T': ['any'] },
         returns: { array: 'number' },
         impl: { function: 'SEQUENCE' },
     },
     date_to_date: {
         takes: { 'start': 'date', 'stop': 'date' },
-        generic: { 'T': ['any'] },
         returns: { array: 'date' },
         impl: { function: 'SEQUENCE' },
     },
-    // mtoy todo document missing sequence
 };
+const string_reverse = {
+    takes: { 'str': 'string' },
+    returns: 'string',
+    impl: { sql: 'REVERSE(CAST(${str} AS VARCHAR))' },
+};
+/**
+ * This map is for functions which exist in both Presto and Trino.
+ * If you are adding functions which only exist in Presto, put them in
+ * to PRESTO_DIALECT_FUNCTIONS.
+ *
+ * If you have a function which works differently in each, add them to
+ * both.
+ */
 exports.TRINO_DIALECT_FUNCTIONS = {
+    // string functions
+    reverse: string_reverse,
     // aggregate functions
-    approx_percentile,
-    arbitrary,
-    bitwise_and_agg,
-    bitwise_or_agg,
-    bitwise_xor_agg,
-    bool_and,
-    bool_or,
-    corr,
-    count_approx,
-    hll_accumulate,
-    hll_combine,
+    // TODO: Approx percentile can be called with a third argument; we probably
+    // want to implement that at some point
+    // In Presto, this is an "error" parameter between 0 and 1
+    // In Trino, this is a "weight" parameter between 1 and 99
+    ...(0, util_1.def)('approx_percentile', { 'value': 'number', 'percentage': 'number' }, { measure: 'number' }),
+    ...(0, util_1.def)('arbitrary', { 'value': { dimension: T } }, { measure: T }, {
+        generic: {
+            'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+        },
+    }),
+    ...(0, util_1.def)('bitwise_and_agg', { 'value': { dimension: 'number' } }, { measure: 'number' }, { isSymmetric: true }),
+    ...(0, util_1.def)('bitwise_or_agg', { 'value': { dimension: 'number' } }, { measure: 'number' }, { isSymmetric: true }),
+    ...(0, util_1.def)('bitwise_xor_agg', { 'value': { dimension: 'number' } }, { measure: 'number' }, { isSymmetric: true }),
+    ...(0, util_1.def)('bool_and', { 'value': { dimension: 'boolean' } }, { measure: 'boolean' }),
+    ...(0, util_1.def)('bool_or', { 'value': { dimension: 'boolean' } }, { measure: 'boolean' }),
+    ...(0, util_1.def)('corr', { 'y': { dimension: 'number' }, 'x': { dimension: 'number' } }, { measure: 'number' }),
+    ...(0, util_1.def)('count_approx', { 'value': { dimension: 'any' } }, { measure: 'number' }, {
+        impl: { function: 'APPROX_DISTINCT' },
+        isSymmetric: true,
+    }),
+    hll_accumulate: {
+        default: {
+            takes: { 'value': { dimension: T } },
+            returns: { measure: { sql_native: 'hyperloglog' } },
+            generic: {
+                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+            },
+            isSymmetric: true,
+            impl: { function: 'APPROX_SET' },
+        },
+        with_percent: {
+            takes: { 'value': { dimension: T }, 'accuracy': 'number' },
+            returns: { measure: { sql_native: 'hyperloglog' } },
+            generic: {
+                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+            },
+            isSymmetric: true,
+            impl: { function: 'APPROX_SET' },
+        },
+    },
+    hll_combine: {
+        takes: { 'value': { sql_native: 'hyperloglog' } },
+        returns: { measure: { sql_native: 'hyperloglog' } },
+        impl: { function: 'MERGE' },
+        isSymmetric: true,
+    },
+    hll_estimate: {
+        takes: { 'value': { sql_native: 'hyperloglog' } },
+        returns: { dimension: 'number' },
+        impl: { function: 'CARDINALITY' },
+    },
+    hll_export: {
+        takes: { 'value': { sql_native: 'hyperloglog' } },
+        returns: { dimension: { sql_native: 'varbinary' } },
+        impl: { sql: 'CAST(${value} AS VARBINARY)' },
+    },
+    hll_import: {
+        takes: { 'value': { sql_native: 'varbinary' } },
+        returns: { dimension: { sql_native: 'hyperloglog' } },
+        impl: { sql: 'CAST(${value} AS HyperLogLog)' },
+    },
     max_by,
     min_by,
     string_agg,
     string_agg_distinct,
-    variance,
+    ...(0, util_1.def)('variance', { 'n': 'number' }, { measure: 'number' }),
     // scalar functions
-    bitwise_and,
-    bitwise_or,
-    date_format,
+    ...(0, util_1.def)('bitwise_and', { 'val1': 'number', 'val2': 'number' }, 'number'),
+    ...(0, util_1.def)('bitwise_or', { 'val1': 'number', 'val2': 'number' }, 'number'),
+    ...(0, util_1.def)('date_format', { 'ts_val': 'timestamp', 'format': 'string' }, 'string'),
     date_parse,
-    from_unixtime,
-    hll_estimate,
-    hll_export,
-    hll_import,
+    ...(0, util_1.def)('from_unixtime', { 'unixtime': 'number' }, 'timestamp'),
     json_extract_scalar,
     regexp_like,
     regexp_replace,
-    to_unixtime,
-    url_extract_fragment,
-    url_extract_host,
-    url_extract_parameter,
-    url_extract_path,
-    url_extract_port,
-    url_extract_protocol,
-    url_extract_query,
+    ...(0, util_1.def)('to_unixtime', { 'ts_val': 'timestamp' }, 'number'),
+    ...(0, util_1.def)('url_extract_fragment', { 'url': 'string' }, 'string'),
+    ...(0, util_1.def)('url_extract_host', { 'url': 'string' }, 'string'),
+    ...(0, util_1.def)('url_extract_parameter', { 'url': 'string', 'parameter': 'string' }, 'string'),
+    ...(0, util_1.def)('url_extract_path', { 'url': 'string' }, 'string'),
+    ...(0, util_1.def)('url_extract_port', { 'url': 'string' }, 'number'),
+    ...(0, util_1.def)('url_extract_protocol', { 'url': 'string' }, 'string'),
+    ...(0, util_1.def)('url_extract_query', { 'url': 'string' }, 'string'),
     // window functions
     percent_rank,
-    // array functions except those below
+    // array function
     array_join,
     sequence,
+    ...(0, util_1.def)('array_distinct', { 'x': { array: T } }, { array: T }),
+    ...(0, util_1.def)('array_except', { 'x': { array: T }, 'y': { array: T } }, { array: T }),
+    ...(0, util_1.def)('array_intersect', { 'x': { array: T }, 'y': { array: T } }, { array: T }),
+    ...(0, util_1.def)('array_max', { 'x': { array: T } }, T),
+    ...(0, util_1.def)('array_min', { 'x': { array: T } }, T),
+    ...(0, util_1.def)('array_normalize', { 'x': { array: T }, 'p': 'number' }, { array: T }),
+    ...(0, util_1.def)('array_remove', { 'x': { array: T }, 'element': T }, { array: T }),
+    ...(0, util_1.def)('array_sort', { 'x': { array: T } }, { array: T }),
+    ...(0, util_1.def)('arrays_overlap', { 'x': { array: T }, 'y': { array: T } }, 'boolean'),
+    ...(0, util_1.def)('array_union', { 'x': { array: T }, 'y': { array: T } }, { array: T }),
+    ...(0, util_1.def)('cardinality', { 'x': { array: T } }, 'number'),
+    ...(0, util_1.def)('shuffle', { 'x': { array: T } }, { array: T }),
+    ...(0, util_1.def)('combinations', { 'x': { array: T }, 'n': 'number' }, { array: { array: T } }),
+    ...(0, util_1.def)('contains', { 'x': { array: T }, 'element': T }, 'boolean'),
+    ...(0, util_1.def)('element_at', { 'x': { array: T }, 'oridnal': 'number' }, T),
+    ...(0, util_1.def)('flatten', { 'x': { array: { array: T } } }, { array: T }),
+    ...(0, util_1.def)('ngrams', { 'x': { array: T }, 'n': 'number' }, { array: { array: T } }),
+    ...(0, util_1.def)('repeat', { 'x': T, 'n': 'number' }, { array: T }),
+    ...(0, util_1.def)('slice', { 'x': { array: T }, 'start': 'number', 'len': 'number' }, { array: T }),
+    ...(0, util_1.def)('split', { to_split: 'string', seperator: 'string' }, { array: 'string' }),
+    ...(0, util_1.def)('trim_array', { 'x': { array: T }, 'n': 'number' }, { array: T }),
+    ...(0, util_1.def)('array_split_into_chunks', { 'x': { array: T }, 'n': 'number' }, { array: { array: T } }),
 };
-/**
- * Lazy function to add wrapper blueprint definition for non overloaded functions
- * which have generic array in their parameter list or return value
- * @param name function name
- * @param types list of types, last is return type
- */
-function define(name, takes, returns) {
-    const newDef = {
-        takes,
-        generic: { 'T': ['any'] },
-        returns,
-        impl: { function: name.toUpperCase() },
-    };
-    exports.TRINO_DIALECT_FUNCTIONS[name] = newDef;
-}
-define('array_distinct', { x: { array: T } }, { array: T });
-define('array_except', { x: { array: T }, y: { array: T } }, { array: T });
-define('array_intersect', { x: { array: T }, y: { array: T } }, { array: T });
-define('array_max', { x: { array: T } }, T);
-define('array_min', { x: { array: T } }, T);
-define('array_normalize', { x: { array: T }, p: 'number' }, { array: T });
-define('array_remove', { x: { array: T }, element: T }, { array: T });
-// mtoy todo document missing lambda sort
-define('array_sort', { x: { array: T } }, { array: T });
-define('array_split_into_chunks', { x: { array: T }, n: 'number' }, { array: { array: T } });
-define('arrays_overlap', { x: { array: T }, y: { array: T } }, 'boolean');
-define('array_union', { x: { array: T }, y: { array: T } }, { array: T });
-define('cardinality', { x: { array: T } }, 'number');
-// mtoy todo move overload version?
-// define('reverse', {x: {array: T}}, {array: T});
-define('shuffle', { x: { array: T } }, { array: T });
-define('combinations', { x: { array: T }, n: 'number' }, { array: { array: T } });
-define('contains', { x: { array: T }, element: T }, 'boolean');
-define('element_at', { x: { array: T }, oridnal: 'number' }, T);
-// hard to believe, but this is what flatten does
-define('flatten', { x: { array: { array: T } } }, { array: T });
-define('ngrams', { x: { array: T }, n: 'number' }, { array: { array: T } });
-define('repeat', { x: T, n: 'number' }, { array: T });
-define('slice', { x: { array: T }, start: 'number', len: 'number' }, { array: T });
-define('split', { to_split: 'string', seperator: 'string' }, { array: 'string' });
-define('trim_array', { x: { array: T }, n: 'number' }, { array: T });
 /******** Presto Only *********/
-const array_position = {
-    first_instance: {
-        takes: { x: { array: T }, el: T },
-        generic: { T: ['any'] },
-        returns: 'number',
-        impl: { function: 'ARRAY_POSITION' },
-    },
-    nth_instance: {
-        takes: { x: { array: T }, el: T, instance: 'number' },
-        generic: { T: ['any'] },
-        returns: 'number',
-        impl: { function: 'ARRAY_POSITION' },
-    },
-};
-const array_intersect = {
-    two_arrays: {
-        takes: {
-            'a': { array: T },
-            'b': { array: T },
+exports.PRESTO_DIALECT_FUNCTIONS = {
+    ...exports.TRINO_DIALECT_FUNCTIONS,
+    array_intersect: {
+        ...(0, util_1.def)('array_intersect', { 'x': { array: T }, 'y': { array: T } }, { array: T }),
+        nested_array: {
+            takes: { 'x': { array: { array: T } } },
+            generic: { 'T': ['any'] },
+            returns: { array: T },
+            impl: { function: 'ARRAY_INTERSECT' },
         },
-        generic: { 'T': ['any'] },
-        returns: { array: T },
-        impl: { function: 'ARRAY_INTERSECT' },
     },
-    nested_array: {
-        takes: { 'a': { array: { array: T } } },
-        generic: { 'T': ['any'] },
-        returns: { array: T },
-        impl: { function: 'ARRAY_INTERSECT' },
-    },
-};
-const array_least_frequent = {
-    array_only: {
-        takes: { 'theArray': { array: T } },
-        generic: { 'T': ['any'] },
-        returns: { array: T },
-        impl: { function: 'ARRAY_LEAST_FREQUENT' },
+    array_least_frequent: {
+        ...(0, util_1.def)('array_least_frequent', { 'x': { array: T } }, { array: T }),
+        bottom_n: {
+            takes: { 'array_v': { array: T }, 'n': 'number' },
+            returns: { array: T },
+            generic: { 'T': ['any'] },
+            impl: { function: 'ARRAY_LEAST_FREQUENT' },
+        },
     },
-    bottom: {
-        takes: {
-            'theArray': { array: T },
-            'count': 'number',
+    array_position: {
+        ...(0, util_1.def)('array_position', { 'x': { array: T }, 'el': T }, 'number'),
+        nth_instance: {
+            takes: { 'x': { array: T }, 'el': T, 'instance': 'number' },
+            generic: { 'T': ['any'] },
+            returns: 'number',
+            impl: { function: 'ARRAY_POSITION' },
         },
-        generic: { 'T': ['any'] },
-        returns: { array: T },
-        impl: { function: 'ARRAY_LEAST_FREQUENT' },
     },
-};
-function def(name, takes, returns) {
-    const newDef = {
-        takes,
-        generic: { 'T': ['any'] },
-        returns,
-        impl: { function: name.toUpperCase() },
-    };
-    return { [name]: newDef };
-}
-exports.PRESTO_DIALECT_FUNCTIONS = {
-    ...exports.TRINO_DIALECT_FUNCTIONS,
-    array_intersect,
-    array_least_frequent,
-    array_position,
-    ...def('array_average', { x: { array: T } }, 'number'),
-    ...def('array_has_duplicates', { x: { array: T } }, 'boolean'),
-    ...def('array_cum_sum', { numeric_array: { array: T } }, { array: 'number' }),
-    ...def('array_duplicates', { x: { array: T } }, { array: T }),
-    ...def('array_sum', { x: { array: T } }, 'number'),
-    ...def('array_sort_desc', { x: { array: T } }, { array: T }),
-    ...def('remove_nulls', { x: { array: T } }, { array: T }),
-    ...def('array_top_n', { x: { array: T }, n: 'number' }, { array: T }),
+    reverse: {
+        string_reverse,
+        ...(0, util_1.def)('reverse', { 'x': { array: T } }, { array: T }),
+    },
+    ...(0, util_1.def)('array_average', { 'x': { array: T } }, 'number'),
+    ...(0, util_1.def)('array_has_duplicates', { 'x': { array: T } }, 'boolean'),
+    ...(0, util_1.def)('array_cum_sum', { numeric_array: { array: T } }, { array: 'number' }),
+    ...(0, util_1.def)('array_duplicates', { 'x': { array: T } }, { array: T }),
+    ...(0, util_1.def)('array_sum', { 'x': { array: T } }, 'number'),
+    ...(0, util_1.def)('array_sort_desc', { 'x': { array: T } }, { array: T }),
+    ...(0, util_1.def)('remove_nulls', { 'x': { array: T } }, { array: T }),
+    ...(0, util_1.def)('array_top_n', { 'x': { array: T }, 'n': 'number' }, { array: T }),
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/dialect/trino/function_overrides.js

@@ -28,9 +28,6 @@ exports.TRINO_MALLOY_STANDARD_OVERLOADS = {
     string_repeat: {
         sql: "ARRAY_JOIN(REPEAT(${value}, CASE WHEN ${value} IS NOT NULL THEN ${count} END),'')",
     },
-    reverse: {
-        sql: 'REVERSE(CAST(${value} AS VARCHAR))',
-    },
     starts_with: { sql: 'COALESCE(STARTS_WITH(${value}, ${prefix}), false)' },
     ends_with: {
         sql: 'COALESCE(STARTS_WITH(REVERSE(CAST(${value} AS VARCHAR)), REVERSE(CAST(${suffix} AS VARCHAR))), false)',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.225-dev241220203531",
+  "version": "0.0.225-dev241221012915",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",