@malloydata/malloy 0.0.183-dev240913195502 → 0.0.183-dev240917170343

package/dist/dialect/duckdb/dialect_functions.js

@@ -7,6 +7,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DUCKDB_DIALECT_FUNCTIONS = void 0;
+const dayname = {
+    takes: { 'date_value': ['date', 'timestamp'] },
+    returns: 'string',
+    impl: { function: 'DAYNAME' },
+};
 const to_timestamp = {
     takes: { 'epoch_seconds': 'number' },
     returns: 'timestamp',
@@ -60,6 +65,7 @@ const string_agg_distinct = {
 };
 exports.DUCKDB_DIALECT_FUNCTIONS = {
     count_approx,
+    dayname,
     to_timestamp,
     string_agg,
     string_agg_distinct,

package/dist/dialect/trino/dialect_functions.js

@@ -7,16 +7,79 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRINO_DIALECT_FUNCTIONS = void 0;
-const from_unixtime = {
-    takes: { 'unixtime': 'number' },
-    returns: 'timestamp',
-    impl: { function: 'FROM_UNIXTIME' },
+// 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: { generic: 'T' } } },
+    returns: { measure: { generic: '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' },
 };
+const max_by = {
+    generic: ['T', ['string', 'number', 'date', 'timestamp', 'boolean', 'json']],
+    takes: {
+        'value': { dimension: { generic: 'T' } },
+        'order_by_val': { dimension: 'any' },
+    },
+    returns: { measure: { generic: 'T' } },
+    impl: { function: 'MAX_BY' },
+};
+const min_by = {
+    generic: ['T', ['string', 'number', 'date', 'timestamp', 'boolean', 'json']],
+    takes: {
+        'value': { dimension: { generic: 'T' } },
+        'order_by_val': { dimension: 'any' },
+    },
+    returns: { measure: { generic: 'T' } },
+    impl: { function: 'MIN_BY' },
+};
 const string_agg = {
     default_separator: {
         takes: { 'value': { dimension: 'string' } },
@@ -54,10 +117,110 @@ 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',
+    impl: {
+        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 = {
+    takes: { 'json_val': 'string', 'json_path': 'string' },
+    returns: 'string',
+    impl: { function: 'JSON_EXTRACT_SCALAR' },
+};
+const regexp_like = {
+    takes: { 'str': 'string', 'pattern': ['string', 'regular expression'] },
+    returns: 'boolean',
+    impl: { function: 'REGEXP_LIKE' },
+};
+const regexp_replace = {
+    remove_matches: {
+        takes: {
+            'input_val': 'string',
+            'regexp_pattern': ['string', 'regular expression'],
+        },
+        returns: 'string',
+        impl: {
+            function: 'REGEXP_REPLACE',
+        },
+    },
+    replace_matches: {
+        takes: {
+            'input_val': 'string',
+            'regexp_pattern': ['string', 'regular expression'],
+            'replacement': 'string',
+        },
+        returns: 'string',
+        impl: {
+            function: 'REGEXP_REPLACE',
+        },
+    },
+};
+const to_unixtime = {
+    takes: { 'ts_val': 'timestamp' },
+    returns: 'number',
+    impl: { function: 'TO_UNIXTIME' },
+};
 exports.TRINO_DIALECT_FUNCTIONS = {
+    // aggregate functions
+    approx_percentile,
+    arbitrary,
+    bitwise_and_agg,
+    bitwise_or_agg,
+    bitwise_xor_agg,
+    bool_and,
+    bool_or,
+    corr,
     count_approx,
-    from_unixtime,
+    max_by,
+    min_by,
     string_agg,
     string_agg_distinct,
+    variance,
+    // scalar functions
+    bitwise_and,
+    bitwise_or,
+    date_format,
+    date_parse,
+    from_unixtime,
+    json_extract_scalar,
+    regexp_like,
+    regexp_replace,
+    to_unixtime,
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/lang/ast/types/expression-def.js

@@ -263,8 +263,13 @@ function equality(fs, left, op, right) {
             case '~':
             case '!~': {
                 if (lhs.dataType !== 'string' || rhs.dataType !== 'string') {
-                    const regexCmp = regexEqual(lhs, rhs);
-                    if (regexCmp === undefined) {
+                    let regexCmp = regexEqual(lhs, rhs);
+                    if (regexCmp) {
+                        if (op[0] === '!') {
+                            regexCmp = { node: 'not', e: { ...regexCmp } };
+                        }
+                    }
+                    else {
                         throw new TypeMismatch("Incompatible types for match('~') operator");
                     }
                     value = regexCmp;

package/dist/lang/test/expressions.spec.js

@@ -112,6 +112,12 @@ describe('expressions', () => {
         test('not match', () => {
             expect("'forty-two' !~ 'fifty-four'").compilesTo('{"forty-two" !like "fifty-four"}');
         });
+        test('regexp-match', () => {
+            expect("'forty-two' ~ r'fifty-four'").compilesTo('{"forty-two" regex-match /fifty-four/}');
+        });
+        test('not regexp-match', () => {
+            expect("'forty-two' !~ r'fifty-four'").compilesTo('{not {"forty-two" regex-match /fifty-four/}}');
+        });
         test('apply as equality', () => {
             expect("'forty-two' ? 'fifty-four'").compilesTo('{"forty-two" = "fifty-four"}');
         });

package/dist/lang/test/parse-expects.js

@@ -161,6 +161,8 @@ function eToStr(e, symbols) {
             return `"${e.literal}"`;
         case 'timeLiteral':
             return `@${e.literal}`;
+        case 'regexpLiteral':
+            return `/${e.literal}/`;
         case 'trunc':
             return `{timeTrunc-${e.units} ${subExpr(e.e)}}`;
         case 'delta':
@@ -168,6 +170,8 @@ function eToStr(e, symbols) {
         case 'true':
         case 'false':
             return e.node;
+        case 'regexpMatch':
+            return `{${subExpr(e.kids.expr)} regex-match ${subExpr(e.kids.regex)}}`;
     }
     if ((0, model_1.exprHasKids)(e) && e.kids['left'] && e.kids['right']) {
         return `{${subExpr(e.kids['left'])} ${e.node} ${subExpr(e.kids['right'])}}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.183-dev240913195502",
+  "version": "0.0.183-dev240917170343",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",