@abaplint/transpiler 2.13.95 → 2.13.97

package/build/src/statements/select.js

@@ -102,6 +102,12 @@ class SelectTranspiler {
         if (groupBy) {
             select += new sql_group_by_1.SQLGroupByTranspiler().transpile(groupBy, traversal).getCode() + " ";
         }
+        const having = node.findDirectExpression(abaplint.Expressions.Select)
+            ?.findDirectExpression(abaplint.Expressions.SQLHaving);
+        const havingCond = having?.findFirstExpression(abaplint.Expressions.SQLCond);
+        if (havingCond) {
+            select += "HAVING " + new expressions_1.SQLCondTranspiler().transpile(havingCond, traversal, table).getCode() + " ";
+        }
         const upTo = node.findFirstExpression(abaplint.Expressions.SQLUpTo);
         if (upTo) {
             const s = upTo.findFirstExpression(abaplint.Expressions.SimpleSource3);
@@ -168,26 +174,85 @@ class SelectTranspiler {
             const faeTranspiled = new expressions_1.SQLSourceTranspiler().transpile(fn, traversal).getCode();
             // ABAP semantics: with an empty driving table the whole WHERE condition is ignored
             const selectEmpty = select.replace(whereClause, "");
-            select = select.replace(new RegExp(" " + escapeRegExp(faeTranspiled), "g"), " " + unique);
-            select = select.replace(unique + ".get().table_line.get()", unique + ".get()"); // there can be only one?
+            const bindRow = (text) => text
+                .replace(new RegExp(" " + escapeRegExp(faeTranspiled), "g"), " " + unique)
+                .replace(unique + ".get().table_line.get()", unique + ".get()"); // there can be only one?
+            select = bindRow(select);
+            const where = bindRow(whereClause);
             // FOR ALL ENTRIES removes duplicate rows from the result: duplicates of
             // the selected columns, so de-duplicate by the target's components. The
             // DB key alone is wrong for projections (INTO CORRESPONDING FIELDS
             // without the key fields crashed on the missing component names)
             const by = `Object.keys(${target}.getRowType().get())`;
+            // generated code is not indented, Chunk.runIndentationLogic indents by brace depth
+            const dedup = `if (!(${target} instanceof abap.types.HashedTable) && ${target}.getOptions()?.primaryKey?.type !== "SORTED") {
+abap.statements.sort(${target}, {by: ${by}.map(k => { return {component: k}; })});
+await abap.statements.deleteInternal(${target}, {adjacent: true, allFields: true});
+}`;
+            const at = where.startsWith("WHERE ") ? select.indexOf(where) : -1;
+            // UP TO with ORDER BY keeps the first n rows in that order; the blocks
+            // trim after the de-duplicating sort, so that pair stays row by row
+            if (concat.startsWith("SELECT SINGLE ") || at < 0 || (upTo && orderBy)) {
+                const code = `if (${faeTranspiled}.array().length === 0) {
+await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
+} else {
+const ${unique2} = ${faeTranspiled}.array();
+${target}.clear();
+for await (const ${unique} of ${unique2}) {
+await abap.statements.select(${target}, {select: "${select.trim()}"${extra}}, {appending: true});
+}
+${dedup}
+abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
+}`;
+                return new chunk_1.Chunk().append(code, node, traversal);
+            }
+            // One SELECT per block of driving rows, similar to the kernel's blocking
+            // of FOR ALL ENTRIES (rsdb/max_blocking_factor): the condition of each row in
+            // parentheses, joined with OR. Not one SELECT per row. UP TO n ROWS
+            // counts the whole de-duplicated result, not each block (measured on
+            // a 7.5x system: two driving rows and UP TO 3 give 3 rows).
+            let tail = select.substring(at + where.length);
+            let upToCode = "0";
+            if (upTo) {
+                const s = upTo.findFirstExpression(abaplint.Expressions.SimpleSource3);
+                if (s) {
+                    const n = new expressions_1.SourceTranspiler(true).transpile(s, traversal).getCode();
+                    tail = tail.replace(`UP TO " + ${n} + " ROWS `, "");
+                    upToCode = `parseInt(${n}, 10)`;
+                }
+                else {
+                    tail = tail.replace(upTo.concatTokens() + " ", "");
+                    upToCode = String(parseInt(upTo.findFirstExpression(abaplint.Expressions.Integer)?.concatTokens() ?? "0", 10));
+                }
+            }
+            const head = select.substring(0, at);
+            const condition = where.substring("WHERE ".length).trimEnd();
+            const unique3 = unique_identifier_1.UniqueIdentifier.get();
+            const unique4 = unique_identifier_1.UniqueIdentifier.get();
             const code = `if (${faeTranspiled}.array().length === 0) {
-  await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
+await abap.statements.select(${target}, {select: "${selectEmpty.trim()}"${extra}});
+} else {
+const ${unique2} = ${faeTranspiled}.array();
+${target}.clear();
+const ${unique3} = (${unique}) => "(${condition})";
+for (let ${unique4} = 0; ${unique4} < ${unique2}.length; ${unique4} += 50) {
+const ${unique4}where = ${unique2}.slice(${unique4}, ${unique4} + 50).map(${unique3}).join(" OR ");
+await abap.statements.select(${target}, {select: "${head}WHERE " + ${unique4}where + " ${tail.trim()}"${extra}}, {appending: true});
+}
+${dedup}
+const ${unique4}max = ${upToCode};
+if (${unique4}max > 0 && ${target}.getArrayLength() > ${unique4}max) {
+if (${target} instanceof abap.types.HashedTable) {
+for (const ${unique4}row of ${target}.array().slice(${unique4}max)) {
+await abap.statements.deleteInternal(${target}, {fromValue: ${unique4}row});
+}
 } else {
-  const ${unique2} = ${faeTranspiled}.array();
-  ${target}.clear();
-  for await (const ${unique} of ${unique2}) {
-    await abap.statements.select(${target}, {select: "${select.trim()}"${extra}}, {appending: true});
-  }
-  if (!(${target} instanceof abap.types.HashedTable) && ${target}.getOptions()?.primaryKey?.type !== "SORTED") {
-    abap.statements.sort(${target}, {by: ${by}.map(k => { return {component: k}; })});
-    await abap.statements.deleteInternal(${target}, {adjacent: true, allFields: true});
-  }
-  abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
+while (${target}.getArrayLength() > ${unique4}max) {
+${target}.deleteIndex(${target}.getArrayLength() - 1);
+}
+}
+}
+abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
 }`;
             return new chunk_1.Chunk().append(code, node, traversal);
         }

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SelectOptionTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/select_option.js

@@ -1,10 +1,71 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectOptionTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
+const transpile_types_1 = require("../transpile_types");
+const _selection_1 = require("./_selection");
 class SelectOptionTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("SelectOption, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const variable = _selection_1.SelectionDefault.variable(node, traversal);
+        const row = variable?.type instanceof abaplint.BasicTypes.TableType ? variable.type.getRowType() : undefined;
+        const lowType = row instanceof abaplint.BasicTypes.StructureType ? row.getComponentByName("LOW") : undefined;
+        if (variable === undefined || lowType === undefined) {
+            // eg. FOR (dynamic)
+            return new chunk_1.Chunk(`throw new Error("SelectOption, not supported, transpiler");`);
+        }
+        const { name, type } = variable;
+        const ret = new chunk_1.Chunk().appendString("let " + name + " = " + transpile_types_1.TranspileTypes.toType(type) + ";");
+        // DEFAULT low [TO high] [OPTION o] [SIGN s] is the first row of the table and
+        // stays in the header line: I EQ, or I BT with TO, unless OPTION or SIGN say otherwise
+        const low = _selection_1.SelectionDefault.after(node, "DEFAULT");
+        if (low === undefined) {
+            return ret;
+        }
+        const high = _selection_1.SelectionDefault.after(node, "TO");
+        const option = _selection_1.SelectionDefault.after(node, "OPTION")?.concatTokens().toUpperCase() ?? (high ? "BT" : "EQ");
+        const sign = _selection_1.SelectionDefault.after(node, "SIGN")?.concatTokens().toUpperCase() ?? "I";
+        ret.appendString("\n" + name + ".get().sign.set('" + sign + "');");
+        ret.appendString("\n" + name + ".get().option.set('" + option + "');");
+        ret.appendString(_selection_1.SelectionDefault.set(node, name + ".get().low", lowType, low, traversal));
+        if (high) {
+            ret.appendString(_selection_1.SelectionDefault.set(node, name + ".get().high", lowType, high, traversal));
+        }
+        ret.appendString("\nabap.statements.append({source: " + name + "});");
+        return ret;
     }
 }
 exports.SelectOptionTranspiler = SelectOptionTranspiler;

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SetDatasetTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/set_dataset.js

@@ -2,9 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SetDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class SetDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("SetDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const option = operands.after("POSITION") !== undefined
+            ? "position: " + operands.after("POSITION")
+            : "endOfFile: true";
+        return new chunk_1.Chunk()
+            .append("await abap.statements.setDataset(", node, traversal)
+            .appendString(operands.first() + ", {" + option + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.SetDatasetTranspiler = SetDatasetTranspiler;

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

@@ -4,5 +4,7 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SortTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private isDynamicName;
+    private dynamicName;
     private findNextText;
 }

package/build/src/statements/sort.js

@@ -40,7 +40,8 @@ const expressions_1 = require("../expressions");
 class SortTranspiler {
     transpile(node, traversal) {
         const concat = node.concatTokens().toUpperCase();
-        const components = node.findDirectExpressions(abaplint.Expressions.ComponentChain);
+        const components = node.getChildren().filter(c => c instanceof abaplint.Nodes.ExpressionNode
+            && (c.get() instanceof abaplint.Expressions.ComponentChain || this.isDynamicName(c, traversal)));
         const options = [];
         if (concat.includes(" BY ") === false) {
             const descending = node.findDirectTokenByText("DESCENDING") !== undefined;
@@ -52,12 +53,14 @@ class SortTranspiler {
             const by = [];
             for (const c of components) {
                 const next = this.findNextText(c, node);
-                const concat = expressions_1.ComponentChainTranspiler.concat(c, traversal);
+                const component = c.get() instanceof abaplint.Expressions.Dynamic
+                    ? this.dynamicName(c, traversal)
+                    : `"${expressions_1.ComponentChainTranspiler.concat(c, traversal)}"`;
                 if (next === "DESCENDING") {
-                    by.push(`{component: "${concat}", descending: true}`);
+                    by.push(`{component: ${component}, descending: true}`);
                 }
                 else {
-                    by.push(`{component: "${concat}"}`);
+                    by.push(`{component: ${component}}`);
                 }
             }
             options.push(`by: [${by.join(",")}]`);
@@ -65,6 +68,32 @@ class SortTranspiler {
         const target = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Target)).getCode();
         return new chunk_1.Chunk().append("abap.statements.sort(" + target + ",{" + options.join(",") + "});", node, traversal);
     }
+    // "BY (name)" with the component name in a literal or a character-like field; a sort order table
+    // (abap_sortorder_tab) is not handled here
+    isDynamicName(c, traversal) {
+        if (!(c.get() instanceof abaplint.Expressions.Dynamic)) {
+            return false;
+        }
+        if (c.findFirstExpression(abaplint.Expressions.ConstantString)) {
+            return true;
+        }
+        const field = c.findFirstExpression(abaplint.Expressions.FieldChain);
+        if (field === undefined) {
+            return false;
+        }
+        const token = field.getFirstToken();
+        const type = traversal.findCurrentScopeByToken(token)?.findVariable(token.getStr())?.getType();
+        return !(type instanceof abaplint.BasicTypes.TableType);
+    }
+    dynamicName(c, traversal) {
+        const constant = c.findFirstExpression(abaplint.Expressions.ConstantString);
+        if (constant) {
+            const str = constant.getFirstToken().getStr();
+            return JSON.stringify(str.substring(1, str.length - 1).toLowerCase().trimEnd());
+        }
+        const field = c.findFirstExpression(abaplint.Expressions.FieldChain);
+        return new expressions_1.FieldChainTranspiler(true).transpile(field, traversal).getCode() + ".toLowerCase().trimEnd()";
+    }
     findNextText(c, parent) {
         const children = parent.getChildren();
         for (let i = 0; i < children.length; i++) {

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class TransferTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/transfer.js

@@ -2,9 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransferTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class TransferTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("Transfer, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        if (operands.after("LENGTH", ["MAXIMUM", "ACTUAL"]) !== undefined) {
+            options.push("length: " + operands.after("LENGTH", ["MAXIMUM", "ACTUAL"]));
+        }
+        if (operands.has("NO END OF LINE")) {
+            options.push("noEndOfLine: true");
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.transfer(", node, traversal)
+            .appendString(operands.first() + ", " + operands.after("TO") + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.TransferTranspiler = TransferTranspiler;

package/build/src/structures/class_definition.js

@@ -52,17 +52,18 @@ class ClassDefinitionTranspiler {
         }
         else {
             // its an abstract class with only abstract methods
+            // not indented, Chunk.runIndentationLogic indents by brace depth
             return new chunk_1.Chunk(`
 class ${className?.toLowerCase()} {
-  static INTERNAL_TYPE = 'CLAS';
-  static IMPLEMENTED_INTERFACES = [];
-  static INTERNAL_NAME = 'ABSTRACT_CLASS_INTERNAL_NAME';
-  static ATTRIBUTES = {};
-  async constructor_() {
-    this.me = new abap.types.ABAPObject();
-    this.me.set(this);
-    return this;
-  }
+static INTERNAL_TYPE = 'CLAS';
+static IMPLEMENTED_INTERFACES = [];
+static INTERNAL_NAME = 'ABSTRACT_CLASS_INTERNAL_NAME';
+static ATTRIBUTES = {};
+async constructor_() {
+this.me = new abap.types.ABAPObject();
+this.me.set(this);
+return this;
+}
 }`);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.95",
+  "version": "2.13.97",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,7 +29,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.120.63",
+    "@abaplint/core": "^2.120.65",
     "source-map": "^0.8.0"
   },
   "devDependencies": {