@abaplint/runtime 1.8.40 → 2.0.2

package/README.md

@@ -1,3 +1,3 @@
-# @abaplint/runtime
-
+# @abaplint/runtime
+
 Runtime

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

@@ -10,6 +10,7 @@ export * from "./escape";
 export * from "./find";
 export * from "./floor";
 export * from "./frac";
+export * from "./insert";
 export * from "./lines";
 export * from "./nmax";
 export * from "./nmin";

package/build/src/builtin/index.js

@@ -27,6 +27,7 @@ __exportStar(require("./escape"), exports);
 __exportStar(require("./find"), exports);
 __exportStar(require("./floor"), exports);
 __exportStar(require("./frac"), exports);
+__exportStar(require("./insert"), exports);
 __exportStar(require("./lines"), exports);
 __exportStar(require("./nmax"), exports);
 __exportStar(require("./nmin"), exports);

package/build/src/builtin/insert.d.ts

@@ -0,0 +1,9 @@
+import { String } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IInsertInput {
+    val: ICharacter;
+    sub: ICharacter;
+    off?: INumeric;
+}
+export declare function insert(input: IInsertInput): String;

package/build/src/builtin/insert.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insert = void 0;
+const types_1 = require("../types");
+function insert(input) {
+    let value = input.val.get();
+    let offset = 0;
+    if (input.off) {
+        offset = input.off.get();
+    }
+    value = value.substring(0, offset) + input.sub.get() + value.substring(offset);
+    return new types_1.String().set(value);
+}
+exports.insert = insert;
+//# sourceMappingURL=insert.js.map

package/build/src/builtin/sy.js

