@malloydata/malloy 0.0.177-dev240828173040 → 0.0.177-dev240829030921

package/dist/model/utils.js

@@ -22,8 +22,9 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.range = exports.joinWith = exports.exprWalk = exports.exprMap = exports.generateHash = exports.AndChain = exports.generateSQLStringLiteral = exports.indent = void 0;
+exports.composeSQLExpr = exports.exprMap = exports.exprWalk = exports.exprKids = exports.range = exports.joinWith = exports.generateHash = exports.AndChain = exports.generateSQLStringLiteral = exports.indent = void 0;
 const uuid_1 = require("uuid");
+const malloy_types_1 = require("./malloy_types");
 /** simple indent function */
 function indent(s) {
     const re = /(^|\n)/g;
@@ -97,224 +98,6 @@ function generateHash(input) {
     return (0, uuid_1.v5)(input, MALLOY_UUID);
 }
 exports.generateHash = generateHash;
-function exprMap(expr, func) {
-    return expr.flatMap(fragment => {
-        const mapped = func(fragment);
-        return mapped.map(fragment => {
-            if (typeof fragment === 'string') {
-                return fragment;
-            }
-            switch (fragment.type) {
-                case 'aggregate':
-                case 'all':
-                case 'spread':
-                case 'sql_expression':
-                case 'exclude':
-                    return {
-                        ...fragment,
-                        e: exprMap(fragment.e, func),
-                    };
-                case 'apply':
-                    return {
-                        ...fragment,
-                        to: exprMap(fragment.to, func),
-                        value: exprMap(fragment.value, func),
-                    };
-                case 'applyVal':
-                case 'field':
-                case 'function_parameter':
-                case 'parameter':
-                case 'outputField':
-                case 'source-reference':
-                case 'aggregate_limit':
-                case 'aggregate_order_by':
-                    return fragment;
-                case 'sql-string':
-                    return {
-                        ...fragment,
-                        e: exprMap(fragment.e, func),
-                    };
-                case 'function_call':
-                    return {
-                        ...fragment,
-                        args: fragment.args.map(arg => exprMap(arg, func)),
-                    };
-                case 'filterExpression':
-                    return {
-                        ...fragment,
-                        e: exprMap(fragment.e, func),
-                        filterList: fragment.filterList.map(filter => {
-                            return {
-                                ...filter,
-                                expression: exprMap(filter.expression, func),
-                            };
-                        }),
-                    };
-                case 'dialect': {
-                    switch (fragment.function) {
-                        case 'cast':
-                        case 'regexpMatch':
-                            return {
-                                ...fragment,
-                                expr: exprMap(fragment.expr, func),
-                            };
-                        case 'delta':
-                            return {
-                                ...fragment,
-                                delta: exprMap(fragment.delta, func),
-                            };
-                        case 'div':
-                            return {
-                                ...fragment,
-                                denominator: exprMap(fragment.denominator, func),
-                                numerator: exprMap(fragment.numerator, func),
-                            };
-                        case 'now':
-                        case 'numberLiteral':
-                        case 'stringLiteral':
-                        case 'timeLiteral':
-                        case 'regexpLiteral':
-                            return fragment;
-                        case 'extract':
-                        case 'trunc':
-                            return {
-                                ...fragment,
-                                expr: {
-                                    ...fragment.expr,
-                                    value: exprMap(fragment.expr.value, func),
-                                },
-                            };
-                        case 'timeDiff':
-                            return {
-                                ...fragment,
-                                left: {
-                                    ...fragment.left,
-                                    value: exprMap(fragment.left.value, func),
-                                },
-                                right: {
-                                    ...fragment.right,
-                                    value: exprMap(fragment.right.value, func),
-                                },
-                            };
-                        default:
-                            throw new Error('unexpected dialect function');
-                    }
-                }
-                default:
-                    throw new Error('unexpected');
-            }
-        });
-    });
-}
-exports.exprMap = exprMap;
-function exprWalk(expr, func) {
-    expr.forEach(fragment => {
-        func(fragment);
-        if (typeof fragment === 'string') {
-            return fragment;
-        }
-        switch (fragment.type) {
-            case 'aggregate':
-            case 'all':
-            case 'spread':
-            case 'sql_expression':
-            case 'exclude':
-                return {
-                    ...fragment,
-                    e: exprWalk(fragment.e, func),
-                };
-            case 'apply':
-                return {
-                    ...fragment,
-                    to: exprWalk(fragment.to, func),
-                    value: exprWalk(fragment.value, func),
-                };
-            case 'applyVal':
-            case 'field':
-            case 'function_parameter':
-            case 'parameter':
-            case 'outputField':
-            case 'source-reference':
-            case 'aggregate_limit':
-            case 'aggregate_order_by':
-                return fragment;
-            case 'function_call':
-                return {
-                    ...fragment,
-                    args: fragment.args.map(arg => exprWalk(arg, func)),
-                };
-            case 'sql-string':
-                return {
-                    ...fragment,
-                    e: exprWalk(fragment.e, func),
-                };
-            case 'filterExpression':
-                return {
-                    ...fragment,
-                    e: exprWalk(fragment.e, func),
-                    filterList: fragment.filterList.map(filter => {
-                        return {
-                            ...filter,
-                            expression: exprWalk(filter.expression, func),
-                        };
-                    }),
-                };
-            case 'dialect': {
-                switch (fragment.function) {
-                    case 'cast':
-                    case 'regexpMatch':
-                        return {
-                            ...fragment,
-                            expr: exprWalk(fragment.expr, func),
-                        };
-                    case 'delta':
-                        return {
-                            ...fragment,
-                            delta: exprWalk(fragment.delta, func),
-                        };
-                    case 'div':
-                        return {
-                            ...fragment,
-                            denominator: exprWalk(fragment.denominator, func),
-                            numerator: exprWalk(fragment.numerator, func),
-                        };
-                    case 'now':
-                    case 'numberLiteral':
-                    case 'stringLiteral':
-                    case 'timeLiteral':
-                    case 'regexpLiteral':
-                        return fragment;
-                    case 'extract':
-                    case 'trunc':
-                        return {
-                            ...fragment,
-                            expr: {
-                                ...fragment.expr,
-                                value: exprWalk(fragment.expr.value, func),
-                            },
-                        };
-                    case 'timeDiff':
-                        return {
-                            ...fragment,
-                            left: {
-                                ...fragment.left,
-                                value: exprWalk(fragment.left.value, func),
-                            },
-                            right: {
-                                ...fragment.right,
-                                value: exprWalk(fragment.right.value, func),
-                            },
-                        };
-                    default:
-                        throw new Error('unexpected dialect function');
-                }
-            }
-            default:
-                throw new Error(`unexpected fragment type ${fragment.type}`);
-        }
-    });
-}
-exports.exprWalk = exprWalk;
 function joinWith(els, sep) {
     const result = [];
     for (let i = 0; i < els.length; i++) {
@@ -330,4 +113,86 @@ function range(start, end) {
     return Array.from({ length: end - start }, (_, index) => index + start);
 }
 exports.range = range;
+function* exprKids(eNode) {
+    if ((0, malloy_types_1.exprHasKids)(eNode)) {
+        for (const kidEnt of Object.values(eNode.kids)) {
+            if (Array.isArray(kidEnt)) {
+                yield* kidEnt;
+            }
+            else {
+                yield kidEnt;
+            }
+        }
+    }
+    else if ((0, malloy_types_1.exprHasE)(eNode)) {
+        yield eNode.e;
+    }
+}
+exports.exprKids = exprKids;
+function* exprWalk(eNode, order = 'post') {
+    if (order === 'pre') {
+        yield eNode;
+    }
+    for (const kid of exprKids(eNode)) {
+        yield* exprWalk(kid, order);
+    }
+    if (order === 'post') {
+        yield eNode;
+    }
+}
+exports.exprWalk = exprWalk;
+function exprMap(eNode, mapFunc) {
+    let mapExpr = { ...eNode };
+    if ((0, malloy_types_1.exprHasKids)(eNode)) {
+        const parentNode = { ...eNode };
+        parentNode.kids = {};
+        for (const [name, kidEnt] of Object.entries(eNode.kids)) {
+            if (Array.isArray(kidEnt)) {
+                parentNode.kids[name] = kidEnt.map(kidEl => mapFunc(kidEl));
+            }
+            else {
+                parentNode.kids[name] = mapFunc(kidEnt);
+            }
+        }
+        mapExpr = parentNode;
+    }
+    if ((0, malloy_types_1.exprHasE)(mapExpr)) {
+        mapExpr.e = mapFunc(mapExpr.e);
+    }
+    return mapFunc(mapExpr);
+}
+exports.exprMap = exprMap;
+/**
+ * Take a mixed array of strings and Expr and turn it into an SQLExpr
+ * expression node.
+ */
+function composeSQLExpr(from) {
+    const ret = {
+        node: 'genericSQLExpr',
+        kids: { args: [] },
+        src: [],
+    };
+    // Build the array of alternating strings and expressions
+    let lastWasString = false;
+    for (const el of from) {
+        if (typeof el === 'string') {
+            if (lastWasString) {
+                ret.src[ret.src.length - 1] += el;
+            }
+            else {
+                ret.src.push(el);
+            }
+            lastWasString = true;
+        }
+        else {
+            if (!lastWasString) {
+                ret.src.push('');
+            }
+            ret.kids.args.push(el);
+            lastWasString = false;
+        }
+    }
+    return ret;
+}
+exports.composeSQLExpr = composeSQLExpr;
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.177-dev240828173040",
+  "version": "0.0.177-dev240829030921",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",

package/dist/lang/ast/types/comparison.d.ts

@@ -1,11 +0,0 @@
-export declare enum Comparison {
-    Like = "~",
-    NotLike = "!~",
-    LessThan = "<",
-    LessThanOrEqualTo = "<=",
-    EqualTo = "=",
-    GreaterThan = ">",
-    GreaterThanOrEqualTo = ">=",
-    NotEqualTo = "!="
-}
-export declare function isComparison(s: string): s is Comparison;

package/dist/lang/ast/types/comparison.js

@@ -1,41 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isComparison = exports.Comparison = void 0;
-var Comparison;
-(function (Comparison) {
-    Comparison["Like"] = "~";
-    Comparison["NotLike"] = "!~";
-    Comparison["LessThan"] = "<";
-    Comparison["LessThanOrEqualTo"] = "<=";
-    Comparison["EqualTo"] = "=";
-    Comparison["GreaterThan"] = ">";
-    Comparison["GreaterThanOrEqualTo"] = ">=";
-    Comparison["NotEqualTo"] = "!=";
-})(Comparison || (exports.Comparison = Comparison = {}));
-function isComparison(s) {
-    return Object.values(Comparison).includes(s);
-}
-exports.isComparison = isComparison;
-//# sourceMappingURL=comparison.js.map

package/dist/lang/ast/types/equality.d.ts

@@ -1,7 +0,0 @@
-export declare enum Equality {
-    Like = "~",
-    NotLike = "!~",
-    Equals = "=",
-    NotEquals = "!="
-}
-export declare function isEquality(s: string): s is Equality;

package/dist/lang/ast/types/equality.js

@@ -1,37 +0,0 @@
-"use strict";
-/*
- * Copyright 2023 Google LLC
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEquality = exports.Equality = void 0;
-var Equality;
-(function (Equality) {
-    Equality["Like"] = "~";
-    Equality["NotLike"] = "!~";
-    Equality["Equals"] = "=";
-    Equality["NotEquals"] = "!=";
-})(Equality || (exports.Equality = Equality = {}));
-function isEquality(s) {
-    return Object.values(Equality).includes(s);
-}
-exports.isEquality = isEquality;
-//# sourceMappingURL=equality.js.map