@abaplint/transpiler 2.13.94 → 2.13.96

package/build/src/db/schema_generation/pg_database_schema.js

@@ -95,6 +95,9 @@ class PGDatabaseSchema {
         else if (type instanceof abaplint.BasicTypes.IntegerType) {
             return `INT`;
         }
+        else if (type instanceof abaplint.BasicTypes.Integer8Type) {
+            return `BIGINT`;
+        }
         else if (type instanceof abaplint.BasicTypes.FloatType
             || type instanceof abaplint.BasicTypes.FloatingPointType) {
             return `REAL`;

package/build/src/db/schema_generation/snowflake_database_schema.js

@@ -94,6 +94,9 @@ class SnowflakeDatabaseSchema {
         else if (type instanceof abaplint.BasicTypes.IntegerType) {
             return `INT`;
         }
+        else if (type instanceof abaplint.BasicTypes.Integer8Type) {
+            return `NUMBER(19)`;
+        }
         else if (type instanceof abaplint.BasicTypes.FloatType
             || type instanceof abaplint.BasicTypes.FloatingPointType) {
             return `REAL`;

package/build/src/db/schema_generation/sqlite_database_schema.js

@@ -96,6 +96,9 @@ class SQLiteDatabaseSchema {
         else if (type instanceof abaplint.BasicTypes.IntegerType) {
             return `INT`;
         }
+        else if (type instanceof abaplint.BasicTypes.Integer8Type) {
+            return `INTEGER`;
+        }
         else if (type instanceof abaplint.BasicTypes.FloatType
             || type instanceof abaplint.BasicTypes.FloatingPointType) {
             return `REAL`;

package/build/src/expressions/sql_cond.d.ts

@@ -11,6 +11,7 @@ export declare class SQLCondTranspiler implements IExpressionTranspiler {
     private findSubselect;
     private sqlSubselect;
     private sqlSource;
+    private sqlHost;
     private basicConditionNew;
     private sourceWithComponents;
     private sqlOperator;

package/build/src/expressions/sql_cond.js

@@ -151,6 +151,11 @@ class SQLCondTranspiler {
             ret += fieldName + " IS NULL";
             return ret;
         }
+        const aggregation = c.findDirectExpression(abaplint.Expressions.SQLAggregation);
+        if (aggregation && operator && source) {
+            return aggregation.concatTokens() + " " + this.sqlOperator(operator.concatTokens()) + " "
+                + this.sqlSource(source, traversal, filename, table, true);
+        }
         if (fieldName === undefined || operator === undefined || source === undefined) {
             throw new Error("SQL Condition, transpiler todo2, " + c.concatTokens());
         }
@@ -212,17 +217,18 @@ class SQLCondTranspiler {
         }
         return ret + ")";
     }
-    sqlSource(source, traversal, filename, table) {
+    sqlSource(source, traversal, filename, table, numericHost = false) {
         let ret = "";
         const simple = source.findDirectExpression(abaplint.Expressions.SimpleSource3);
         const hostExpression = source.findDirectExpression(abaplint.Expressions.Source);
         const alias = source.findDirectExpression(abaplint.Expressions.SQLAliasField);
         if (source.getFirstToken().getStr() === "@" && hostExpression) {
             const code = new source_1.SourceTranspiler(true).transpile(hostExpression, traversal).getCode();
-            ret += "'\" + " + code + " + \"'";
+            ret += this.sqlHost(code, numericHost);
         }
         else if (simple && simple.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
-            ret += "'\" + " + new simple_source3_1.SimpleSource3Transpiler(true).transpile(simple, traversal).getCode() + " + \"'";
+            const code = new simple_source3_1.SimpleSource3Transpiler(true).transpile(simple, traversal).getCode();
+            ret += this.sqlHost(code, numericHost);
         }
         else if (alias) {
             // SQLAliasField might be a SQL reference or value from ABAP interface
@@ -257,6 +263,12 @@ class SQLCondTranspiler {
         }
         return ret;
     }
+    sqlHost(code, numericHost) {
+        if (numericHost) {
+            return `" + ((value) => typeof value === "number" || typeof value === "bigint" ? value : "'" + value + "'")(${code}) + "`;
+        }
+        return "'\" + " + code + " + \"'";
+    }
     basicConditionNew(node, traversal, filename, table) {
         const sourceWithComponents = this.sourceWithComponents(node, traversal);
         if (sourceWithComponents) {

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

@@ -0,0 +1,17 @@
+import * as abaplint from "@abaplint/core";
+import { Traversal } from "../traversal";
+/** the Sources and Targets of a DATASET statement, each found by the
+ *  keywords right in front of it: "MESSAGE" in "FOR INPUT IN BINARY MODE
+ *  MESSAGE m", "LENGTH" only when not "MAXIMUM LENGTH" or "ACTUAL LENGTH" */
+export declare class DatasetOperands {
+    private readonly operands;
+    private readonly words;
+    constructor(node: abaplint.Nodes.StatementNode, traversal: Traversal);
+    /** whether the statement has these keywords in a row: its own tokens only,
+     *  never the text of an operand, so a variable lv_type or a literal
+     *  'no end of line' is not an addition */
+    has(words: string): boolean;
+    /** the dataset name, or the source of TRANSFER: the first operand */
+    first(): string;
+    after(words: string, notAfter?: string[]): string | undefined;
+}

package/build/src/statements/_dataset.js

@@ -0,0 +1,82 @@
+"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.DatasetOperands = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
+/** the Sources and Targets of a DATASET statement, each found by the
+ *  keywords right in front of it: "MESSAGE" in "FOR INPUT IN BINARY MODE
+ *  MESSAGE m", "LENGTH" only when not "MAXIMUM LENGTH" or "ACTUAL LENGTH" */
+class DatasetOperands {
+    operands = [];
+    words = [];
+    constructor(node, traversal) {
+        let keywords = [];
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.TokenNode) {
+                keywords.push(c.getFirstToken().getStr().toUpperCase());
+                this.words.push(c.getFirstToken().getStr().toUpperCase());
+            }
+            else if (c instanceof abaplint.Nodes.ExpressionNode) {
+                this.operands.push({ keywords, code: traversal.traverse(c).getCode() });
+                keywords = [];
+            }
+        }
+    }
+    /** whether the statement has these keywords in a row: its own tokens only,
+     *  never the text of an operand, so a variable lv_type or a literal
+     *  'no end of line' is not an addition */
+    has(words) {
+        // abaplint splits UTF-8, NON-UNICODE and BYTE-ORDER into three tokens
+        const joined = this.words.join(" ").replace(/ - /g, "-");
+        return (" " + joined + " ").includes(" " + words + " ");
+    }
+    /** the dataset name, or the source of TRANSFER: the first operand */
+    first() {
+        return this.operands[0].code;
+    }
+    after(words, notAfter = []) {
+        const want = words.split(" ");
+        for (const o of this.operands.slice(1)) {
+            const tail = o.keywords.slice(-want.length);
+            const before = o.keywords[o.keywords.length - want.length - 1];
+            if (tail.join(" ") === words && (before === undefined || notAfter.includes(before) === false)) {
+                return o.code;
+            }
+        }
+        return undefined;
+    }
+}
+exports.DatasetOperands = DatasetOperands;
+//# sourceMappingURL=_dataset.js.map

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

@@ -0,0 +1,18 @@
+import * as abaplint from "@abaplint/core";
+import { Traversal } from "../traversal";
+/** PARAMETERS and SELECT-OPTIONS declare program variables that exist, with their
+ * DEFAULT values, before INITIALIZATION runs. Without LOWER CASE a character-like
+ * default is upper-cased (measured on a 7.5x system: 'abcdef' into a parameter of
+ * length 4 is "ABCD", a string parameter and the LOW of a select-option likewise) */
+export declare class SelectionDefault {
+    static variable(node: abaplint.Nodes.StatementNode, traversal: Traversal): {
+        name: string;
+        type: abaplint.AbstractType;
+    } | undefined;
+    /** the expression after a keyword of the statement, eg. DEFAULT; only a keyword
+     * token counts, an operand named like the keyword does not */
+    static after(node: abaplint.Nodes.StatementNode, keyword: string): abaplint.Nodes.ExpressionNode | undefined;
+    /** sets the target to a DEFAULT operand, a Constant or a FieldChain, and upper-cases
+     * it when the target is character-like and the statement has no LOWER CASE */
+    static set(node: abaplint.Nodes.StatementNode, target: string, targetType: abaplint.AbstractType, operand: abaplint.Nodes.ExpressionNode, traversal: Traversal): string;
+}

package/build/src/statements/_selection.js

@@ -0,0 +1,82 @@
+"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.SelectionDefault = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
+const traversal_1 = require("../traversal");
+/** PARAMETERS and SELECT-OPTIONS declare program variables that exist, with their
+ * DEFAULT values, before INITIALIZATION runs. Without LOWER CASE a character-like
+ * default is upper-cased (measured on a 7.5x system: 'abcdef' into a parameter of
+ * length 4 is "ABCD", a string parameter and the LOW of a select-option likewise) */
+class SelectionDefault {
+    static variable(node, traversal) {
+        const token = node.findDirectExpression(abaplint.Expressions.FieldSub)?.getFirstToken();
+        if (token === undefined) {
+            return undefined;
+        }
+        const found = traversal.findCurrentScopeByToken(token)?.findVariable(token.getStr());
+        if (found === undefined) {
+            return undefined;
+        }
+        return {
+            name: traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase())),
+            type: found.getType(),
+        };
+    }
+    /** the expression after a keyword of the statement, eg. DEFAULT; only a keyword
+     * token counts, an operand named like the keyword does not */
+    static after(node, keyword) {
+        const children = node.getChildren();
+        for (let i = 0; i < children.length - 1; i++) {
+            if (children[i] instanceof abaplint.Nodes.TokenNode && children[i].concatTokens().toUpperCase() === keyword) {
+                return children[i + 1];
+            }
+        }
+        return undefined;
+    }
+    /** sets the target to a DEFAULT operand, a Constant or a FieldChain, and upper-cases
+     * it when the target is character-like and the statement has no LOWER CASE */
+    static set(node, target, targetType, operand, traversal) {
+        let code = "\n" + target + ".set(" + traversal.traverse(operand).getCode() + ");";
+        const characterLike = targetType instanceof abaplint.BasicTypes.CharacterType
+            || targetType instanceof abaplint.BasicTypes.StringType;
+        if (node.findDirectTokenByText("LOWER") === undefined && characterLike === true) {
+            code += "\n" + target + ".set(abap.builtin.to_upper({val: " + target + "}));";
+        }
+        return code;
+    }
+}
+exports.SelectionDefault = SelectionDefault;
+//# sourceMappingURL=_selection.js.map

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

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

package/build/src/statements/close_dataset.js

@@ -1,10 +1,48 @@
 "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.CloseDatasetTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
 class CloseDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("CloseDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const name = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Source)).getCode();
+        return new chunk_1.Chunk()
+            .append("await abap.statements.closeDataset(", node, traversal)
+            .appendString(name)
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.CloseDatasetTranspiler = CloseDatasetTranspiler;

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

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

package/build/src/statements/delete_dataset.js

@@ -1,10 +1,48 @@
 "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.DeleteDatasetTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
 class DeleteDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("DeleteDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const name = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Source)).getCode();
+        return new chunk_1.Chunk()
+            .append("await abap.statements.deleteDataset(", node, traversal)
+            .appendString(name)
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.DeleteDatasetTranspiler = DeleteDatasetTranspiler;

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

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

package/build/src/statements/get_dataset.js

@@ -2,9 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class GetDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("GetDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        if (operands.after("POSITION") !== undefined) {
+            options.push("position: " + operands.after("POSITION"));
+        }
+        if (operands.after("ATTRIBUTES") !== undefined) {
+            options.push("attributes: " + operands.after("ATTRIBUTES"));
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.getDataset(", node, traversal)
+            .appendString(operands.first() + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.GetDatasetTranspiler = GetDatasetTranspiler;

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

@@ -15,4 +15,5 @@ export declare class LoopTranspiler implements IStatementTranspiler {
     getTarget(): string;
     private determineInto;
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private hasHeaderLine;
 }

package/build/src/statements/loop.js

@@ -94,6 +94,10 @@ class LoopTranspiler {
                 targetNode = assigning;
                 target = traversal.traverse(assigning).getCode() + ".assign(" + this.unique + ");";
             }
+            else if (!node.concatTokens().toUpperCase().includes(" TRANSPORTING NO FIELDS") && this.hasHeaderLine(loopSource, traversal)) {
+                // LOOP AT itab. without a target: the row goes into the header line of the table
+                target = source + ".getHeader().set(" + this.unique + ");";
+            }
         }
         const extra = [];
         const fromNode = node.findExpressionAfterToken("FROM");
@@ -148,7 +152,10 @@ class LoopTranspiler {
             extra.push(`atLast: (last) => { ${this.atLast} = last; }`);
         }
         const topEquals = {};
-        for (const compare of whereNode?.findDirectExpressions(abaplint.Expressions.ComponentCompare) || []) {
+        // only a pure conjunction makes each top-level `=` a condition every row
+        // has to meet: `a = 1 OR b = 2` narrows by neither
+        const onlyAnd = whereNode?.getChildren().every(c => !(c instanceof abaplint.Nodes.TokenNode) || c.concatTokens().toUpperCase() !== "OR") ?? true;
+        for (const compare of onlyAnd ? whereNode?.findDirectExpressions(abaplint.Expressions.ComponentCompare) || [] : []) {
             const op = compare.findDirectExpression(abaplint.Expressions.CompareOperator)?.concatTokens().toUpperCase();
             if (op !== "=" && op !== "EQ") {
                 continue;
@@ -185,6 +192,14 @@ class LoopTranspiler {
         }
         return ret;
     }
+    hasHeaderLine(loopSource, traversal) {
+        if (loopSource === undefined || /^[\w\/]+$/.test(loopSource.concatTokens()) === false) {
+            return false;
+        }
+        const token = loopSource.getFirstToken();
+        const type = traversal.findCurrentScopeByToken(token)?.findVariable(loopSource.concatTokens())?.getType();
+        return type instanceof abaplint.BasicTypes.TableType && type.isWithHeader();
+    }
 }
 exports.LoopTranspiler = LoopTranspiler;
 //# sourceMappingURL=loop.js.map

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

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

package/build/src/statements/open_dataset.js

@@ -2,9 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class OpenDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("OpenDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        const mode = ["INPUT", "OUTPUT", "APPENDING", "UPDATE"].find(m => operands.has("FOR " + m)) ?? "INPUT";
+        options.push(`mode: "${mode}"`);
+        options.push(`binary: ${operands.has("BINARY MODE")}`);
+        const encoding = ["DEFAULT", "UTF-8", "NON-UNICODE"].find(e => operands.has("ENCODING " + e));
+        if (encoding !== undefined) {
+            options.push(`encoding: "${encoding}"`);
+        }
+        if (operands.has("IN LEGACY")) {
+            options.push("legacy: true");
+        }
+        if (operands.after("MESSAGE") !== undefined) {
+            options.push("message: " + operands.after("MESSAGE"));
+        }
+        if (operands.after("AT POSITION") !== undefined) {
+            options.push("position: " + operands.after("AT POSITION"));
+        }
+        // accepted by the syntax, not implemented by the runtime: it refuses them
+        // by name rather than ignoring them
+        const unsupported = ["CODE PAGE", "TYPE", "FILTER", "REPLACEMENT CHARACTER", "WITH BYTE-ORDER MARK", "SKIPPING BYTE-ORDER MARK",
+            "WITH SMART LINEFEED", "WITH NATIVE LINEFEED", "WITH UNIX LINEFEED", "WITH WINDOWS LINEFEED", "IGNORING CONVERSION ERRORS"]
+            .filter(u => operands.has(u) || operands.after(u) !== undefined);
+        if (unsupported.length > 0) {
+            options.push("unsupported: " + JSON.stringify(unsupported));
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.openDataset(", node, traversal)
+            .appendString(operands.first() + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.OpenDatasetTranspiler = OpenDatasetTranspiler;

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

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

package/build/src/statements/parameter.js

@@ -1,10 +1,76 @@
 "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.ParameterTranspiler = 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 ParameterTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("Parameter, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const variable = _selection_1.SelectionDefault.variable(node, traversal);
+        // abaplint types "TYPE c LENGTH 3" and "TYPE p ... DECIMALS 2" of a parameter
+        // without the length and the decimals, a value would be cut silently
+        const tokens = node.getTokens().map(t => t.getStr().toUpperCase());
+        const sized = tokens.some((t, i) => (t === "LENGTH" && tokens[i - 1] !== "VISIBLE") || t === "DECIMALS");
+        if (variable === undefined || sized === true) {
+            return new chunk_1.Chunk(`throw new Error("Parameter, not supported, transpiler");`);
+        }
+        const { name, type } = variable;
+        const ret = new chunk_1.Chunk().appendString("let " + name + " = " + transpile_types_1.TranspileTypes.toType(type) + ";");
+        const operand = _selection_1.SelectionDefault.after(node, "DEFAULT");
+        if (operand) {
+            ret.appendString(_selection_1.SelectionDefault.set(node, name, type, operand, traversal));
+        }
+        else if (this.isFirstOfUnsetRadioGroup(node, traversal)) {
+            // a radio button group without DEFAULT 'X' starts with its first button chosen
+            ret.appendString("\n" + name + ".set('X');");
+        }
+        return ret;
+    }
+    isFirstOfUnsetRadioGroup(node, traversal) {
+        const group = node.findDirectExpression(abaplint.Expressions.RadioGroupName)?.concatTokens().toUpperCase();
+        if (group === undefined) {
+            return false;
+        }
+        const members = traversal.getFile().getStatements().filter(s => s.get() instanceof abaplint.Statements.Parameter
+            && s.findDirectExpression(abaplint.Expressions.RadioGroupName)?.concatTokens().toUpperCase() === group);
+        if (members.some(m => _selection_1.SelectionDefault.after(m, "DEFAULT") !== undefined)) {
+            return false;
+        }
+        return members[0].getStart().equals(node.getStart());
     }
 }
 exports.ParameterTranspiler = ParameterTranspiler;

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

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

package/build/src/statements/read_dataset.js

@@ -2,9 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class ReadDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("ReadDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        if (operands.after("MAXIMUM LENGTH") !== undefined) {
+            options.push("maximumLength: " + operands.after("MAXIMUM LENGTH"));
+        }
+        // the obsolete LENGTH is ACTUAL LENGTH
+        const actual = operands.after("ACTUAL LENGTH") ?? operands.after("LENGTH", ["MAXIMUM", "ACTUAL"]);
+        if (actual !== undefined) {
+            options.push("actualLength: " + actual);
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.readDataset(", node, traversal)
+            .appendString(operands.first() + ", " + operands.after("INTO") + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.ReadDatasetTranspiler = ReadDatasetTranspiler;

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,14 +174,25 @@ 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())`;
-            const code = `if (${faeTranspiled}.array().length === 0) {
+            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();
@@ -183,9 +200,56 @@ class SelectTranspiler {
   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});
+  ${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}});
+} 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 {
+      while (${target}.getArrayLength() > ${unique4}max) {
+        ${target}.deleteIndex(${target}.getArrayLength() - 1);
+      }
+    }
   }
   abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
 }`;

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/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/statements/update_database.js

@@ -58,8 +58,12 @@ class UpdateDatabaseTranspiler {
             }
             options.push(`"set": [${s.join(",")}]`);
         }
+        const fromTable = node.findExpressionAfterToken("TABLE");
+        if (fromTable && fromTable.get() instanceof abaplint.Expressions.SQLSource) {
+            options.push(`"table": ` + traversal.traverse(fromTable).getCode());
+        }
         const sourceExpression = node.findDirectExpression(abaplint.Expressions.SQLSource)?.findDirectExpression(abaplint.Expressions.SimpleSource3);
-        if (sourceExpression) {
+        if (sourceExpression && fromTable === undefined) {
             const sqlSource = new expressions_1.SourceTranspiler(true).transpile(sourceExpression, traversal).getCode();
             const tableName = node.findDirectExpression(abaplint.Expressions.DatabaseTable)?.concatTokens();
             const tabl = traversal.findTable(tableName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.94",
+  "version": "2.13.96",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,14 +29,14 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.120.61",
+    "@abaplint/core": "^2.120.64",
     "source-map": "^0.8.0"
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",
     "@types/mocha": "^10.0.10",
     "chai": "^6.2.2",
-    "mocha": "^12.0.2",
+    "mocha": "^12.0.3",
     "source-map-support": "^0.5.21",
     "typescript": "^6.0.3"
   }