@abaplint/runtime 2.13.95 → 2.13.96

package/build/src/context.d.ts

@@ -1,6 +1,7 @@
 import { Console } from "./console/console";
 import { DatabaseClient, DatabaseCursorCallbacks } from "./db/db";
 import * as RFC from "./rfc";
+import { DatasetHost, OpenDataset } from "./dataset/dataset";
 export declare class Context {
     console: Console;
     cursorCounter: number;
@@ -13,5 +14,9 @@ export declare class Context {
     RFCDestinations: {
         [name: string]: RFC.RFCClient;
     };
+    dataset: DatasetHost | undefined;
+    datasets: {
+        [name: string]: OpenDataset;
+    };
     defaultDB(): DatabaseClient;
 }

package/build/src/context.js

@@ -8,6 +8,10 @@ class Context {
     // DEFAULT and secondary database connections
     databaseConnections = {};
     RFCDestinations = {};
+    // the file system OPEN DATASET and friends read and write; none by default,
+    // and then every DATASET statement throws
+    dataset = undefined;
+    datasets = {};
     defaultDB() {
         if (this.databaseConnections["DEFAULT"] === undefined) {
             throw new Error("Runtime, database not initialized");

package/build/src/dataset/dataset.d.ts

@@ -0,0 +1,51 @@
+import { FieldSymbol } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export type DatasetMode = "INPUT" | "OUTPUT" | "APPENDING" | "UPDATE";
+/** an open file: positional reads and writes, the runtime keeps the position */
+export interface DatasetHandle {
+    /** up to length bytes from position; fewer at the end of the file */
+    read(position: number, length: number): Promise<Uint8Array>;
+    write(position: number, bytes: Uint8Array): Promise<void>;
+    size(): Promise<number>;
+    close(): Promise<void>;
+}
+export interface DatasetHost {
+    /** OUTPUT truncates or creates, APPENDING and UPDATE keep the content;
+     *  a failure is returned as the text OPEN DATASET ... MESSAGE receives
+     *  and becomes sy-subrc 8 */
+    open(name: string, mode: DatasetMode): Promise<DatasetHandle | {
+        message: string;
+    }>;
+    /** false when there was nothing to delete (sy-subrc 4) */
+    delete(name: string): Promise<boolean>;
+}
+export interface IOpenDatasetOptions {
+    mode: DatasetMode;
+    binary: boolean;
+    encoding?: "DEFAULT" | "UTF-8" | "NON-UNICODE";
+    legacy?: boolean;
+    message?: ICharacter | FieldSymbol;
+    position?: INumeric | FieldSymbol;
+    /** additions this runtime does not implement, by name */
+    unsupported?: string[];
+}
+export interface ITransferOptions {
+    length?: INumeric | FieldSymbol;
+    noEndOfLine?: boolean;
+}
+export interface IReadDatasetOptions {
+    maximumLength?: INumeric | FieldSymbol;
+    actualLength?: INumeric | FieldSymbol;
+}
+export interface IGetDatasetOptions {
+    position?: INumeric | FieldSymbol;
+    attributes?: any;
+}
+/** a file OPEN DATASET opened, as the runtime keeps it by name */
+export interface OpenDataset {
+    handle: DatasetHandle;
+    mode: DatasetMode;
+    binary: boolean;
+    position: number;
+}

package/build/src/dataset/dataset.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=dataset.js.map

package/build/src/dataset/memory_dataset.d.ts

@@ -0,0 +1,17 @@
+import { DatasetHandle, DatasetHost, DatasetMode } from "./dataset";
+/** A DatasetHost over a map of names to bytes: for tests, and for a runtime
+ *  in a browser, where there is no file system to hand to OPEN DATASET.
+ *  OUTPUT empties or creates a file, APPENDING and UPDATE create it when
+ *  missing, INPUT of a missing file fails with the message a system gives. */
+export declare class MemoryDataset implements DatasetHost {
+    readonly files: {
+        [name: string]: Uint8Array;
+    };
+    constructor(files?: {
+        [name: string]: Uint8Array;
+    });
+    open(name: string, mode: DatasetMode): Promise<DatasetHandle | {
+        message: string;
+    }>;
+    delete(name: string): Promise<boolean>;
+}

package/build/src/dataset/memory_dataset.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDataset = void 0;
+/** A DatasetHost over a map of names to bytes: for tests, and for a runtime
+ *  in a browser, where there is no file system to hand to OPEN DATASET.
+ *  OUTPUT empties or creates a file, APPENDING and UPDATE create it when
+ *  missing, INPUT of a missing file fails with the message a system gives. */
+class MemoryDataset {
+    files;
+    constructor(files = {}) {
+        this.files = files;
+    }
+    async open(name, mode) {
+        const files = this.files;
+        if (files[name] === undefined) {
+            if (mode === "INPUT") {
+                return { message: "No such file or directory" };
+            }
+            files[name] = new Uint8Array(0);
+        }
+        if (mode === "OUTPUT") {
+            files[name] = new Uint8Array(0);
+        }
+        return {
+            read: async (position, length) => files[name].slice(position, position + length),
+            write: async (position, bytes) => {
+                const end = Math.max(files[name].length, position + bytes.length);
+                const out = new Uint8Array(end);
+                out.set(files[name], 0);
+                out.set(bytes, position);
+                files[name] = out;
+            },
+            size: async () => files[name].length,
+            close: async () => undefined,
+        };
+    }
+    async delete(name) {
+        if (this.files[name] === undefined) {
+            return false;
+        }
+        delete this.files[name];
+        return true;
+    }
+}
+exports.MemoryDataset = MemoryDataset;
+//# sourceMappingURL=memory_dataset.js.map

package/build/src/index.d.ts

@@ -21,7 +21,10 @@ import { ABAPEventing } from "./abap_eventing";
 import { isLineNotFound } from "./is_line_not_found";
 import { parametersCall } from "./parameters_call";
 import { alphaIn, alphaOut } from "./alpha";
+import { DatasetHost } from "./dataset/dataset";
 export { RFC, types, DB, MemoryConsole };
+export type { DatasetHost, DatasetHandle, DatasetMode } from "./dataset/dataset";
+export { MemoryDataset } from "./dataset/memory_dataset";
 export type RuntimeDatabaseOptions = {
     schemaPrefix?: string;
     tablePrefix?: string;
@@ -29,6 +32,7 @@ export type RuntimeDatabaseOptions = {
 export type RuntimeOptions = {
     console?: Console;
     database?: RuntimeDatabaseOptions;
+    dataset?: DatasetHost;
 };
 export declare class ABAP {
     Classes: {

package/build/src/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ABAP = exports.MemoryConsole = exports.DB = exports.types = exports.RFC = void 0;
+exports.ABAP = exports.MemoryDataset = exports.MemoryConsole = exports.DB = exports.types = exports.RFC = void 0;
 const context_1 = require("./context");
 const offset_length_1 = require("./offset_length");
 const statements_1 = require("./statements");
@@ -61,6 +61,8 @@ const abap_eventing_1 = require("./abap_eventing");
 const is_line_not_found_1 = require("./is_line_not_found");
 const parameters_call_1 = require("./parameters_call");
 const alpha_1 = require("./alpha");
+var memory_dataset_1 = require("./dataset/memory_dataset");
+Object.defineProperty(exports, "MemoryDataset", { enumerable: true, get: function () { return memory_dataset_1.MemoryDataset; } });
 class ABAP {
     // global objects
     Classes = {};
@@ -101,6 +103,7 @@ class ABAP {
         this.context = new context_1.Context();
         this.console = input?.console ? input?.console : new standard_out_console_1.StandardOutConsole();
         this.context.console = this.console;
+        this.context.dataset = input?.dataset;
         this.dbo = input?.database || { schemaPrefix: "", tablePrefix: "" };
         if (this.dbo.schemaPrefix === undefined) {
             this.dbo.schemaPrefix = "";

package/build/src/primary_key.d.ts

@@ -1,2 +1,2 @@
-import { Table } from "./types";
-export declare function primaryKeyValues(target: Table, row: any): any[];
+import { HashedTable, Table } from "./types";
+export declare function primaryKeyValues(target: Table | HashedTable, row: any): any[];

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

@@ -1,3 +1,3 @@
-import { Table } from "../types";
+import { HashedTable, Structure, Table } from "../types";
 import { ICharacter } from "../types/_character";
-export declare function collect(source: ICharacter | Table, target?: Table): void;
+export declare function collect(source: ICharacter | Structure | Table, target?: Table | HashedTable): void;

package/build/src/statements/collect.js

@@ -2,25 +2,64 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collect = collect;
 const compare_1 = require("../compare");
+const primary_key_1 = require("../primary_key");
 const types_1 = require("../types");
 const insert_internal_1 = require("./insert_internal");
-const read_table_1 = require("./read_table");
+function sumNumeric(found, source, keyValues) {
+    if (found instanceof types_1.Structure && source instanceof types_1.Structure) {
+        for (const name of Object.keys(source.get())) {
+            sumNumeric(found.get()[name], source.get()[name], keyValues);
+        }
+    }
+    else if (keyValues.has(source)) {
+        return;
+    }
+    else if (found instanceof types_1.Integer && source instanceof types_1.Integer) {
+        found.set(found.get() + source.get());
+    }
+    else if (found instanceof types_1.Integer8 && source instanceof types_1.Integer8) {
+        found.set(found.get() + source.get());
+    }
+    else if (found instanceof types_1.Packed && source instanceof types_1.Packed) {
+        const decimals = found.getDecimals();
+        const factor = 10n ** BigInt(decimals);
+        const left = BigInt(found.toFixed(decimals).replace(".", ""));
+        const right = BigInt(source.toFixed(decimals).replace(".", ""));
+        const total = left + right;
+        const magnitude = total < 0n ? -total : total;
+        const fraction = decimals === 0 ? "" : "." + (magnitude % factor).toString().padStart(decimals, "0");
+        found.set((total < 0n ? "-" : "") + (magnitude / factor).toString() + fraction);
+    }
+    else if (found instanceof types_1.Float && source instanceof types_1.Float) {
+        found.set(found.getRaw() + source.getRaw());
+    }
+    else if (found instanceof types_1.DecFloat34 && source instanceof types_1.DecFloat34) {
+        found.set(found.getRaw() + source.getRaw());
+    }
+}
 function collect(source, target) {
     if (target === undefined && source instanceof types_1.Table) {
-        // with header line
-        const read = (0, read_table_1.readTable)(source, { withKey: (i) => { return (0, compare_1.eq)(i.table_line, source.getHeader()); } });
-        if (read.subrc === 4) {
-            (0, insert_internal_1.insertInternal)({ table: source, data: source.getHeader() });
-        }
+        target = source;
+        source = source.getHeader();
     }
-    else if (target !== undefined) {
-        const read = (0, read_table_1.readTable)(target, { withKey: (i) => { return (0, compare_1.eq)(i.table_line, source); } });
-        if (read.subrc === 4) {
-            (0, insert_internal_1.insertInternal)({ table: target, data: source });
-        }
+    if (target === undefined) {
+        throw new Error("COLLECT, no target specified");
+    }
+    const sourceKeys = (0, primary_key_1.primaryKeyValues)(target, source);
+    const matches = (row) => {
+        const rowKeys = (0, primary_key_1.primaryKeyValues)(target, row);
+        return rowKeys.length === sourceKeys.length && rowKeys.every((key, index) => (0, compare_1.eq)(key, sourceKeys[index]));
+    };
+    const rows = target.array();
+    let index = rows.findIndex(matches);
+    if (index >= 0) {
+        sumNumeric(rows[index], source, new Set(sourceKeys));
+        abap.builtin.sy.get().subrc.set(0);
     }
     else {
-        throw new Error("COLLECT, no target specified");
+        (0, insert_internal_1.insertInternal)({ table: target, data: source });
+        index = target.array().findIndex(matches);
     }
+    abap.builtin.sy.get().tabix.set(target instanceof types_1.HashedTable ? 0 : index + 1);
 }
 //# sourceMappingURL=collect.js.map

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

@@ -0,0 +1,23 @@
+import { Context } from "../context";
+import { FieldSymbol } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+import { IGetDatasetOptions, IOpenDatasetOptions, IReadDatasetOptions, ITransferOptions } from "../dataset/dataset";
+export declare class DatasetStatements {
+    private readonly context;
+    constructor(context: Context);
+    private host;
+    private opened;
+    openDataset(nameIn: ICharacter | FieldSymbol | string, options: IOpenDatasetOptions): Promise<void>;
+    closeDataset(nameIn: ICharacter | FieldSymbol | string): Promise<void>;
+    deleteDataset(nameIn: ICharacter | FieldSymbol | string): Promise<void>;
+    transfer(sourceIn: any, nameIn: ICharacter | FieldSymbol | string, options?: ITransferOptions): Promise<void>;
+    readDataset(nameIn: ICharacter | FieldSymbol | string, targetIn: any, options?: IReadDatasetOptions): Promise<void>;
+    private readLine;
+    private readBytes;
+    getDataset(nameIn: ICharacter | FieldSymbol | string, options: IGetDatasetOptions): Promise<void>;
+    setDataset(nameIn: ICharacter | FieldSymbol | string, options: {
+        position?: INumeric | FieldSymbol;
+        endOfFile?: boolean;
+    }): Promise<void>;
+}

package/build/src/statements/dataset.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetStatements = void 0;
+const throw_error_1 = require("../throw_error");
+const types_1 = require("../types");
+// OPEN / READ / TRANSFER / CLOSE / DELETE / GET / SET DATASET.
+//
+// The ABAP semantics live here, once: text lines, the byte layout of each
+// mode, ACTUAL LENGTH, sy-subrc and the exceptions. A host supplies bytes
+// only (DatasetHost), the way a DatabaseClient supplies rows, so that
+// a sandboxed file system, an in-memory one in a browser and a test double
+// all behave the same. Without a host every statement throws, as before.
+// The host and the options are defined in ../dataset/dataset.ts, and an
+// in-memory host is ../dataset/memory_dataset.ts.
+// what the text mode reads per host call while it looks for the end of a line
+const CHUNK = 64 * 1024;
+function deref(value) {
+    if (value instanceof types_1.FieldSymbol) {
+        const pointer = value.getPointer();
+        if (pointer === undefined) {
+            throw new Error("GETWA_NOT_ASSIGNED");
+        }
+        return pointer;
+    }
+    return value;
+}
+function nameOf(name) {
+    const value = typeof name === "string" ? name : deref(name).get();
+    // a C field holding the name is padded; the name is not
+    return (value + "").replace(/ +$/, "");
+}
+function numberOf(value) {
+    return value === undefined ? undefined : Number(deref(value).get());
+}
+function setSubrc(value) {
+    abap.builtin.sy.get().subrc.set(value);
+}
+function isHex(target) {
+    return target instanceof types_1.Hex || target instanceof types_1.HexUInt8;
+}
+function isCharLike(target) {
+    return typeof target?.get === "function" && typeof target.get() === "string" && !isHex(target) && !(target instanceof types_1.XString);
+}
+function hexToBytes(hex) {
+    const out = new Uint8Array(Math.floor(hex.length / 2));
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return out;
+}
+function bytesToHex(bytes) {
+    let out = "";
+    for (const b of bytes) {
+        out += b.toString(16).toUpperCase().padStart(2, "0");
+    }
+    return out;
+}
+// a character-like field in BINARY MODE is its code units in the system code
+// page, UTF-16LE on a Unicode system (measured: c(4) 'ab' is 6100 6200
+// 2000 2000)
+function utf16le(text) {
+    const out = new Uint8Array(text.length * 2);
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        out[i * 2] = code % 256;
+        out[i * 2 + 1] = Math.floor(code / 256);
+    }
+    return out;
+}
+function fromUtf16le(bytes) {
+    let out = "";
+    for (let i = 0; i + 1 < bytes.length; i += 2) {
+        out += globalThis.String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+    }
+    return out;
+}
+function concat(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+class DatasetStatements {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    host(statement) {
+        if (this.context.dataset === undefined) {
+            throw new Error(`${statement}, not supported: no dataset host installed (abap.context.dataset)`);
+        }
+        return this.context.dataset;
+    }
+    opened(name) {
+        const file = this.context.datasets[name];
+        if (file === undefined) {
+            (0, throw_error_1.throwError)("CX_SY_FILE_OPEN_MODE");
+        }
+        return file;
+    }
+    async openDataset(nameIn, options) {
+        const host = this.host("OPEN DATASET");
+        if (options.legacy === true || options.encoding === "NON-UNICODE") {
+            throw new Error("OPEN DATASET, LEGACY and NON-UNICODE modes not supported");
+        }
+        if (options.unsupported !== undefined && options.unsupported.length > 0) {
+            throw new Error(`OPEN DATASET, not supported: ${options.unsupported.join(", ")}`);
+        }
+        const name = nameOf(nameIn);
+        if (this.context.datasets[name] !== undefined) {
+            (0, throw_error_1.throwError)("CX_SY_FILE_OPEN");
+        }
+        const opened = await host.open(name, options.mode);
+        if (!("read" in opened)) {
+            if (options.message !== undefined) {
+                deref(options.message).set(opened.message);
+            }
+            setSubrc(8);
+            return;
+        }
+        let position = 0;
+        if (options.mode === "APPENDING") {
+            position = await opened.size();
+        }
+        const at = numberOf(options.position);
+        if (at !== undefined) {
+            position = at;
+        }
+        this.context.datasets[name] = { handle: opened, mode: options.mode, binary: options.binary, position };
+        setSubrc(0);
+    }
+    async closeDataset(nameIn) {
+        this.host("CLOSE DATASET");
+        const name = nameOf(nameIn);
+        const file = this.context.datasets[name];
+        // closing a file that is not open is no error (measured: sy-subrc 0)
+        if (file !== undefined) {
+            delete this.context.datasets[name];
+            await file.handle.close();
+        }
+        setSubrc(0);
+    }
+    async deleteDataset(nameIn) {
+        const host = this.host("DELETE DATASET");
+        const name = nameOf(nameIn);
+        // deleting an open file answers 0 and closes it: a READ after it raises
+        // CX_SY_FILE_OPEN_MODE (measured)
+        const file = this.context.datasets[name];
+        if (file !== undefined) {
+            delete this.context.datasets[name];
+            await file.handle.close();
+        }
+        setSubrc(await host.delete(name) ? 0 : 4);
+    }
+    async transfer(sourceIn, nameIn, options = {}) {
+        this.host("TRANSFER");
+        const file = this.opened(nameOf(nameIn));
+        if (file.mode === "INPUT") {
+            (0, throw_error_1.throwError)("CX_SY_FILE_OPEN_MODE");
+        }
+        const source = deref(sourceIn);
+        const length = numberOf(options.length);
+        let bytes;
+        if (file.binary === true) {
+            if (isHex(source) || source instanceof types_1.XString) {
+                bytes = hexToBytes(source.get());
+            }
+            else if (isCharLike(source)) {
+                let text = source.get();
+                if (source instanceof types_1.Character) {
+                    text = text.padEnd(source.getLength(), " ");
+                }
+                bytes = utf16le(length === undefined ? text : text.substring(0, length));
+                if (length !== undefined) {
+                    const want = length * 2;
+                    bytes = bytes.length >= want ? bytes : concat(bytes, utf16le(" ".repeat((want - bytes.length) / 2)));
+                }
+            }
+            else {
+                throw new Error("TRANSFER, BINARY MODE supports byte-like and character-like fields only");
+            }
+            if (length !== undefined && (isHex(source) || source instanceof types_1.XString)) {
+                bytes = bytes.length >= length ? bytes.slice(0, length) : concat(bytes, new Uint8Array(length - bytes.length));
+            }
+        }
+        else {
+            if (!isCharLike(source)) {
+                throw new Error("TRANSFER, TEXT MODE is only supported for character-type data objects");
+            }
+            let text = source.get();
+            if (length !== undefined) {
+                if (source instanceof types_1.Character) {
+                    text = text.padEnd(source.getLength(), " ");
+                }
+                text = text.substring(0, length);
+            }
+            else if (source instanceof types_1.Character) {
+                // measured: c(10) 'ab' is written as 'ab' and a line end;
+                // a string keeps its trailing blanks
+                text = source.getTrimEnd();
+            }
+            if (options.noEndOfLine !== true) {
+                text = text + "\n";
+            }
+            bytes = new TextEncoder().encode(text);
+        }
+        await file.handle.write(file.position, bytes);
+        file.position += bytes.length;
+        setSubrc(0);
+    }
+    async readDataset(nameIn, targetIn, options = {}) {
+        this.host("READ DATASET");
+        const file = this.opened(nameOf(nameIn));
+        const target = deref(targetIn);
+        const maximum = numberOf(options.maximumLength);
+        const setActual = (n) => {
+            if (options.actualLength !== undefined) {
+                deref(options.actualLength).set(n);
+            }
+        };
+        // a file opened for writing only answers 4 (measured, OUTPUT and APPENDING)
+        if (file.mode === "OUTPUT" || file.mode === "APPENDING") {
+            setActual(0);
+            setSubrc(4);
+            return;
+        }
+        if (file.binary === false) {
+            await this.readLine(file, target, maximum, setActual);
+        }
+        else {
+            await this.readBytes(file, target, maximum, setActual);
+        }
+    }
+    // TEXT MODE: one line per READ, without its LF (a CR before it stays,
+    // measured); the last line needs no LF; at the end sy-subrc 4 and the target
+    // cleared. ACTUAL LENGTH is the whole line even when the target is shorter,
+    // and the whole line is consumed either way.
+    async readLine(file, target, maximum, setActual) {
+        if (!isCharLike(target)) {
+            throw new Error("READ DATASET, the current statement is only supported for character-type data objects");
+        }
+        if (maximum !== undefined) {
+            throw new Error("READ DATASET, MAXIMUM LENGTH in TEXT MODE not supported");
+        }
+        let line = new Uint8Array(0);
+        let position = file.position;
+        let ended = false;
+        for (;;) {
+            const chunk = await file.handle.read(position, CHUNK);
+            if (chunk.length === 0) {
+                break;
+            }
+            const lf = chunk.indexOf(0x0A);
+            if (lf >= 0) {
+                line = concat(line, chunk.subarray(0, lf));
+                position += lf + 1;
+                ended = true;
+                break;
+            }
+            line = concat(line, chunk);
+            position += chunk.length;
+        }
+        if (ended === false && line.length === 0) {
+            target.clear();
+            setActual(0);
+            setSubrc(4);
+            return;
+        }
+        file.position = position;
+        const text = new TextDecoder("utf-8").decode(line);
+        target.set(text);
+        setActual(text.length);
+        setSubrc(0);
+    }
+    // BINARY MODE: a field of fixed length takes its length in bytes (a C
+    // field two per character, UTF-16LE), a string or xstring the rest of the
+    // file; MAXIMUM LENGTH caps the bytes; fewer bytes than asked is sy-subrc 4
+    // and ACTUAL LENGTH counts bytes (measured)
+    async readBytes(file, target, maximum, setActual) {
+        let want;
+        if (isHex(target)) {
+            want = target.getLength();
+        }
+        else if (target instanceof types_1.Character) {
+            want = target.getLength() * 2;
+        }
+        else if (target instanceof types_1.XString || target instanceof types_1.String) {
+            want = Math.max(0, await file.handle.size() - file.position);
+        }
+        else if (isCharLike(target) && typeof target.getLength === "function") {
+            want = target.getLength() * 2;
+        }
+        else {
+            throw new Error("READ DATASET, BINARY MODE supports byte-like and character-like fields only");
+        }
+        const variable = target instanceof types_1.XString || target instanceof types_1.String;
+        if (maximum !== undefined) {
+            want = Math.min(want, maximum);
+        }
+        const bytes = want === 0 ? new Uint8Array(0) : await file.handle.read(file.position, want);
+        file.position += bytes.length;
+        if (isHex(target)) {
+            target.set(bytesToHex(bytes).padEnd(target.getLength() * 2, "0"));
+        }
+        else if (target instanceof types_1.XString) {
+            target.set(bytesToHex(bytes));
+        }
+        else {
+            target.set(fromUtf16le(bytes));
+        }
+        setActual(bytes.length);
+        if (variable === true) {
+            setSubrc(bytes.length > 0 ? 0 : 4);
+        }
+        else {
+            setSubrc(bytes.length < want || want === 0 ? 4 : 0);
+        }
+    }
+    async getDataset(nameIn, options) {
+        this.host("GET DATASET");
+        const file = this.opened(nameOf(nameIn));
+        if (options.attributes !== undefined) {
+            throw new Error("GET DATASET, ATTRIBUTES not supported");
+        }
+        if (options.position !== undefined) {
+            deref(options.position).set(file.position);
+        }
+        setSubrc(0);
+    }
+    async setDataset(nameIn, options) {
+        this.host("SET DATASET");
+        const file = this.opened(nameOf(nameIn));
+        if (options.endOfFile === true) {
+            file.position = await file.handle.size();
+        }
+        else if (options.position !== undefined) {
+            file.position = numberOf(options.position) ?? 0;
+        }
+        setSubrc(0);
+    }
+}
+exports.DatasetStatements = DatasetStatements;
+//# sourceMappingURL=dataset.js.map

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

@@ -1,4 +1,5 @@
 import { append } from "./append";
+import { IGetDatasetOptions, IOpenDatasetOptions, IReadDatasetOptions, ITransferOptions } from "../dataset/dataset";
 import { assert } from "./assert";
 import { assign } from "./assign";
 import { ICommitOptions } from "./commit";
@@ -110,5 +111,15 @@ export declare class Statements {
     message(options: IMessageOptions): Promise<void>;
     readReport(name: ICharacter, options: Parameters<typeof readReport>[1]): Promise<void>;
     write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
+    openDataset(name: any, options: IOpenDatasetOptions): Promise<void>;
+    closeDataset(name: any): Promise<void>;
+    deleteDataset(name: any): Promise<void>;
+    transfer(source: any, name: any, options?: ITransferOptions): Promise<void>;
+    readDataset(name: any, target: any, options?: IReadDatasetOptions): Promise<void>;
+    getDataset(name: any, options: IGetDatasetOptions): Promise<void>;
+    setDataset(name: any, options: {
+        position?: any;
+        endOfFile?: boolean;
+    }): Promise<void>;
     skip(options?: ISkipOptions): void;
 }

package/build/src/statements/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Statements = void 0;
 const append_1 = require("./append");
+const dataset_1 = require("./dataset");
 const assert_1 = require("./assert");
 const assign_1 = require("./assign");
 const commit_1 = require("./commit");
@@ -148,6 +149,27 @@ class Statements {
     write(source, options) {
         return new write_1.WriteStatement(this.context).write(source, options);
     }
+    async openDataset(name, options) {
+        return new dataset_1.DatasetStatements(this.context).openDataset(name, options);
+    }
+    async closeDataset(name) {
+        return new dataset_1.DatasetStatements(this.context).closeDataset(name);
+    }
+    async deleteDataset(name) {
+        return new dataset_1.DatasetStatements(this.context).deleteDataset(name);
+    }
+    async transfer(source, name, options) {
+        return new dataset_1.DatasetStatements(this.context).transfer(source, name, options);
+    }
+    async readDataset(name, target, options) {
+        return new dataset_1.DatasetStatements(this.context).readDataset(name, target, options);
+    }
+    async getDataset(name, options) {
+        return new dataset_1.DatasetStatements(this.context).getDataset(name, options);
+    }
+    async setDataset(name, options) {
+        return new dataset_1.DatasetStatements(this.context).setDataset(name, options);
+    }
     skip(options) {
         return new skip_1.SkipStatement(this.context).skip(options);
     }

package/build/src/statements/loop.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loop = loop;
 const binary_search_1 = require("../binary_search");
+const compare_1 = require("../compare");
 const types_1 = require("../types");
 function determineFromTo(array, topEquals, key) {
     if (topEquals === undefined) {
@@ -27,6 +28,53 @@ function determineFromTo(array, topEquals, key) {
         to: to,
     };
 }
+/** -1 / 0 / 1: the key field x sorts before / equal to / after the WHERE operand
+ *  v - only for pairs whose order agrees with the table's sort (sort.ts compares
+ *  the fields with lt/eq): the same type, of the same length for c, n and x, or
+ *  a c operand against a string field, which eq compares by its getTrimEnd() */
+function keyComparator(sample, value) {
+    if (value === null || typeof value !== "object" || sample === null || typeof sample !== "object") {
+        return undefined;
+    }
+    if (sample.constructor === value.constructor) {
+        const fixed = sample instanceof types_1.Character || sample instanceof types_1.Numc || sample instanceof types_1.Hex;
+        if (fixed && sample.getLength() !== value.getLength()) {
+            return undefined;
+        }
+        return (x, v) => ((0, compare_1.eq)(x, v) ? 0 : (0, compare_1.lt)(x, v) ? -1 : 1);
+    }
+    if (sample instanceof types_1.String && value instanceof types_1.Character) {
+        return (x, v) => {
+            const s = v.getTrimEnd();
+            const xs = x.get();
+            return xs === s ? 0 : xs < s ? -1 : 1;
+        };
+    }
+    return undefined;
+}
+/** A SORTED primary key, and a WHERE that requires its first field to equal a
+ *  value: the rows the WHERE can accept are one block of the array. Relies on
+ *  topEquals holding only conditions every row has to meet - see the
+ *  transpiler's LoopTranspiler, which emits it for a conjunction only */
+function sortedPrimaryBlock(table, options) {
+    const primary = table.getOptions()?.primaryKey;
+    if (!(table instanceof types_1.Table) || primary?.type !== types_1.TableAccessType.sorted
+        || !primary.keyFields?.length || options?.topEquals === undefined) {
+        return undefined;
+    }
+    const field = primary.keyFields[0].toLowerCase();
+    const value = options.topEquals[field];
+    const rowType = table.getRowType();
+    const structured = rowType instanceof types_1.Structure;
+    if (value === undefined || structured === (field === "table_line")) {
+        return undefined;
+    }
+    const compare = keyComparator(structured ? rowType.get()[field] : rowType, value);
+    if (compare === undefined) {
+        return undefined;
+    }
+    return structured ? (row) => compare(row.get()[field], value) : (row) => compare(row, value);
+}
 // todo: rewrite, this is a mess & hack & slow
 function dynamicToWhere(condition, evaluate) {
     //  console.dir(condition);
@@ -103,6 +151,7 @@ async function* loop(table, options) {
     let loopFrom = options?.from && options?.from.get() > 0 ? options.from.get() - 1 : 0;
     let loopTo = options?.to && options.to.get() < length ? options.to.get() : length;
     let array = [];
+    let block = undefined;
     // a dynamic key name may come in any case, USING KEY ('PRIMARY_KEY') is the primary key too
     const isPrimaryKey = options?.usingKey === undefined || options.usingKey.toLowerCase() === "primary_key";
     if (options?.usingKey && isPrimaryKey === false) {
@@ -113,6 +162,24 @@ async function* loop(table, options) {
     }
     else {
         array = table.array();
+        if (options?.where !== undefined && options.from === undefined && options.to === undefined) {
+            block = sortedPrimaryBlock(table, options);
+        }
+        if (block !== undefined) {
+            // the first row that does not sort before the value
+            let lo = 0;
+            let hi = array.length;
+            while (lo < hi) {
+                const mid = Math.floor((lo + hi) / 2);
+                if (block(array[mid]) < 0) {
+                    lo = mid + 1;
+                }
+                else {
+                    hi = mid;
+                }
+            }
+            loopFrom = lo;
+        }
     }
     const loopController = table.startLoop(loopFrom, loopTo, array);
     let entered = false;
@@ -143,6 +210,10 @@ async function* loop(table, options) {
                 break;
             }
             const current = array[loopController.index];
+            if (block !== undefined && block(current) > 0) {
+                // this row sorts after the value, and so does every row behind it
+                break;
+            }
             if (options?.where) {
                 const row = isStructured ? current.get() : { table_line: current };
                 if (await options.where(row) === false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "2.13.95",
+  "version": "2.13.96",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",