@@ -6,6 +6,7 @@ exports.sy = new types_1.Structure({
     abcde: new types_1.Character({ length: 26 }).set("ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
     datlo: new types_1.Date(),
     datum: new types_1.Date(),
+    dbcnt: new types_1.Integer(),
     fdpos: new types_1.Integer(),
     index: new types_1.Integer(),
     langu: new types_1.Character({ length: 1 }).set("E"),
@@ -19,6 +20,7 @@ exports.sy = new types_1.Structure({
     subrc: new types_1.Integer(),
     sysid: new types_1.Character({ length: 3 }).set("ABC"),
     tabix: new types_1.Integer(),
+    tzone: new types_1.Integer(),
     timlo: new types_1.Time(),
     uname: new types_1.Character({ length: 12 }).set("USERNAME"),
     uzeit: new types_1.Time(),

package/build/src/context.d.ts

@@ -0,0 +1,13 @@
+import { Console } from "./console";
+import { DatabaseClient } from "./db/db";
+import * as RFC from "./rfc";
+export declare class Context {
+    console: Console;
+    databaseConnections: {
+        [name: string]: DatabaseClient;
+    };
+    RFCDestinations: {
+        [name: string]: RFC.RFCClient;
+    };
+    defaultDB(): DatabaseClient;
+}

package/build/src/context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+class Context {
+    constructor() {
+        // DEFAULT and secondary database connections
+        this.databaseConnections = {};
+        this.RFCDestinations = {};
+    }
+    defaultDB() {
+        if (this.databaseConnections["DEFAULT"] === undefined) {
+            throw new Error("Runtime, database not initialized");
+        }
+        return this.databaseConnections["DEFAULT"];
+    }
+}
+exports.Context = Context;
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,49 @@
+export interface DeleteDatabaseOptions {
+    table: string;
+    where: string;
+}
+export interface UpdateDatabaseOptions {
+    table: string;
+    where: string;
+    set: string[];
+}
+export interface InsertDatabaseOptions {
+    table: string;
+    columns: string[];
+    values: string[];
+}
+export interface SelectDatabaseOptions {
+    select: string;
+}
+export declare type DatabaseValue = number | string | Uint8Array | null;
+export declare type DatabaseRow = {
+    [name: string]: DatabaseValue;
+};
+export declare type DatabaseRows = DatabaseRow[];
+export interface SelectDatabaseResult {
+    rows: DatabaseRows;
+}
+export interface DatabaseClient {
+    /*** the type/name/identifier of the database */
+    name: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /*** execute any native SQL command */
+    execute(sql: string): Promise<void>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    delete(options: DeleteDatabaseOptions): Promise<{
+        subrc: number;
+        dbcnt: number;
+    }>;
+    update(options: UpdateDatabaseOptions): Promise<{
+        subrc: number;
+        dbcnt: number;
+    }>;
+    insert(options: InsertDatabaseOptions): Promise<{
+        subrc: number;
+        dbcnt: number;
+    }>;
+    select(options: SelectDatabaseOptions): Promise<SelectDatabaseResult>;
+}

package/build/src/db/db.js

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

package/build/src/index.d.ts

@@ -1,14 +1,16 @@
-import * as types from "./types";
+import { Console } from "./console";
+import { Context } from "./context";
+import { OffsetLength } from "./offset_length";
+import { Statements } from "./statements";
+import { templateFormatting } from "./template_formatting";
+import { UnitTestResult } from "./unit_test";
 import * as builtin from "./builtin";
 import * as compare from "./compare";
+import * as DB from "./db/db";
 import * as operators from "./operators";
-import { Statements } from "./statements";
 import * as RFC from "./rfc";
-import { Console } from "./console";
-import { UnitTestResult } from "./unit_test";
-import { OffsetLength } from "./offset_length";
-import { templateFormatting } from "./template_formatting";
-export { UnitTestResult, RFC, types };
+import * as types from "./types";
+export { UnitTestResult, RFC, types, DB };
 export declare class ABAP {
     FunctionModules: {
         [name: string]: any;
@@ -22,18 +24,14 @@ export declare class ABAP {
     DDIC: {
         [name: string]: any;
     };
-    RFCDestinations: {
-        [name: string]: RFC.RFCClient;
-    };
     statements: Statements;
     types: typeof types;
     builtin: typeof builtin;
     operators: typeof operators;
     compare: typeof compare;
-    console: Console;
-    db: undefined | any;
+    readonly console: Console;
     OffsetLength: typeof OffsetLength;
     templateFormatting: typeof templateFormatting;
+    readonly context: Context;
     constructor();
-    initDB(sql?: string): Promise<void>;
 }

package/build/src/index.js

@@ -1,20 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ABAP = exports.types = exports.RFC = exports.UnitTestResult = void 0;
-const types = require("./types");
-exports.types = types;
+exports.ABAP = exports.DB = exports.types = exports.RFC = exports.UnitTestResult = void 0;
+const console_1 = require("./console");
+const context_1 = require("./context");
+const offset_length_1 = require("./offset_length");
+const statements_1 = require("./statements");
+const template_formatting_1 = require("./template_formatting");
+const unit_test_1 = require("./unit_test");
+Object.defineProperty(exports, "UnitTestResult", { enumerable: true, get: function () { return unit_test_1.UnitTestResult; } });
 const builtin = require("./builtin");
 const compare = require("./compare");
+const DB = require("./db/db");
+exports.DB = DB;
 const operators = require("./operators");
-const statements_1 = require("./statements");
 const RFC = require("./rfc");
 exports.RFC = RFC;
-const sql_js_1 = require("sql.js");
-const console_1 = require("./console");
-const unit_test_1 = require("./unit_test");
-Object.defineProperty(exports, "UnitTestResult", { enumerable: true, get: function () { return unit_test_1.UnitTestResult; } });
-const offset_length_1 = require("./offset_length");
-const template_formatting_1 = require("./template_formatting");
+const types = require("./types");
+exports.types = types;
 class ABAP {
     constructor() {
         // global objects
@@ -22,28 +24,22 @@ class ABAP {
         this.Classes = {};
         this.Interfaces = {};
         this.DDIC = {};
-        // RFC Destinations
-        this.RFCDestinations = {};
         this.types = types;
         this.builtin = builtin;
         this.operators = operators;
         this.compare = compare;
         this.OffsetLength = offset_length_1.OffsetLength;
         this.templateFormatting = template_formatting_1.templateFormatting;
+        this.context = new context_1.Context();
         this.console = new console_1.Console();
-        this.statements = new statements_1.Statements(this.console);
+        this.context.console = this.console;
+        this.statements = new statements_1.Statements(this.context);
         // todo, this should not be a singleton, it should be part of this instance
+        // todo, move to context
         builtin.sy.get().subrc.set(0);
         builtin.sy.get().tabix.set(0);
         builtin.sy.get().index.set(0);
-    }
-    async initDB(sql) {
-        const SQL = await (0, sql_js_1.default)();
-        this.db = new SQL.Database();
-        if (sql && sql !== "") {
-            this.db.run(sql);
-        }
-        this.statements.setDb(this.db);
+        this.statements.getTime({ sy: builtin.sy });
     }
 }
 exports.ABAP = ABAP;

package/build/src/offset_length.js

@@ -55,7 +55,7 @@ class OffsetLength {
         }
         if (this.length) {
             val = val.substr(0, this.length);
-            if (this.isHex) {
+            if (this.isHex || this.obj instanceof types_1.Time) {
                 val = val.padStart(this.length, "0");
             }
         }

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

@@ -1,3 +1,4 @@
+import { Context } from "../context";
 export interface ICallFunctionOptions {
     name: string;
     destination: string;
@@ -7,4 +8,8 @@ export interface ICallFunctionOptions {
     changing?: any;
     exceptions?: any;
 }
-export declare function callFunction(options: ICallFunctionOptions): Promise<void>;
+export declare class CallFunction {
+    private readonly context;
+    constructor(context: Context);
+    callFunction(options: ICallFunctionOptions): Promise<void>;
+}

package/build/src/statements/call_function.js

@@ -1,20 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callFunction = void 0;
-// note: this is only called if DESTNIATION is supplied
-async function callFunction(options) {
-    // @ts-ignore
-    const dest = abap.RFCDestinations[options.destination];
-    if (dest === undefined) {
-        throw new Error(`RFC destination ${options.destination} does not exist`);
+exports.CallFunction = void 0;
+class CallFunction {
+    constructor(context) {
+        this.context = context;
+    }
+    // note: this is only called if DESTINIATION is supplied
+    async callFunction(options) {
+        const dest = this.context.RFCDestinations[options.destination];
+        if (dest === undefined) {
+            throw new Error(`RFC destination ${options.destination} does not exist`);
+        }
+        await dest.call(options.name, {
+            exporting: options.exporting,
+            importing: options.importing,
+            tables: options.tables,
+            changing: options.changing,
+            exceptions: options.exceptions,
+        });
     }
-    await dest.call(options.name, {
-        exporting: options.exporting,
-        importing: options.importing,
-        tables: options.tables,
-        changing: options.changing,
-        exceptions: options.exceptions,
-    });
 }
-exports.callFunction = callFunction;
+exports.CallFunction = CallFunction;
 //# sourceMappingURL=call_function.js.map

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

@@ -1,7 +1,12 @@
+import { Context } from "../context";
 import { FieldSymbol, Structure, Table } from "../types";
 import { ICharacter } from "../types/_character";
-export interface IInsertDatabaseOptions {
+export interface IDeleteDatabaseOptions {
     from?: Structure | FieldSymbol;
     table?: Table | FieldSymbol;
 }
-export declare function deleteDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): void;
+export declare class DeleteDatabase {
+    private readonly context;
+    constructor(context: Context);
+    deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
+}

package/build/src/statements/delete_database.js

@@ -1,44 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteDatabase = void 0;
+exports.DeleteDatabase = void 0;
 const types_1 = require("../types");
-function deleteDatabase(table, options) {
-    if (this.db === undefined) {
-        throw new Error("Runtime, database not initialized");
+class DeleteDatabase {
+    constructor(context) {
+        this.context = context;
     }
-    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 (options.table) {
-        for (const row of options.table.array()) {
-            deleteDatabase.bind(this)(table, { from: row });
+    async deleteDatabase(table, options) {
+        if (options.table instanceof types_1.FieldSymbol) {
+            options.table = options.table.getPointer();
         }
-    }
-    else if (options.from) {
-        const where = [];
-        const structure = options.from.get();
-        for (const k of Object.keys(structure)) {
-            // todo, integers should not be surrounded by '"'?
-            const str = k + ' = "' + structure[k].get() + '"';
-            where.push(str);
+        if (options.from instanceof types_1.FieldSymbol) {
+            options.from = options.from.getPointer();
         }
-        const sql = `DELETE FROM ${table} WHERE ${where.join(" AND ")}`;
-        let subrc = 0;
-        try {
-            this.db.exec(sql);
+        if (typeof table !== "string") {
+            table = table.get();
         }
-        catch (error) {
-            subrc = 4;
+        if (options.table) {
+            for (const row of options.table.array()) {
+                this.deleteDatabase(table, { from: row });
+            }
+        }
+        else if (options.from) {
+            let where = [];
+            const structure = options.from.get();
+            for (const k of Object.keys(structure)) {
+                // todo, integers should not be surrounded by '"'?
+                const str = k + ' = "' + structure[k].get() + '"';
+                where.push(str);
+            }
+            where = where.join(" AND ");
+            const { subrc, dbcnt } = await this.context.defaultDB().delete({ table, where });
+            // @ts-ignore
+            abap.builtin.sy.get().subrc.set(subrc);
+            // @ts-ignore
+            abap.builtin.sy.get().dbcnt.set(dbcnt);
+        }
+        else {
+            throw "deleteDatabase todo";
         }
-        // @ts-ignore
-        abap.builtin.sy.get().subrc.set(subrc);
-    }
-    else {
-        throw "deleteDatabase todo";
     }
 }
-exports.deleteDatabase = deleteDatabase;
+exports.DeleteDatabase = DeleteDatabase;
 //# sourceMappingURL=delete_database.js.map

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

@@ -1,7 +1,9 @@
+import { Structure } from "../types";
 import { ICharacter } from "../types/_character";
 declare type options = {
     field?: ICharacter;
     stamp?: ICharacter;
+    sy?: Structure;
 };
 export declare function getTime(options?: options): void;
 export {};

package/build/src/statements/get_time.js

@@ -9,14 +9,17 @@ function getTime(options) {
     const time = (d.getUTCHours() + "").padStart(2, "0") +
         (d.getUTCMinutes() + "").padStart(2, "0") +
         (d.getUTCSeconds() + "").padStart(2, "0");
-    // @ts-ignore
-    abap.builtin.sy.get().datlo.set(date);
-    // @ts-ignore
-    abap.builtin.sy.get().datum.set(date);
-    // @ts-ignore
-    abap.builtin.sy.get().timlo.set(time);
-    // @ts-ignore
-    abap.builtin.sy.get().uzeit.set(time);
+    if (options === undefined) {
+        options = {};
+    }
+    if ((options === null || options === void 0 ? void 0 : options.sy) === undefined) {
+        // @ts-ignore
+        options.sy = abap.builtin.sy;
+    }
+    options.sy.get().datlo.set(date);
+    options.sy.get().datum.set(date);
+    options.sy.get().timlo.set(time);
+    options.sy.get().uzeit.set(time);
     if (options === null || options === void 0 ? void 0 : options.field) {
         options.field.set(time);
     }

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

@@ -1,12 +1,10 @@
 import { append } from "./append";
 import { assert } from "./assert";
 import { assign } from "./assign";
-import { callFunction } from "./call_function";
 import { clear } from "./clear";
 import { commit } from "./commit";
 import { concatenate } from "./concatenate";
 import { condense } from "./condense";
-import { Console } from "../console";
 import { convert } from "./convert";
 import { createData } from "./create_data";
 import { deleteInternal } from "./delete_internal";
@@ -15,25 +13,29 @@ import { find } from "./find";
 import { getBit } from "./get_bit";
 import { getRunTime } from "./get_run_time";
 import { getTime } from "./get_time";
-import { insertDatabase } from "./insert_database";
+import { IInsertDatabaseOptions } from "./insert_database";
 import { insertInternal } from "./insert_internal";
-import { deleteDatabase } from "./delete_database";
+import { IDeleteDatabaseOptions } from "./delete_database";
 import { loop } from "./loop";
-import { message } from "./message";
-import { modifyDatabase } from "./modify_database";
+import { IMessageOptions } from "./message";
+import { IModifyDatabaseOptions } from "./modify_database";
 import { modifyInternal } from "./modify_internal";
 import { moveCorresponding } from "./move_corresponding";
 import { readTable } from "./read_table";
 import { replace } from "./replace";
 import { rollback } from "./rollback";
-import { select } from "./select";
 import { setBit } from "./set_bit";
 import { shift } from "./shift";
 import { sort } from "./sort";
 import { split } from "./split";
 import { translate } from "./translate";
-import { updateDatabase } from "./update_database";
-import { write } from "./write";
+import { IUpdateDatabaseOptions } from "./update_database";
+import { IWriteOptions } from "./write";
+import { Context } from "../context";
+import { ICharacter } from "../types/_character";
+import { FieldSymbol, Structure, Table } from "../types";
+import { INumeric } from "../types/_numeric";
+import { ICallFunctionOptions } from "./call_function";
 export declare class Statements {
     append: typeof append;
     assert: typeof assert;
@@ -48,30 +50,28 @@ export declare class Statements {
     describe: typeof describe;
     find: typeof find;
     getBit: typeof getBit;
-    callFunction: typeof callFunction;
     getRunTime: typeof getRunTime;
-    deleteDatabase: typeof deleteDatabase;
     getTime: typeof getTime;
-    insertDatabase: typeof insertDatabase;
     insertInternal: typeof insertInternal;
     loop: typeof loop;
-    message: typeof message;
     modifyInternal: typeof modifyInternal;
     moveCorresponding: typeof moveCorresponding;
     readTable: typeof readTable;
-    updateDatabase: typeof updateDatabase;
-    modifyDatabase: typeof modifyDatabase;
     replace: typeof replace;
     rollback: typeof rollback;
-    select: typeof select;
     setBit: typeof setBit;
     shift: typeof shift;
     sort: typeof sort;
     split: typeof split;
     translate: typeof translate;
-    write: typeof write;
-    private readonly console;
-    private db;
-    constructor(console: Console);
-    setDb(db: any): void;
+    private readonly context;
+    constructor(context: Context);
+    deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
+    insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number>;
+    message(options: IMessageOptions): Promise<void>;
+    modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;
+    select(target: Structure | Table | FieldSymbol, select: string): Promise<void>;
+    updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions): Promise<number>;
+    callFunction(options: ICallFunctionOptions): Promise<void>;
+    write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
 }

package/build/src/statements/index.js

@@ -4,7 +4,6 @@ exports.Statements = void 0;
 const append_1 = require("./append");
 const assert_1 = require("./assert");
 const assign_1 = require("./assign");
-const call_function_1 = require("./call_function");
 const clear_1 = require("./clear");
 const commit_1 = require("./commit");
 const concatenate_1 = require("./concatenate");
@@ -36,10 +35,11 @@ const split_1 = require("./split");
 const translate_1 = require("./translate");
 const update_database_1 = require("./update_database");
 const write_1 = require("./write");
+const call_function_1 = require("./call_function");
 // this is a class, as statements like SELECT needs access to the database object instance
 // and WRITE will access the Console
 class Statements {
-    constructor(console) {
+    constructor(context) {
         this.append = append_1.append;
         this.assert = assert_1.assert;
         this.assign = assign_1.assign;
@@ -53,32 +53,45 @@ class Statements {
         this.describe = describe_1.describe;
         this.find = find_1.find;
         this.getBit = get_bit_1.getBit;
-        this.callFunction = call_function_1.callFunction;
         this.getRunTime = get_run_time_1.getRunTime;
-        this.deleteDatabase = delete_database_1.deleteDatabase;
         this.getTime = get_time_1.getTime;
-        this.insertDatabase = insert_database_1.insertDatabase;
         this.insertInternal = insert_internal_1.insertInternal;
         this.loop = loop_1.loop;
-        this.message = message_1.message;
         this.modifyInternal = modify_internal_1.modifyInternal;
         this.moveCorresponding = move_corresponding_1.moveCorresponding;
         this.readTable = read_table_1.readTable;
-        this.updateDatabase = update_database_1.updateDatabase;
-        this.modifyDatabase = modify_database_1.modifyDatabase;
         this.replace = replace_1.replace;
         this.rollback = rollback_1.rollback;
-        this.select = select_1.select;
         this.setBit = set_bit_1.setBit;
         this.shift = shift_1.shift;
         this.sort = sort_1.sort;
         this.split = split_1.split;
         this.translate = translate_1.translate;
-        this.write = write_1.write;
-        this.console = console;
+        this.context = context;
+    }
+    async deleteDatabase(table, options) {
+        return new delete_database_1.DeleteDatabase(this.context).deleteDatabase(table, options);
+    }
+    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);
+    }
+    async modifyDatabase(table, options) {
+        return new modify_database_1.ModifyDatabase(this.context).modifyDatabase(table, options);
+    }
+    async select(target, select) {
+        return new select_1.SelectDatabase(this.context).select(target, select);
+    }
+    async updateDatabase(table, options) {
+        return new update_database_1.UpdateDatabase(this.context).updateDatabase(table, options);
+    }
+    async callFunction(options) {
+        return new call_function_1.CallFunction(this.context).callFunction(options);
     }
-    setDb(db) {
-        this.db = db;
+    write(source, options) {
+        return new write_1.WriteStatement(this.context).write(source, options);
     }
 }
 exports.Statements = Statements;

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

@@ -1,6 +1,11 @@
+import { Context } from "../context";
 import { Structure } from "../types";
 import { ICharacter } from "../types/_character";
 export interface IInsertDatabaseOptions {
     values: Structure;
 }
-export declare function insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): number;
+export declare class InsertDatabase {
+    private readonly context;
+    constructor(context: Context);
+    insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number>;
+}