@abaplint/runtime 2.7.95 → 2.7.97

package/build/src/context.d.ts

@@ -1,8 +1,12 @@
 import { Console } from "./console/console";
-import { DatabaseClient } from "./db/db";
+import { DatabaseClient, DatabaseCursorCallbacks } from "./db/db";
 import * as RFC from "./rfc";
 export declare class Context {
     console: Console;
+    cursorCounter: number;
+    cursors: {
+        [key: number]: DatabaseCursorCallbacks;
+    };
     databaseConnections: {
         [name: string]: DatabaseClient;
     };

package/build/src/context.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 class Context {
     constructor() {
+        this.cursorCounter = 0;
+        this.cursors = {};
         // DEFAULT and secondary database connections
         this.databaseConnections = {};
         this.RFCDestinations = {};

package/build/src/db/db.d.ts

@@ -29,6 +29,10 @@ export type DatabaseRows = DatabaseRow[];
 export interface SelectDatabaseResult {
     rows: DatabaseRows;
 }
+export type DatabaseCursorCallbacks = {
+    fetchNextCursor: (packageSize: number) => Promise<SelectDatabaseResult>;
+    closeCursor: () => Promise<void>;
+};
 export interface DatabaseClient {
     /*** the type/name/identifier of the database */
     name: string;
@@ -52,4 +56,5 @@ export interface DatabaseClient {
         dbcnt: number;
     }>;
     select(options: SelectDatabaseOptions): Promise<SelectDatabaseResult>;
+    openCursor(options: SelectDatabaseOptions): Promise<DatabaseCursorCallbacks>;
 }

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

@@ -0,0 +1,2 @@
+import { Context } from "../context";
+export declare function closeCursor(context: Context, cursor: number): Promise<void>;

package/build/src/statements/close_cursor.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeCursor = void 0;
+async function closeCursor(context, cursor) {
+    await context.cursors[cursor].closeCursor();
+    delete context.cursors[cursor];
+}
+exports.closeCursor = closeCursor;
+//# sourceMappingURL=close_cursor.js.map

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

@@ -6,8 +6,4 @@ export interface IDeleteDatabaseOptions {
     where?: string;
     table?: Table | FieldSymbol;
 }
-export declare class DeleteDatabase {
-    private readonly context;
-    constructor(context: Context);
-    deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
-}
+export declare function deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions, context: Context): Promise<void>;

package/build/src/statements/delete_database.js

@@ -1,59 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteDatabase = void 0;
+exports.deleteDatabase = void 0;
 const prefix_1 = require("../prefix");
 const types_1 = require("../types");
 const insert_database_1 = require("./insert_database");
-class DeleteDatabase {
-    constructor(context) {
-        this.context = context;
+async function deleteDatabase(table, options, context) {
+    if (options.table instanceof types_1.FieldSymbol) {
+        options.table = options.table.getPointer();
     }
-    async deleteDatabase(table, options) {
-        if (options.table instanceof types_1.FieldSymbol) {
-            options.table = options.table.getPointer();
-        }
-        if (options.from instanceof types_1.FieldSymbol) {
-            options.from = options.from.getPointer();
-        }
-        if (typeof table !== "string") {
-            table = table.get().trimEnd();
-        }
-        if (options.table) {
-            for (const row of options.table.array()) {
-                await this.deleteDatabase(table, { from: row });
-            }
-        }
-        else if (options.from) {
-            let where = [];
-            const structure = options.from.get();
-            for (const k of Object.keys(structure)) {
-                const str = `"${k.toLowerCase()}"` + " = " + (0, insert_database_1.toValue)(structure[k].get());
-                where.push(str);
-            }
-            where = where.join(" AND ");
-            const { subrc, dbcnt } = await this.context.defaultDB().delete({
-                table: (0, prefix_1.buildDbTableName)(table),
-                where,
-            });
-            // @ts-ignore
-            abap.builtin.sy.get().subrc.set(subrc);
-            // @ts-ignore
-            abap.builtin.sy.get().dbcnt.set(dbcnt);
-        }
-        else if (options.where) {
-            const { subrc, dbcnt } = await this.context.defaultDB().delete({
-                table: (0, prefix_1.buildDbTableName)(table),
-                where: options.where,
-            });
-            // @ts-ignore
-            abap.builtin.sy.get().subrc.set(subrc);
-            // @ts-ignore
-            abap.builtin.sy.get().dbcnt.set(dbcnt);
+    if (options.from instanceof types_1.FieldSymbol) {
+        options.from = options.from.getPointer();
+    }
+    if (typeof table !== "string") {
+        table = table.get().trimEnd();
+    }
+    if (options.table) {
+        for (const row of options.table.array()) {
+            await deleteDatabase(table, { from: row }, context);
         }
-        else {
-            throw "deleteDatabase todo";
+    }
+    else if (options.from) {
+        let where = [];
+        const structure = options.from.get();
+        for (const k of Object.keys(structure)) {
+            const str = `"${k.toLowerCase()}"` + " = " + (0, insert_database_1.toValue)(structure[k].get());
+            where.push(str);
         }
+        where = where.join(" AND ");
+        const { subrc, dbcnt } = await context.defaultDB().delete({
+            table: (0, prefix_1.buildDbTableName)(table),
+            where,
+        });
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(subrc);
+        // @ts-ignore
+        abap.builtin.sy.get().dbcnt.set(dbcnt);
+    }
+    else if (options.where) {
+        const { subrc, dbcnt } = await context.defaultDB().delete({
+            table: (0, prefix_1.buildDbTableName)(table),
+            where: options.where,
+        });
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(subrc);
+        // @ts-ignore
+        abap.builtin.sy.get().dbcnt.set(dbcnt);
+    }
+    else {
+        throw "deleteDatabase todo";
     }
 }
-exports.DeleteDatabase = DeleteDatabase;
+exports.deleteDatabase = deleteDatabase;
 //# sourceMappingURL=delete_database.js.map

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

@@ -0,0 +1,3 @@
+import { Context } from "../context";
+import { HashedTable, Structure, Table, FieldSymbol } from "../types";
+export declare function fetchNextCursor(context: Context, cursor: number, target: Structure | Table | FieldSymbol | HashedTable, packageSize: number): Promise<void>;

package/build/src/statements/fetch_next_cursor.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchNextCursor = void 0;
+const types_1 = require("../types");
+const select_1 = require("./select");
+async function fetchNextCursor(context, cursor, target, packageSize) {
+    if (target instanceof types_1.FieldSymbol) {
+        if (target.isAssigned() === false) {
+            throw new Error("GETWA_NOT_ASSIGNED");
+        }
+        // @ts-ignore
+        target = target.getPointer();
+    }
+    if (target instanceof types_1.Structure) {
+        packageSize = 1;
+    }
+    const result = await context.cursors[cursor].fetchNextCursor(packageSize);
+    if (result.rows.length === 0) {
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(4);
+        return;
+    }
+    // @ts-ignore
+    abap.builtin.sy.get().subrc.set(0);
+    (0, select_1.rowsToTarget)(target, result.rows);
+}
+exports.fetchNextCursor = fetchNextCursor;
+//# sourceMappingURL=fetch_next_cursor.js.map

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

@@ -95,12 +95,15 @@ export declare class Statements {
     private _trace;
     private _traceAsync;
     _setTrace(min?: number, totals?: boolean): void;
+    openCursor(target: INumeric, select: string): Promise<void>;
+    fetchNextCursor(cursor: INumeric, target: any, packageSize?: INumeric): Promise<void>;
+    closeCursor(cursor: INumeric): Promise<void>;
     deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
     insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number | undefined>;
-    message(options: IMessageOptions): Promise<void>;
     modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;
     select(target: Structure | Table | FieldSymbol, select: SelectDatabaseOptions, runtimeOptions?: SelectRuntimeOptions): Promise<void>;
     updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions): Promise<number>;
     callFunction(options: ICallFunctionOptions): Promise<void>;
+    message(options: IMessageOptions): Promise<void>;
     write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
 }

package/build/src/statements/index.js

@@ -41,6 +41,9 @@ const set_bit_1 = require("./set_bit");
 const shift_1 = require("./shift");
 const sort_1 = require("./sort");
 const wait_1 = require("./wait");
+const fetch_next_cursor_1 = require("./fetch_next_cursor");
+const open_cursor_1 = require("./open_cursor");
+const close_cursor_1 = require("./close_cursor");
 const set_handler_1 = require("./set_handler");
 const split_1 = require("./split");
 const translate_1 = require("./translate");
@@ -154,27 +157,37 @@ class Statements {
             }
         }
     }
+    async openCursor(target, select) {
+        const num = await (0, open_cursor_1.openCursor)(this.context, select);
+        target.set(num);
+    }
+    async fetchNextCursor(cursor, target, packageSize) {
+        await (0, fetch_next_cursor_1.fetchNextCursor)(this.context, cursor.get(), target, (packageSize === null || packageSize === void 0 ? void 0 : packageSize.get()) || 0);
+    }
+    async closeCursor(cursor) {
+        await (0, close_cursor_1.closeCursor)(this.context, cursor.get());
+    }
     async deleteDatabase(table, options) {
-        return new delete_database_1.DeleteDatabase(this.context).deleteDatabase(table, options);
+        await (0, delete_database_1.deleteDatabase)(table, options, this.context);
     }
     async insertDatabase(table, options) {
-        return new insert_database_1.InsertDatabase(this.context).insertDatabase(table, options);
-    }
-    async message(options) {
-        return new message_1.MessageStatement(this.context).message(options);
+        return (0, insert_database_1.insertDatabase)(table, options, this.context);
     }
     async modifyDatabase(table, options) {
-        return new modify_database_1.ModifyDatabase(this.context).modifyDatabase(table, options);
+        return (0, modify_database_1.modifyDatabase)(table, options, this.context);
     }
     async select(target, select, runtimeOptions) {
-        return new select_1.SelectDatabase(this.context).select(target, select, runtimeOptions);
+        return (0, select_1.select)(target, select, runtimeOptions || {}, this.context);
     }
     async updateDatabase(table, options) {
-        return new update_database_1.UpdateDatabase(this.context).updateDatabase(table, options);
+        return (0, update_database_1.updateDatabase)(table, options, this.context);
     }
     async callFunction(options) {
         return new call_function_1.CallFunction(this.context).callFunction(options);
     }
+    async message(options) {
+        return new message_1.MessageStatement(this.context).message(options);
+    }
     write(source, options) {
         return new write_1.WriteStatement(this.context).write(source, options);
     }

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

@@ -5,9 +5,6 @@ export declare function toValue(value: any): any;
 export interface IInsertDatabaseOptions {
     values?: Structure;
     table?: Table;
+    connection?: string;
 }
-export declare class InsertDatabase {
-    private readonly context;
-    constructor(context: Context);
-    insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number | undefined>;
-}
+export declare function insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions, context: Context): Promise<number | undefined>;

package/build/src/statements/insert_database.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InsertDatabase = exports.toValue = void 0;
+exports.insertDatabase = exports.toValue = void 0;
 const prefix_1 = require("../prefix");
 function toValue(value) {
     if (typeof value === "string") {
@@ -13,52 +13,51 @@ function toValue(value) {
     }
 }
 exports.toValue = toValue;
-class InsertDatabase {
-    constructor(context) {
-        this.context = context;
+async function insertDatabase(table, options, context) {
+    const columns = [];
+    const values = [];
+    if (options.values === undefined && options.table === undefined) {
+        throw "insertDatabase, wrong input";
     }
-    async insertDatabase(table, options) {
-        const columns = [];
-        const values = [];
-        if (options.values === undefined && options.table === undefined) {
-            throw "insertDatabase, wrong input";
-        }
-        if (options.table !== undefined) {
-            let subrc = 0;
-            let dbcnt = 0;
-            for (const row of options.table.array()) {
-                await this.insertDatabase(table, { values: row });
-                // @ts-ignore
-                subrc = Math.max(subrc, abap.builtin.sy.get().subrc.get());
-                // @ts-ignore
-                dbcnt += abap.builtin.sy.get().dbcnt.get();
-            }
+    if (options.table !== undefined) {
+        let subrc = 0;
+        let dbcnt = 0;
+        for (const row of options.table.array()) {
+            await insertDatabase(table, { values: row, connection: options.connection }, context);
             // @ts-ignore
-            abap.builtin.sy.get().subrc.set(subrc);
+            subrc = Math.max(subrc, abap.builtin.sy.get().subrc.get());
             // @ts-ignore
-            abap.builtin.sy.get().dbcnt.set(dbcnt);
-            return;
-        }
-        const structure = options.values.get();
-        for (const k of Object.keys(structure)) {
-            columns.push(k);
-            const value = structure[k].get();
-            values.push(toValue(value));
-        }
-        if (typeof table !== "string") {
-            table = table.get().trimEnd().toLowerCase();
+            dbcnt += abap.builtin.sy.get().dbcnt.get();
         }
-        const { subrc, dbcnt } = await this.context.defaultDB().insert({
-            table: (0, prefix_1.buildDbTableName)(table),
-            columns,
-            values,
-        });
         // @ts-ignore
         abap.builtin.sy.get().subrc.set(subrc);
         // @ts-ignore
         abap.builtin.sy.get().dbcnt.set(dbcnt);
-        return subrc;
+        return;
+    }
+    const structure = options.values.get();
+    for (const k of Object.keys(structure)) {
+        columns.push(k);
+        const value = structure[k].get();
+        values.push(toValue(value));
+    }
+    if (typeof table !== "string") {
+        table = table.get().trimEnd().toLowerCase();
+    }
+    let db = context.defaultDB();
+    if (options.connection) {
+        db = context.databaseConnections[options.connection];
     }
+    const { subrc, dbcnt } = await db.insert({
+        table: (0, prefix_1.buildDbTableName)(table),
+        columns,
+        values,
+    });
+    // @ts-ignore
+    abap.builtin.sy.get().subrc.set(subrc);
+    // @ts-ignore
+    abap.builtin.sy.get().dbcnt.set(dbcnt);
+    return subrc;
 }
-exports.InsertDatabase = InsertDatabase;
+exports.insertDatabase = insertDatabase;
 //# sourceMappingURL=insert_database.js.map

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

@@ -5,8 +5,4 @@ export interface IModifyDatabaseOptions {
     values?: Structure | FieldSymbol;
     table?: Table | FieldSymbol;
 }
-export declare class ModifyDatabase {
-    private readonly context;
-    constructor(context: Context);
-    modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;
-}
+export declare function modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions, context: Context): Promise<void>;

package/build/src/statements/modify_database.js

@@ -1,40 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModifyDatabase = void 0;
+exports.modifyDatabase = void 0;
 const types_1 = require("../types");
 const insert_database_1 = require("./insert_database");
 const update_database_1 = require("./update_database");
-class ModifyDatabase {
-    constructor(context) {
-        this.context = context;
+async function modifyDatabase(table, options, context) {
+    if (options.table instanceof types_1.FieldSymbol) {
+        options.table = options.table.getPointer();
     }
-    async modifyDatabase(table, options) {
-        if (options.table instanceof types_1.FieldSymbol) {
-            options.table = options.table.getPointer();
-        }
-        if (options.values instanceof types_1.FieldSymbol) {
-            options.values = options.values.getPointer();
-        }
-        const insert = new insert_database_1.InsertDatabase(this.context);
-        const update = new update_database_1.UpdateDatabase(this.context);
-        if (options.table) {
-            for (const row of options.table.array()) {
-                const subrc = await insert.insertDatabase(table, { values: row });
-                if (subrc !== 0) {
-                    await update.updateDatabase(table, { from: row });
-                }
-            }
-        }
-        else if (options.values) {
-            const subrc = await insert.insertDatabase(table, { values: options.values });
+    if (options.values instanceof types_1.FieldSymbol) {
+        options.values = options.values.getPointer();
+    }
+    if (options.table) {
+        for (const row of options.table.array()) {
+            const subrc = await (0, insert_database_1.insertDatabase)(table, { values: row }, context);
             if (subrc !== 0) {
-                await update.updateDatabase(table, { from: options.values });
+                await (0, update_database_1.updateDatabase)(table, { from: row }, context);
             }
         }
-        else {
-            throw "modifyDatabase todo";
+    }
+    else if (options.values) {
+        const subrc = await (0, insert_database_1.insertDatabase)(table, { values: options.values }, context);
+        if (subrc !== 0) {
+            await (0, update_database_1.updateDatabase)(table, { from: options.values }, context);
         }
     }
+    else {
+        throw "modifyDatabase todo";
+    }
 }
-exports.ModifyDatabase = ModifyDatabase;
+exports.modifyDatabase = modifyDatabase;
 //# sourceMappingURL=modify_database.js.map

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

@@ -0,0 +1,2 @@
+import { Context } from "../context";
+export declare function openCursor(context: Context, select: string): Promise<number>;

package/build/src/statements/open_cursor.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openCursor = void 0;
+async function openCursor(context, select) {
+    const callbacks = await context.defaultDB().openCursor({ select: select });
+    const num = context.cursorCounter++;
+    context.cursors[num] = callbacks;
+    return num;
+}
+exports.openCursor = openCursor;
+//# sourceMappingURL=open_cursor.js.map

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

@@ -1,8 +1,5 @@
 import { Context } from "../context";
-import { SelectDatabaseOptions, SelectRuntimeOptions } from "../db/db";
+import { DatabaseRows, SelectDatabaseOptions, SelectRuntimeOptions } from "../db/db";
 import { FieldSymbol, HashedTable, Structure, Table } from "../types";
-export declare class SelectDatabase {
-    private readonly context;
-    constructor(context: Context);
-    select(target: Structure | Table | HashedTable | FieldSymbol, input: SelectDatabaseOptions, runtimeOptions?: SelectRuntimeOptions): Promise<void>;
-}
+export declare function select(target: Structure | Table | HashedTable | FieldSymbol, input: SelectDatabaseOptions, runtimeOptions: SelectRuntimeOptions, context: Context): Promise<void>;
+export declare function rowsToTarget(target: Structure | Table | HashedTable | FieldSymbol, rows: DatabaseRows): void;

package/build/src/statements/select.js

@@ -1,91 +1,90 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectDatabase = void 0;
+exports.rowsToTarget = exports.select = void 0;
 const clone_1 = require("../clone");
 const types_1 = require("../types");
-class SelectDatabase {
-    constructor(context) {
-        this.context = context;
-    }
-    async select(target, input, runtimeOptions) {
-        var _a, _b;
-        const { rows: rows } = await this.context.defaultDB().select(input);
-        if (target instanceof types_1.FieldSymbol) {
-            if (target.isAssigned() === false) {
-                throw new Error("GETWA_NOT_ASSIGNED");
-            }
-            // @ts-ignore
-            target = target.getPointer();
+async function select(target, input, runtimeOptions, context) {
+    const { rows: rows } = await context.defaultDB().select(input);
+    if (target instanceof types_1.FieldSymbol) {
+        if (target.isAssigned() === false) {
+            throw new Error("GETWA_NOT_ASSIGNED");
         }
-        if ((runtimeOptions === null || runtimeOptions === void 0 ? void 0 : runtimeOptions.appending) !== true) {
-            if (Array.isArray(target)) {
-                target.forEach(f => f.clear());
-            }
-            else {
-                target === null || target === void 0 ? void 0 : target.clear();
-            }
+        // @ts-ignore
+        target = target.getPointer();
+    }
+    if ((runtimeOptions === null || runtimeOptions === void 0 ? void 0 : runtimeOptions.appending) !== true) {
+        if (Array.isArray(target)) {
+            target.forEach(f => f.clear());
         }
-        if (rows.length === 0) {
-            // @ts-ignore
-            abap.builtin.sy.get().dbcnt.set(0);
-            // @ts-ignore
-            abap.builtin.sy.get().subrc.set(4);
-            return;
+        else {
+            target === null || target === void 0 ? void 0 : target.clear();
         }
-        if (target instanceof types_1.Structure) {
-            const result = {};
-            for (const column in rows[0]) {
-                if (rows[0][column] === null || target.get()[column] === undefined) {
-                    continue;
-                }
-                result[column] = (0, clone_1.clone)(target.get()[column]).set(rows[0][column]);
+    }
+    if (rows.length === 0) {
+        // @ts-ignore
+        abap.builtin.sy.get().dbcnt.set(0);
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(4);
+        return;
+    }
+    rowsToTarget(target, rows);
+    if (target === undefined && rows.length === 1) {
+        // @ts-ignore
+        abap.builtin.sy.get().dbcnt.set(Object.values(rows[0])[0]);
+    }
+    else {
+        // @ts-ignore
+        abap.builtin.sy.get().dbcnt.set(rows.length);
+    }
+    // @ts-ignore
+    abap.builtin.sy.get().subrc.set(0);
+}
+exports.select = select;
+function rowsToTarget(target, rows) {
+    var _a, _b;
+    if (target instanceof types_1.Structure) {
+        const result = {};
+        for (const column in rows[0]) {
+            if (rows[0][column] === null || target.get()[column] === undefined) {
+                continue;
             }
-            // @ts-ignore
-            abap.statements.moveCorresponding(new types_1.Structure(result), target);
+            result[column] = (0, clone_1.clone)(target.get()[column]).set(rows[0][column]);
         }
-        else if (target instanceof types_1.Table || target instanceof types_1.HashedTable) {
-            for (const row of rows) {
-                const targetRow = (0, clone_1.clone)(target.getRowType());
-                if (targetRow instanceof types_1.Structure) {
-                    for (let columnName in row) {
-                        columnName = columnName.toLowerCase();
-                        if (row[columnName] === null) {
-                            (_a = targetRow.get()[columnName]) === null || _a === void 0 ? void 0 : _a.clear();
-                            continue;
-                        }
-                        // @ts-ignore
-                        (_b = targetRow.get()[columnName]) === null || _b === void 0 ? void 0 : _b.set(row[columnName]);
+        // @ts-ignore
+        abap.statements.moveCorresponding(new types_1.Structure(result), target);
+    }
+    else if (target instanceof types_1.Table || target instanceof types_1.HashedTable) {
+        for (const row of rows) {
+            const targetRow = (0, clone_1.clone)(target.getRowType());
+            if (targetRow instanceof types_1.Structure) {
+                for (let columnName in row) {
+                    columnName = columnName.toLowerCase();
+                    if (row[columnName] === null) {
+                        (_a = targetRow.get()[columnName]) === null || _a === void 0 ? void 0 : _a.clear();
+                        continue;
                     }
+                    // @ts-ignore
+                    (_b = targetRow.get()[columnName]) === null || _b === void 0 ? void 0 : _b.set(row[columnName]);
                 }
-                else {
-                    const columnName = Object.keys(row)[0];
-                    targetRow.set(row[columnName]);
-                }
-                // @ts-ignore
-                abap.statements.insertInternal({ table: target, data: targetRow, noClone: true });
             }
-        }
-        else if (Array.isArray(target)) {
-            for (let index = 0; index < target.length; index++) {
-                const element = target[index];
-                element.set(rows[0][Object.keys(rows[0])[index]]);
+            else {
+                const columnName = Object.keys(row)[0];
+                targetRow.set(row[columnName]);
             }
-        }
-        else if (target !== undefined) {
-            // its a simple type
-            target.set(rows[0][Object.keys(rows[0])[0]]);
-        }
-        if (target === undefined && rows.length === 1) {
             // @ts-ignore
-            abap.builtin.sy.get().dbcnt.set(Object.values(rows[0])[0]);
+            abap.statements.insertInternal({ table: target, data: targetRow, noClone: true });
         }
-        else {
-            // @ts-ignore
-            abap.builtin.sy.get().dbcnt.set(rows.length);
+    }
+    else if (Array.isArray(target)) {
+        for (let index = 0; index < target.length; index++) {
+            const element = target[index];
+            element.set(rows[0][Object.keys(rows[0])[index]]);
         }
-        // @ts-ignore
-        abap.builtin.sy.get().subrc.set(0);
+    }
+    else if (target !== undefined) {
+        // its a simple type
+        target.set(rows[0][Object.keys(rows[0])[0]]);
     }
 }
-exports.SelectDatabase = SelectDatabase;
+exports.rowsToTarget = rowsToTarget;
 //# sourceMappingURL=select.js.map

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

@@ -7,8 +7,4 @@ export interface IUpdateDatabaseOptions {
     set?: string[];
     where?: string;
 }
-export declare class UpdateDatabase {
-    private readonly context;
-    constructor(context: Context);
-    updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions): Promise<number>;
-}
+export declare function updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions, context: Context): Promise<number>;

package/build/src/statements/update_database.js

@@ -1,59 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateDatabase = void 0;
+exports.updateDatabase = void 0;
 const prefix_1 = require("../prefix");
 const types_1 = require("../types");
 const insert_database_1 = require("./insert_database");
-class UpdateDatabase {
-    constructor(context) {
-        this.context = context;
+async function updateDatabase(table, options, context) {
+    if (options.table instanceof types_1.FieldSymbol) {
+        options.table = options.table.getPointer();
     }
-    async updateDatabase(table, options) {
-        if (options.table instanceof types_1.FieldSymbol) {
-            options.table = options.table.getPointer();
-        }
-        if (options.from instanceof types_1.FieldSymbol) {
-            options.from = options.from.getPointer();
-        }
-        if (typeof table !== "string") {
-            table = table.get();
-        }
-        // @ts-ignore
-        const keys = abap.DDIC[table.toUpperCase()].keyFields;
-        const where = [];
-        const set = [];
-        if (options.from) {
-            const structure = options.from.get();
-            for (const k of Object.keys(structure)) {
-                const str = k + " = " + (0, insert_database_1.toValue)(structure[k].get());
-                if (keys.includes(k.toUpperCase())) {
-                    where.push(str);
-                }
-                else {
-                    set.push(str);
-                }
+    if (options.from instanceof types_1.FieldSymbol) {
+        options.from = options.from.getPointer();
+    }
+    if (typeof table !== "string") {
+        table = table.get();
+    }
+    // @ts-ignore
+    const keys = abap.DDIC[table.toUpperCase()].keyFields;
+    const where = [];
+    const set = [];
+    if (options.from) {
+        const structure = options.from.get();
+        for (const k of Object.keys(structure)) {
+            const str = k + " = " + (0, insert_database_1.toValue)(structure[k].get());
+            if (keys.includes(k.toUpperCase())) {
+                where.push(str);
             }
-        }
-        else if (options.set) {
-            if (options.where) {
-                where.push(options.where);
+            else {
+                set.push(str);
             }
-            set.push(...options.set);
         }
-        else {
-            throw "updateDatabase, todo";
+    }
+    else if (options.set) {
+        if (options.where) {
+            where.push(options.where);
         }
-        const { subrc, dbcnt } = await this.context.defaultDB().update({
-            table: (0, prefix_1.buildDbTableName)(table),
-            where: where.join(" AND "),
-            set,
-        });
-        // @ts-ignore
-        abap.builtin.sy.get().subrc.set(subrc);
-        // @ts-ignore
-        abap.builtin.sy.get().dbcnt.set(dbcnt);
-        return subrc;
+        set.push(...options.set);
+    }
+    else {
+        throw "updateDatabase, todo";
     }
+    const { subrc, dbcnt } = await context.defaultDB().update({
+        table: (0, prefix_1.buildDbTableName)(table),
+        where: where.join(" AND "),
+        set,
+    });
+    // @ts-ignore
+    abap.builtin.sy.get().subrc.set(subrc);
+    // @ts-ignore
+    abap.builtin.sy.get().dbcnt.set(dbcnt);
+    return subrc;
 }
-exports.UpdateDatabase = UpdateDatabase;
+exports.updateDatabase = updateDatabase;
 //# sourceMappingURL=update_database.js.map

package/package.json

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