@abaplint/transpiler 2.1.44 → 2.1.47

package/build/src/statements/call_function.js

@@ -8,7 +8,7 @@ class CallFunctionTranspiler {
         var _a, _b;
         const fmname = (_a = node.findDirectExpression(abaplint.Expressions.FunctionName)) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase();
         if (fmname === undefined) {
-            throw "CallFunctionTranspilerNameNotFound";
+            throw new Error("CallFunctionTranspilerNameNotFound");
         }
         let param = "";
         const fmp = node.findDirectExpression(abaplint.Expressions.FunctionParameters);

package/build/src/statements/method_implementation.js

@@ -71,7 +71,7 @@ class MethodImplementationTranspiler {
                         }
                     }
                     else {
-                        throw "MethodImplementationTranspiler, unknown default param type";
+                        throw new Error("MethodImplementationTranspiler, unknown default param type");
                     }
                     after += "if (" + unique + " === undefined || " + unique + "." + varName + " === undefined) {" + varName + " = " + val + ";}\n";
                 }

package/build/src/statements/read_table.js

@@ -39,15 +39,18 @@ class ReadTableTranspiler {
         }
         const compare = node.findDirectExpression(abaplint.Expressions.ComponentCompareSimple);
         if (compare) {
-            const components = compare.findDirectExpressions(abaplint.Expressions.ComponentChainSimple);
-            const sources = compare.findDirectExpressions(abaplint.Expressions.Source);
-            if (components.length !== sources.length) {
-                throw new Error("READ TABLE, transpiler unexpected lengths");
-            }
             const conds = [];
-            for (let i = 0; i < components.length; i++) {
-                const s = traversal.traverse(sources[i]).getCode();
-                const field = components[i].concatTokens().toLowerCase().replace("-", ".get().");
+            const count = compare.getChildren().length / 3;
+            for (let i = 0; i < count; i++) {
+                const left = compare.getChildren()[i * 3];
+                const source = compare.getChildren()[(i * 3) + 2];
+                const s = traversal.traverse(source).getCode();
+                let field = left.concatTokens().toLowerCase().replace("-", ".get().");
+                if (left.get() instanceof abaplint.Expressions.Dynamic
+                    && left instanceof abaplint.Nodes.ExpressionNode) {
+                    const concat = left.concatTokens().toLowerCase();
+                    field = concat.substring(2, concat.length - 2);
+                }
                 if (s.includes("await")) {
                     const id = unique_identifier_1.UniqueIdentifier.get();
                     prefix += "const " + id + " = " + s + ";\n";

package/build/src/statements/select.d.ts

@@ -6,5 +6,7 @@ export declare class SelectTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal, targetOverride?: string): Chunk;
     private findKeys;
     private concatCond;
+    private sqlIn;
+    private basicCondition;
     private isWhereExpression;
 }

package/build/src/statements/select.js

@@ -96,12 +96,30 @@ class SelectTranspiler {
         return keys;
     }
     concatCond(cond, traversal) {
+        var _a;
         let ret = "";
         for (const c of cond.getChildren()) {
-            if (c.get() instanceof abaplint.Expressions.SimpleSource3
-                && c instanceof abaplint.Nodes.ExpressionNode
-                && c.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
-                ret += " '\" + " + new expressions_1.SimpleSource3Transpiler(true).transpile(c, traversal).getCode() + " + \"'";
+            if (c instanceof abaplint.Nodes.ExpressionNode
+                && c.get() instanceof abaplint.Expressions.SQLCompare) {
+                if (ret !== "") {
+                    ret += " ";
+                }
+                if (c.findDirectExpression(abaplint.Expressions.Dynamic)) {
+                    const chain = (_a = c.findDirectExpression(abaplint.Expressions.Dynamic)) === null || _a === void 0 ? void 0 : _a.findFirstExpression(abaplint.Expressions.FieldChain);
+                    if (chain) {
+                        const code = new expressions_1.FieldChainTranspiler(true).transpile(chain, traversal).getCode();
+                        ret += `" + ${code} + "`;
+                    }
+                    else {
+                        throw new Error("SQL Condition, transpiler todo, dyn cond, " + c.concatTokens());
+                    }
+                }
+                else if (c.findDirectExpression(abaplint.Expressions.SQLIn)) {
+                    ret += this.sqlIn(c, traversal);
+                }
+                else {
+                    ret += this.basicCondition(c, traversal);
+                }
             }
             else if (c instanceof abaplint.Nodes.ExpressionNode) {
                 ret += " " + this.concatCond(c, traversal);
@@ -112,6 +130,37 @@ class SelectTranspiler {
         }
         return ret.trim();
     }
+    sqlIn(c, _traversal) {
+        const fieldName = c.findDirectExpression(abaplint.Expressions.SQLFieldName);
+        const slqin = c.findDirectExpression(abaplint.Expressions.SQLIn);
+        const source = c.findFirstExpression(abaplint.Expressions.SimpleSource3);
+        if (fieldName === undefined || slqin === undefined || source === undefined) {
+            throw new Error("SQL Condition, transpiler todo, " + c.concatTokens());
+        }
+        const ret = `" + abap.expandIN("${fieldName.concatTokens()}", ${source.concatTokens()}) + "`;
+        return ret;
+    }
+    basicCondition(c, traversal) {
+        let ret = "";
+        if (c.getChildren().length !== 3) {
+            throw new Error("SQL Condition, transpiler todo, " + c.concatTokens() + ", " + c.getChildren().length);
+        }
+        const fieldName = c.findDirectExpression(abaplint.Expressions.SQLFieldName);
+        const operator = c.findDirectExpression(abaplint.Expressions.SQLCompareOperator);
+        const source = c.findDirectExpression(abaplint.Expressions.SQLSource);
+        if (fieldName === undefined || operator === undefined || source === undefined) {
+            throw new Error("SQL Condition, transpiler todo, " + c.concatTokens());
+        }
+        ret += fieldName.concatTokens() + " " + operator.concatTokens() + " ";
+        const simple = source.findDirectExpression(abaplint.Expressions.SimpleSource3);
+        if (simple && simple.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
+            ret += "'\" + " + new expressions_1.SimpleSource3Transpiler(true).transpile(simple, traversal).getCode() + " + \"'";
+        }
+        else {
+            ret += source.concatTokens();
+        }
+        return ret;
+    }
     isWhereExpression(node, expression) {
         // check if previous token before sqlCond is "WHERE". It could also be "ON" in case of join condition
         let prevToken;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.1.44",
+  "version": "2.1.47",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -28,7 +28,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.93.6",
+    "@abaplint/core": "^2.93.8",
     "source-map": "^0.7.4"
   },
   "devDependencies": {