@abaplint/runtime 1.8.39 → 2.0.1

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/compare/cs.js

@@ -9,6 +9,7 @@ function cs(left, right) {
     else {
         l = left.get().toString();
     }
+    l = l.toUpperCase();
     let r = "";
     if (typeof right === "string") {
         r = right.toString();
@@ -16,6 +17,7 @@ function cs(left, right) {
     else {
         r = right.get().toString();
     }
+    r = r.toUpperCase();
     const index = l.indexOf(r);
     if (index < 0) {
         // @ts-ignore

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>;
+}

package/build/src/statements/insert_database.js

@@ -1,34 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insertDatabase = void 0;
-function insertDatabase(table, options) {
-    if (this.db === undefined) {
-        throw new Error("Runtime, database not initialized");
+exports.InsertDatabase = void 0;
+class InsertDatabase {
+    constructor(context) {
+        this.context = context;
     }
-    const columns = [];
-    const values = [];
-    const structure = options.values.get();
-    for (const k of Object.keys(structure)) {
-        columns.push(k);
-        // todo, integers should not be surrounded by '"'?
-        values.push('"' + structure[k].get() + '"');
+    async insertDatabase(table, options) {
+        const columns = [];
+        const values = [];
+        const structure = options.values.get();
+        for (const k of Object.keys(structure)) {
+            columns.push(k);
+            // todo, integers should not be surrounded by '"'?
+            values.push('"' + structure[k].get() + '"');
+        }
+        if (typeof table !== "string") {
+            table = table.get();
+        }
+        const { subrc, dbcnt } = await this.context.defaultDB().insert({ table, columns, values });
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(subrc);
+        // @ts-ignore
+        abap.builtin.sy.get().dbcnt.set(dbcnt);
+        return subrc;
     }
-    if (typeof table !== "string") {
-        table = table.get();
-    }
-    const sql = `INSERT INTO ${table} (${columns.join(",")}) VALUES (${values.join(",")})`;
-    //  console.dir(sql);
-    let subrc = 0;
-    try {
-        this.db.exec(sql);
-    }
-    catch (error) {
-        // eg "UNIQUE constraint failed" errors
-        subrc = 4;
-    }
-    // @ts-ignore
-    abap.builtin.sy.get().subrc.set(subrc);
-    return subrc;
 }
-exports.insertDatabase = insertDatabase;
+exports.InsertDatabase = InsertDatabase;
 //# sourceMappingURL=insert_database.js.map

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

@@ -1,3 +1,4 @@
+import { Context } from "../context";
 import { ICharacter } from "../types/_character";
 export interface IMessageOptions {
     id?: ICharacter | string;
@@ -6,4 +7,8 @@ export interface IMessageOptions {
     with?: (ICharacter | string)[];
     into?: ICharacter;
 }
-export declare function message(options: IMessageOptions): void;
+export declare class MessageStatement {
+    private readonly context;
+    constructor(context: Context);
+    message(options: IMessageOptions): Promise<void>;
+}

package/build/src/statements/message.js

@@ -1,27 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.message = void 0;
-function message(options) {
-    let arbgb = options.id;
-    if (arbgb !== undefined && typeof arbgb !== "string") {
-        arbgb = arbgb.get();
-    }
-    arbgb = arbgb === null || arbgb === void 0 ? void 0 : arbgb.toUpperCase();
-    // @ts-ignore
-    abap.builtin.sy.get().msgid.set(arbgb);
-    let msgnr = options.number;
-    if (msgnr !== undefined && typeof msgnr !== "string") {
-        msgnr = msgnr.get();
-    }
-    // @ts-ignore
-    abap.builtin.sy.get().msgno.set(msgnr);
-    const text = findText.bind(this)(arbgb, msgnr);
-    const replaced = replace(text, options.with);
-    if (options.into) {
-        options.into.set(replaced);
-    }
-}
-exports.message = message;
+exports.MessageStatement = void 0;
 function replace(text, w) {
     for (let i = 0; i < 6; i++) {
         const search = "&" + (i + 1);
@@ -44,19 +23,15 @@ function replace(text, w) {
     }
     return text.trim();
 }
-function findText(arbgb, msgnr) {
+async function findText(context, arbgb, msgnr) {
     let text = undefined;
-    const db = this.db;
-    if (db && arbgb && msgnr) {
+    if (arbgb && msgnr) {
         try {
-            const stmt = db.prepare("SELECT * FROM t100 WHERE sprsl=:sprsl AND arbgb=:arbgb AND msgnr=:msgnr LIMIT 1");
-            const result = stmt.getAsObject({
-                ":sprsl": "E",
-                ":arbgb": arbgb,
-                ":msgnr": msgnr,
-            });
-            if (result.text) {
-                text = result.text;
+            // todo, sql injection?
+            const select = `SELECT * FROM t100 WHERE sprsl='E' AND arbgb='${arbgb}' AND msgnr='${msgnr}' LIMIT 1`;
+            const { rows: result } = await context.defaultDB().select({ select });
+            if (result[0]) {
+                text = result[0]["text"];
             }
         }
         catch (_a) {
@@ -69,4 +44,30 @@ function findText(arbgb, msgnr) {
     }
     return text;
 }
+class MessageStatement {
+    constructor(context) {
+        this.context = context;
+    }
+    async message(options) {
+        let arbgb = options.id;
+        if (arbgb !== undefined && typeof arbgb !== "string") {
+            arbgb = arbgb.get();
+        }
+        arbgb = arbgb === null || arbgb === void 0 ? void 0 : arbgb.toUpperCase();
+        // @ts-ignore
+        abap.builtin.sy.get().msgid.set(arbgb);
+        let msgnr = options.number;
+        if (msgnr !== undefined && typeof msgnr !== "string") {
+            msgnr = msgnr.get();
+        }
+        // @ts-ignore
+        abap.builtin.sy.get().msgno.set(msgnr);
+        const text = await findText(this.context, arbgb, msgnr);
+        const replaced = replace(text, options.with);
+        if (options.into) {
+            options.into.set(replaced);
+        }
+    }
+}
+exports.MessageStatement = MessageStatement;
 //# sourceMappingURL=message.js.map

package/build/src/statements/modify_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 IModifyDatabaseOptions {
     from?: Structure | FieldSymbol;
     table?: Table | FieldSymbol;
 }
-export declare function modifyDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): void;
+export declare class ModifyDatabase {
+    private readonly context;
+    constructor(context: Context);
+    modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;
+}

package/build/src/statements/modify_database.js

@@ -1,36 +1,40 @@
 "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");
-function modifyDatabase(table, options) {
-    if (this.db === undefined) {
-        throw new Error("Runtime, database not initialized");
+class ModifyDatabase {
+    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()) {
-            const subrc = insert_database_1.insertDatabase.bind(this)(table, { values: row });
+    async modifyDatabase(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();
+        }
+        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.from) {
+            const subrc = await insert.insertDatabase(table, { values: options.from });
             if (subrc !== 0) {
-                update_database_1.updateDatabase.bind(this)(table, { from: row });
+                await update.updateDatabase(table, { from: options.from });
             }
         }
-    }
-    else if (options.from) {
-        const subrc = insert_database_1.insertDatabase.bind(this)(table, { values: options.from });
-        if (subrc !== 0) {
-            update_database_1.updateDatabase.bind(this)(table, { from: options.from });
+        else {
+            throw "modifyDatabase todo";
         }
     }
-    else {
-        throw "modifyDatabase todo";
-    }
 }
-exports.modifyDatabase = modifyDatabase;
+exports.ModifyDatabase = ModifyDatabase;
 //# sourceMappingURL=modify_database.js.map

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

@@ -1,2 +1,7 @@
+import { Context } from "../context";
 import { FieldSymbol, Structure, Table } from "../types";
-export declare function select(target: Structure | Table | FieldSymbol, select: string): void;
+export declare class SelectDatabase {
+    private readonly context;
+    constructor(context: Context);
+    select(target: Structure | Table | FieldSymbol, select: string): Promise<void>;
+}

package/build/src/statements/select.js

@@ -1,70 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.select = void 0;
+exports.SelectDatabase = void 0;
 const clone_1 = require("../clone");
 const types_1 = require("../types");
-function select(target, select) {
-    var _a, _b, _c;
-    if (this.db === undefined) {
-        throw new Error("Runtime, database not initialized");
+class SelectDatabase {
+    constructor(context) {
+        this.context = context;
     }
-    let res = undefined;
-    try {
-        res = this.db.exec(select);
-    }
-    catch (error) {
-        // @ts-ignore
-        if (abap.Classes["CX_SY_DYNAMIC_OSQL_SEMANTICS"] !== undefined) {
+    async select(target, select) {
+        var _a;
+        const { rows: rows } = await this.context.defaultDB().select({ select });
+        if (target instanceof types_1.FieldSymbol) {
+            if (target.isAssigned() === false) {
+                throw "select, fs not assigned";
+            }
             // @ts-ignore
-            throw new abap.Classes["CX_SY_DYNAMIC_OSQL_SEMANTICS"]();
+            target = target.getPointer();
         }
-        throw error;
-    }
-    if (target instanceof types_1.FieldSymbol) {
-        // @ts-ignore
-        target = target.getPointer();
-    }
-    target.clear();
-    if (target instanceof types_1.Structure) {
-        if (((_a = res[0]) === null || _a === void 0 ? void 0 : _a.values[0]) === undefined) {
+        target.clear();
+        if (rows.length === 0) {
             // @ts-ignore
             abap.builtin.sy.get().subrc.set(4);
+            return;
         }
-        else {
-            const columns = res[0].columns;
-            const values = res[0].values[0];
+        if (target instanceof types_1.Structure) {
             const result = {};
-            for (const c of columns) {
-                result[c] = (0, clone_1.clone)(target.get()[c]).set(values.shift());
+            for (const column in rows[0]) {
+                result[column] = (0, clone_1.clone)(target.get()[column]).set(rows[0][column]);
             }
             target.set(new types_1.Structure(result));
-            // @ts-ignore
-            abap.builtin.sy.get().subrc.set(0);
-        }
-    }
-    else if (target instanceof types_1.Table) {
-        if (((_b = res[0]) === null || _b === void 0 ? void 0 : _b.values[0]) === undefined) {
-            // @ts-ignore
-            abap.builtin.sy.get().subrc.set(4);
         }
-        else {
-            for (const selectRow of res[0].values) {
+        else if (target instanceof types_1.Table) {
+            for (const row of rows) {
                 const targetRow = (0, clone_1.clone)(target.getRowType());
-                const values = selectRow;
-                for (const c of res[0].columns) {
+                for (const columnName in row) {
+                    // todo, non structured table = table with simple rows
                     // @ts-ignore
-                    (_c = targetRow.get()[c]) === null || _c === void 0 ? void 0 : _c.set(values.shift());
+                    (_a = targetRow.get()[columnName]) === null || _a === void 0 ? void 0 : _a.set(row[columnName]);
                 }
                 // @ts-ignore
                 abap.statements.insertInternal({ table: target, data: targetRow });
             }
-            // @ts-ignore
-            abap.builtin.sy.get().subrc.set(0);
         }
-    }
-    else {
-        throw new Error("Runtime, SELECT todo");
+        else {
+            throw new Error("Runtime, SELECT todo");
+        }
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(0);
     }
 }
-exports.select = select;
+exports.SelectDatabase = SelectDatabase;
 //# sourceMappingURL=select.js.map

package/build/src/statements/update_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 IUpdateDatabaseOptions {
     from?: Structure | FieldSymbol;
     table?: Table | FieldSymbol;
 }
-export declare function updateDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): number;
+export declare class UpdateDatabase {
+    private readonly context;
+    constructor(context: Context);
+    updateDatabase(table: string | ICharacter, options: IUpdateDatabaseOptions): Promise<number>;
+}

package/build/src/statements/update_database.js

@@ -1,51 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateDatabase = void 0;
+exports.UpdateDatabase = void 0;
 const types_1 = require("../types");
-function updateDatabase(table, options) {
-    if (this.db === undefined) {
-        throw new Error("Runtime, database not initialized");
+class UpdateDatabase {
+    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 (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)) {
-            // todo, integers should not be surrounded by '"'?
-            const str = k + ' = "' + structure[k].get() + '"';
-            if (keys.includes(k.toUpperCase())) {
-                where.push(str);
-            }
-            else {
-                set.push(str);
+    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)) {
+                // todo, integers should not be surrounded by '"'?
+                const str = k + ' = "' + structure[k].get() + '"';
+                if (keys.includes(k.toUpperCase())) {
+                    where.push(str);
+                }
+                else {
+                    set.push(str);
+                }
             }
         }
+        else {
+            throw "updateDatabase, todo";
+        }
+        const { subrc, dbcnt } = await this.context.defaultDB().update({ 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;
     }
-    else {
-        throw "updateDatabase, todo";
-    }
-    const sql = `UPDATE ${table} SET ${set.join(", ")} WHERE ${where.join(" AND ")}`;
-    let subrc = 0;
-    try {
-        this.db.exec(sql);
-    }
-    catch (error) {
-        subrc = 4;
-    }
-    // @ts-ignore
-    abap.builtin.sy.get().subrc.set(subrc);
-    return subrc;
 }
-exports.updateDatabase = updateDatabase;
+exports.UpdateDatabase = UpdateDatabase;
 //# sourceMappingURL=update_database.js.map

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

@@ -1,10 +1,14 @@
+import { Context } from "../context";
 import { FieldSymbol } from "../types/field_symbol";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
-interface IWriteOptions {
+export interface IWriteOptions {
     newLine?: boolean;
     skipLine?: boolean;
     target?: ICharacter;
 }
-export declare function write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
-export {};
+export declare class WriteStatement {
+    private readonly context;
+    constructor(context: Context);
+    write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
+}

package/build/src/statements/write.js

@@ -1,41 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.write = void 0;
+exports.WriteStatement = void 0;
 const types_1 = require("../types");
-function write(source, options) {
-    if ((options === null || options === void 0 ? void 0 : options.skipLine) === true) {
-        this.console.add("\n");
+class WriteStatement {
+    constructor(context) {
+        this.context = context;
     }
-    else {
-        if ((options === null || options === void 0 ? void 0 : options.newLine) === true && this.console.get().length > 0) {
-            this.console.add("\n");
-        }
-        if (typeof source === "string" || typeof source === "number") {
-            if (options === null || options === void 0 ? void 0 : options.target) {
-                options.target.set(source.toString());
-            }
-            else {
-                this.console.add(source.toString());
-            }
+    write(source, options) {
+        if ((options === null || options === void 0 ? void 0 : options.skipLine) === true) {
+            this.context.console.add("\n");
         }
         else {
-            if (source instanceof types_1.Structure) {
-                const obj = source.get();
-                for (const f in obj) {
-                    // @ts-ignore
-                    abap.statements.write(obj[f]);
+            if ((options === null || options === void 0 ? void 0 : options.newLine) === true && this.context.console.get().length > 0) {
+                this.context.console.add("\n");
+            }
+            if (typeof source === "string" || typeof source === "number") {
+                if (options === null || options === void 0 ? void 0 : options.target) {
+                    options.target.set(source.toString());
+                }
+                else {
+                    this.context.console.add(source.toString());
                 }
             }
             else {
-                if (options === null || options === void 0 ? void 0 : options.target) {
-                    options.target.set(source.get().toString());
+                if (source instanceof types_1.Structure) {
+                    const obj = source.get();
+                    for (const f in obj) {
+                        // @ts-ignore
+                        abap.statements.write(obj[f]);
+                    }
                 }
                 else {
-                    this.console.add(source.get().toString());
+                    if (options === null || options === void 0 ? void 0 : options.target) {
+                        options.target.set(source.get().toString());
+                    }
+                    else {
+                        this.context.console.add(source.get().toString());
+                    }
                 }
             }
         }
     }
 }
-exports.write = write;
+exports.WriteStatement = WriteStatement;
 //# sourceMappingURL=write.js.map

package/build/src/template_formatting.d.ts

@@ -7,6 +7,7 @@ declare type options = {
     pad?: string;
     width?: number;
     decimals?: number;
+    align?: "left" | "right";
 };
 export declare function templateFormatting(source: ICharacter | INumeric, options: options): string;
 export {};

package/build/src/template_formatting.js

@@ -14,7 +14,12 @@ function templateFormatting(source, options) {
         text = text.substr(0, 2) + ":" + text.substr(2, 2) + ":" + text.substr(4, 2);
     }
     if (options.width && options.pad) {
-        text = text.trimEnd().padEnd(options.width, options.pad);
+        if (options.align === "right") {
+            text = text.trimEnd().padStart(options.width, options.pad);
+        }
+        else {
+            text = text.trimEnd().padEnd(options.width, options.pad);
+        }
     }
     else if (options.width) {
         text = text.trimEnd().padEnd(options.width, " ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "1.8.39",
+  "version": "2.0.1",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -10,6 +10,7 @@
   },
   "scripts": {
     "compile": "tsc",
+    "publish:major": "npm --no-git-tag-version version major && rm -rf build && npm install && npm run test && npm publish --access public",
     "publish:minor": "npm --no-git-tag-version version minor && rm -rf build && npm install && npm run test && npm publish --access public",
     "publish:patch": "npm --no-git-tag-version version patch && rm -rf build && npm install && npm run test && npm publish --access public",
     "test": "npm run compile && mocha"
@@ -26,9 +27,6 @@
   ],
   "author": "abaplint",
   "license": "MIT",
-  "dependencies": {
-    "sql.js": "^1.6.2"
-  },
   "devDependencies": {
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.1.0",