@abaplint/runtime 2.10.81 → 2.10.83

package/build/src/expand_dynamic.d.ts

@@ -1,2 +1,2 @@
 import { FieldSymbol } from "./types";
-export declare function expandDynamic(code: string, ev: (name: string) => FieldSymbol | undefined): string;
+export declare function expandDynamic(code: string, evaluate: (name: string) => FieldSymbol | undefined): string;

package/build/src/expand_dynamic.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandDynamic = expandDynamic;
 const expand_in_1 = require("./expand_in");
 const types_1 = require("./types");
-function expandDynamic(code, ev) {
+function expandDynamic(code, evaluate) {
     //  console.dir(code);
     if (code === "") {
         return "1 = 1";
@@ -18,7 +18,7 @@ function expandDynamic(code, ev) {
             if (match && match[1] && match[2] && match[3]) {
                 let name = "fs_" + match[2] + "_";
                 name = name.toLowerCase();
-                let found = ev(name);
+                let found = evaluate(name);
                 if (found instanceof types_1.FieldSymbol) {
                     found = found.get()[match[3].toLowerCase()];
                     if (found === undefined) {
@@ -38,7 +38,7 @@ function expandDynamic(code, ev) {
             if (match && match[1] && match[2]) {
                 let name = "fs_" + match[1] + "_";
                 name = name.toLowerCase();
-                let found = ev(name);
+                let found = evaluate(name);
                 if (found instanceof types_1.FieldSymbol) {
                     found = found.get()[match[2].toLowerCase()];
                     if (found === undefined) {
@@ -58,7 +58,7 @@ function expandDynamic(code, ev) {
             if (match && match[1]) {
                 let name = "fs_" + match[1] + "_";
                 name = name.toLowerCase();
-                const found = ev(name);
+                const found = evaluate(name);
                 if (found instanceof types_1.FieldSymbol) {
                     code = code.replace(regex, " '" + found.get() + "'");
                 }

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

@@ -50,6 +50,7 @@ import { FieldSymbol, Structure, Table } from "../types";
 import { INumeric } from "../types/_numeric";
 import { ICallFunctionOptions } from "./call_function";
 import { SelectDatabaseOptions, SelectRuntimeOptions } from "../db/db";
+import { Trace } from "../trace";
 export declare class Statements {
     append: typeof append;
     assert: typeof assert;
@@ -91,11 +92,8 @@ export declare class Statements {
     receive: typeof receive;
     callTransaction: typeof callTransaction;
     private readonly context;
-    private readonly traceTotals;
     constructor(context: Context);
-    private _trace;
-    private _traceAsync;
-    _setTrace(min?: number, totals?: boolean): void;
+    _setTrace(min?: number, totals?: boolean): Trace;
     openCursor(target: INumeric, select: string, options: IOpenCursorDatabaseOptions): Promise<void>;
     fetchNextCursor(cursor: INumeric, target: any, packageSize?: INumeric): Promise<void>;
     closeCursor(cursor: INumeric): Promise<void>;

package/build/src/statements/index.js

@@ -51,7 +51,7 @@ const call_transaction_1 = require("./call_transaction");
 const update_database_1 = require("./update_database");
 const write_1 = require("./write");
 const call_function_1 = require("./call_function");
-const types_1 = require("util/types");
+const trace_1 = require("../trace");
 // this is a class, as statements like SELECT needs access to the database object instance
 // and WRITE will access the Console
 class Statements {
@@ -96,66 +96,9 @@ class Statements {
         this.receive = receive_1.receive;
         this.callTransaction = call_transaction_1.callTransaction;
         this.context = context;
-        this.traceTotals = {};
-    }
-    _trace(func, name, min, totals) {
-        const tt = this.traceTotals;
-        const exec = (...options) => {
-            const start = Date.now();
-            const result = func.bind(this)(...options);
-            const runtime = Date.now() - start;
-            if (totals === true) {
-                if (tt[name] === undefined) {
-                    tt[name] = 0;
-                }
-                tt[name] += runtime;
-            }
-            if (runtime >= min) {
-                console.log(`STATEMENT: ${name}, ${runtime} ms`);
-                if (totals === true) {
-                    console.log(JSON.stringify(tt));
-                }
-            }
-            return result;
-        };
-        return exec;
-    }
-    _traceAsync(func, name, min, totals) {
-        const tt = this.traceTotals;
-        const exec = async (...options) => {
-            const start = Date.now();
-            const result = await func.bind(this)(...options);
-            const runtime = Date.now() - start;
-            if (totals === true) {
-                if (tt[name] === undefined) {
-                    tt[name] = 0;
-                }
-                tt[name] += runtime;
-            }
-            if (runtime >= min) {
-                console.log(`STATEMENT: ${name}, ${runtime} ms`);
-                if (totals === true) {
-                    console.log(JSON.stringify(tt));
-                }
-            }
-            return result;
-        };
-        return exec;
     }
     _setTrace(min = 10, totals = false) {
-        const candidates = [...Object.keys(this), ...Object.getOwnPropertyNames(Statements.prototype)];
-        for (const c of candidates) {
-            if (c === "context" || c === "constructor" || c.startsWith("_") || c === "loop") {
-                continue;
-            }
-            const func = this[c];
-            if ((0, types_1.isAsyncFunction)(func)) {
-                this[c] = this._traceAsync(func, c, min, totals);
-            }
-            else {
-                this[c] = this._trace(func, c, min, totals);
-            }
-        }
+        return new trace_1.Trace().setTrace(min, totals, this);
     }
     async openCursor(target, select, options) {
         const num = await (0, open_cursor_1.openCursor)(this.context, select, options);

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

@@ -10,6 +10,10 @@ export interface ILoopOptions {
     from?: Integer;
     to?: Integer;
     topEquals?: topType;
+    dynamicWhere?: {
+        condition: string;
+        evaluate: (name: string) => FieldSymbol | undefined;
+    };
 }
 export declare function loop(table: Table | HashedTable | FieldSymbol | undefined, options?: ILoopOptions): AsyncGenerator<any, void, unknown>;
 export {};

package/build/src/statements/loop.js

@@ -23,6 +23,38 @@ function determineFromTo(array, topEquals, key) {
         to: to,
     };
 }
+// todo: rewrite, this is a mess & hack & slow
+function dynamicToWhere(condition, evaluate) {
+    //  console.dir(condition);
+    let text = condition.replace(/ AND /gi, " && ").replace(/ OR /gi, " || ").replace(/ = /gi, " EQ ").replace(/ <> /gi, " NE ");
+    //  console.dir(text);
+    let regex = /([\w-]+)\s+(\w+)\s+([<>\w-]+)/gi;
+    let matches = text.matchAll(regex);
+    for (const match of matches) {
+        const left = match[1];
+        const comparator = match[2].toLowerCase();
+        const right = match[3];
+        //    console.dir({left, right});
+        const cleft = "i." + left.toLowerCase().replace(/-/g, ".get().");
+        const cright = right;
+        const cnew = `abap.compare.${comparator}(${cleft}, ${cright})`;
+        text = text.replace(match[0], cnew);
+    }
+    regex = / <(\w+)>-(\w+)/gi;
+    matches = text.matchAll(regex);
+    for (const match of matches) {
+        const name = "fs_" + match[1].toLowerCase() + "_";
+        const value = evaluate(name)?.get()?.[match[2].toLowerCase()]?.get();
+        text = text.replace(match[0], " '" + value + "'");
+    }
+    //  console.dir(text);
+    // @ts-ignore
+    return async (i) => {
+        //    console.dir(i);
+        // eslint-disable-next-line no-eval
+        return eval(text);
+    };
+}
 async function* loop(table, options) {
     if (table === undefined) {
         throw new Error("LOOP at undefined");
@@ -35,6 +67,14 @@ async function* loop(table, options) {
         yield* loop(pnt, options);
         return;
     }
+    if (options?.dynamicWhere) {
+        const dynamicWhere = options.dynamicWhere;
+        const newOptions = { ...options };
+        delete newOptions.dynamicWhere;
+        newOptions.where = dynamicToWhere(dynamicWhere.condition, dynamicWhere.evaluate);
+        yield* loop(table, newOptions);
+        return;
+    }
     const length = table.getArrayLength();
     if (length === 0) {
         // @ts-ignore

package/build/src/trace.d.ts

@@ -0,0 +1,12 @@
+export declare class Trace {
+    private readonly traceTotals;
+    setTrace(min: number, totals: boolean, statements: any): this;
+    getTotals(): {
+        [name: string]: {
+            calls: number;
+            totalRuntime: number;
+        };
+    };
+    private _trace;
+    private _traceAsync;
+}

package/build/src/trace.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trace = void 0;
+const types_1 = require("util/types");
+const statements_1 = require("./statements");
+class Trace {
+    constructor() {
+        this.traceTotals = {};
+    }
+    setTrace(min, totals, statements) {
+        const candidates = [...Object.keys(statements), ...Object.getOwnPropertyNames(statements_1.Statements.prototype)];
+        for (const c of candidates) {
+            if (c === "context" || c === "constructor" || c.startsWith("_") || c === "loop") {
+                continue;
+            }
+            const func = statements[c];
+            if ((0, types_1.isAsyncFunction)(func)) {
+                statements[c] = this._traceAsync(func, c, min, totals);
+            }
+            else {
+                statements[c] = this._trace(func, c, min, totals);
+            }
+        }
+        return this;
+    }
+    getTotals() {
+        return this.traceTotals;
+    }
+    //////////////////////////////////////////
+    _trace(func, name, min, totals) {
+        const tt = this.traceTotals;
+        const exec1 = (...options) => {
+            const start = Date.now();
+            const result = func.bind(this)(...options);
+            const runtime = Date.now() - start;
+            if (totals === true) {
+                if (tt[name] === undefined) {
+                    tt[name] = { calls: 0, totalRuntime: 0 };
+                }
+                tt[name].totalRuntime += runtime;
+                tt[name].calls++;
+            }
+            if (min > 0 && runtime >= min) {
+                console.log(`STATEMENT: ${name}, ${runtime} ms`);
+                if (totals === true) {
+                    console.log(JSON.stringify(tt));
+                }
+            }
+            return result;
+        };
+        return exec1;
+    }
+    _traceAsync(func, name, min, totals) {
+        const tt = this.traceTotals;
+        const exec2 = async (...options) => {
+            const start = Date.now();
+            const result = await func.bind(this)(...options);
+            const runtime = Date.now() - start;
+            if (totals === true) {
+                if (tt[name] === undefined) {
+                    tt[name] = { calls: 0, totalRuntime: 0 };
+                }
+                tt[name].totalRuntime += runtime;
+                tt[name].calls++;
+            }
+            if (min > 0 && runtime >= min) {
+                console.log(`STATEMENT: ${name}, ${runtime} ms`);
+                if (totals === true) {
+                    console.log(JSON.stringify(tt));
+                }
+            }
+            return result;
+        };
+        return exec2;
+    }
+}
+exports.Trace = Trace;
+//# sourceMappingURL=trace.js.map

package/package.json

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