@abaplint/runtime 2.5.57 → 2.5.58

package/build/src/binary_search.d.ts

@@ -1,5 +1,5 @@
 import { ICharacter } from "./types/_character";
 import { INumeric } from "./types/_numeric";
-export declare function binarySearchFromRow(array: readonly any[], left: number, right: number, keyField: (i: any) => any, keyValue: INumeric | ICharacter): number;
+export declare function binarySearchFromRow(array: readonly any[], left: number, right: number, keyField: (i: any) => any, keyValue: INumeric | ICharacter, usesTableLine: boolean | undefined): number;
 export declare function binarySearchFrom(array: readonly any[], left: number, right: number, keyField: string, keyValue: INumeric | ICharacter): number;
 export declare function binarySearchTo(array: readonly any[], left: number, right: number, keyField: string, keyValue: INumeric | ICharacter): number;

package/build/src/binary_search.js

@@ -4,12 +4,18 @@ exports.binarySearchTo = exports.binarySearchFrom = exports.binarySearchFromRow
 /* eslint-disable max-len */
 const compare_1 = require("./compare");
 const types_1 = require("./types");
-function binarySearchFromRow(array, left, right, keyField, keyValue) {
+function binarySearchFromRow(array, left, right, keyField, keyValue, usesTableLine) {
     const isStructured = array[0] instanceof types_1.Structure;
     while (right - left > 1) {
         const middle = Math.floor(((right - left) / 2) + left);
         const a = array[middle];
-        const row = isStructured ? Object.assign({ table_line: a }, a.get()) : { table_line: a };
+        let row = undefined;
+        if (usesTableLine === false && isStructured === true) {
+            row = a.get();
+        }
+        else {
+            row = isStructured ? Object.assign({ table_line: a }, a.get()) : { table_line: a };
+        }
         if ((0, compare_1.ge)(keyField(row), keyValue)) {
             right = middle;
         }

package/build/src/builtin/lines.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.lines = void 0;
 const types_1 = require("../types");
 function lines(input) {
-    if (input.val instanceof types_1.FieldSymbol
-        && input.val.getPointer() === undefined) {
-        throw new Error("GETWA_NOT_ASSIGNED");
+    if (input.val instanceof types_1.FieldSymbol) {
+        if (input.val.getPointer() === undefined) {
+            throw new Error("GETWA_NOT_ASSIGNED");
+        }
+        return lines({ val: input.val.getPointer() });
     }
-    return new types_1.Integer().set(input.val.array().length);
+    return new types_1.Integer().set(input.val.getLength());
 }
 exports.lines = lines;
 //# sourceMappingURL=lines.js.map

package/build/src/statements/find.js

@@ -108,7 +108,7 @@ function find(input, options) {
                 line: new types_1.Integer(),
                 offset: new types_1.Integer(),
                 length: new types_1.Integer(),
-                submatches: new types_1.Table(new types_1.Structure({ offset: new types_1.Integer(), length: new types_1.Integer() })),
+                submatches: types_1.TableFactory.construct(new types_1.Structure({ offset: new types_1.Integer(), length: new types_1.Integer() })),
             });
             match.get().line.set(m.line || 0);
             match.get().offset.set(m.index);

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

@@ -1,11 +1,11 @@
-import { ABAPObject, DataReference, FieldSymbol, Structure, Table } from "../types";
+import { ABAPObject, DataReference, FieldSymbol, HashedTable, Structure, Table } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
 export interface IInsertInternalOptions {
     index?: INumeric;
     initial?: boolean;
     data?: INumeric | ICharacter | Structure | ABAPObject | Table | FieldSymbol | string;
-    table: Table | FieldSymbol;
+    table: Table | HashedTable | FieldSymbol;
     referenceInto?: DataReference;
     assigning?: FieldSymbol;
     lines?: boolean;

package/build/src/statements/insert_internal.js

@@ -21,8 +21,12 @@ function insertInternal(options) {
         options.data = options.data.getPointer();
     }
     const tableOptions = options.table.getOptions();
-    const isSorted = ((_a = tableOptions === null || tableOptions === void 0 ? void 0 : tableOptions.primaryKey) === null || _a === void 0 ? void 0 : _a.type) === types_1.TableAccessType.sorted || ((_b = tableOptions === null || tableOptions === void 0 ? void 0 : tableOptions.primaryKey) === null || _b === void 0 ? void 0 : _b.type) === types_1.TableAccessType.hashed;
-    if (isSorted) {
+    let isSorted = ((_a = tableOptions === null || tableOptions === void 0 ? void 0 : tableOptions.primaryKey) === null || _a === void 0 ? void 0 : _a.type) === types_1.TableAccessType.sorted
+        || ((_b = tableOptions === null || tableOptions === void 0 ? void 0 : tableOptions.primaryKey) === null || _b === void 0 ? void 0 : _b.type) === types_1.TableAccessType.hashed;
+    if (options.table instanceof types_1.HashedTable) {
+        isSorted = false;
+    }
+    else if (isSorted) {
         const insert = options.data instanceof types_1.Structure ? options.data.get() : { table_line: options.data };
         const compare = (row) => {
             var _a;
@@ -92,6 +96,18 @@ function insertInternal(options) {
             options.referenceInto.assign(val);
         }
     }
+    else if (options.table instanceof types_1.HashedTable && data) {
+        const { value: val, subrc: subrc } = options.table.insert(data);
+        if (options.assigning) {
+            options.assigning.assign(val);
+        }
+        if (options.referenceInto) {
+            options.referenceInto.assign(val);
+        }
+        // @ts-ignore
+        abap.builtin.sy.get().subrc.set(subrc);
+        return;
+    }
     else if (data) {
         // todo, for now it just appends, this is not correct, but currently the table type is not known
         const val = options.table.insertIndex(data, options.table.array().length);
@@ -104,7 +120,7 @@ function insertInternal(options) {
     }
     // @ts-ignore
     abap.builtin.sy.get().subrc.set(0);
-    if (isSorted) {
+    if (isSorted && !(options.table instanceof types_1.HashedTable)) {
         // slow, but works for now
         let by = (_e = (_d = tableOptions === null || tableOptions === void 0 ? void 0 : tableOptions.primaryKey) === null || _d === void 0 ? void 0 : _d.keyFields) === null || _e === void 0 ? void 0 : _e.map(f => {
             return { component: f.toLowerCase() };

package/build/src/statements/loop.js

@@ -60,7 +60,7 @@ function loop(table, options) {
             yield __await(yield* __asyncDelegator(__asyncValues(loop(pnt, options))));
             return yield __await(void 0);
         }
-        const length = table.array().length;
+        const length = table.getLength();
         if (length === 0) {
             // @ts-ignore
             abap.builtin.sy.get().subrc.set(4);

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

@@ -3,17 +3,22 @@ import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
 export interface IReadTableOptions {
     index?: INumeric | FieldSymbol | number;
-    withKey?: (i: any) => boolean;
     into?: INumeric | ICharacter | Structure | Table | DataReference;
     from?: INumeric | ICharacter | Structure | Table | DataReference;
     referenceInto?: DataReference;
     assigning?: FieldSymbol;
     binarySearch?: boolean;
+    withTableKey?: boolean;
     keyName?: string;
+    usesTableLine?: boolean;
+    withKey?: (i: any) => boolean;
     withKeyValue?: {
         key: (i: any) => any;
         value: any;
     }[];
+    withKeySimple?: {
+        [key: string]: any;
+    };
 }
 export type ReadTableReturn = {
     subrc: number;

package/build/src/statements/read_table.js

@@ -4,11 +4,17 @@ exports.readTable = void 0;
 const binary_search_1 = require("../binary_search");
 const compare_1 = require("../compare");
 const types_1 = require("../types");
-function searchWithKey(arr, withKey, startIndex = 0) {
+function searchWithKey(arr, withKey, startIndex = 0, usesTableLine) {
     const isStructured = arr[0] instanceof types_1.Structure;
     for (let index = startIndex; index < arr.length; index++) {
         const a = arr[index];
-        const row = isStructured ? Object.assign({ table_line: a }, a.get()) : { table_line: a };
+        let row = undefined;
+        if (usesTableLine === false && isStructured === true) {
+            row = a.get();
+        }
+        else {
+            row = isStructured ? Object.assign({ table_line: a }, a.get()) : { table_line: a };
+        }
         if (withKey(row) === true) {
             return {
                 found: a,
@@ -26,8 +32,8 @@ function readTable(table, options) {
     var _a, _b;
     let found = undefined;
     let foundIndex = 0;
-    const arr = table.array();
     if (options === null || options === void 0 ? void 0 : options.index) {
+        const arr = table.array();
         let index = options.index;
         if (typeof index !== "number") {
             if (index instanceof types_1.FieldSymbol) {
@@ -48,18 +54,20 @@ function readTable(table, options) {
             foundIndex = index;
         }
     }
-    else if ((options === null || options === void 0 ? void 0 : options.binarySearch) === true
+    else if (((options === null || options === void 0 ? void 0 : options.binarySearch) === true || (options === null || options === void 0 ? void 0 : options.withTableKey) === true)
         && options.withKeyValue
         && options.withKey) {
         // note: it currently only uses the first key field for binary search, todo
         const first = options.withKeyValue[0];
-        const startIndex = (0, binary_search_1.binarySearchFromRow)(arr, 0, arr.length, first.key, first.value) - 1;
-        const searchResult = searchWithKey(arr, options.withKey, startIndex);
+        const arr = table.array();
+        const startIndex = (0, binary_search_1.binarySearchFromRow)(arr, 0, arr.length, first.key, first.value, options.usesTableLine) - 1;
+        const searchResult = searchWithKey(arr, options.withKey, startIndex, options.usesTableLine);
         found = searchResult.found;
         foundIndex = searchResult.foundIndex;
     }
     else if (options === null || options === void 0 ? void 0 : options.withKey) {
-        const searchResult = searchWithKey(arr, options.withKey);
+        const arr = table.array();
+        const searchResult = searchWithKey(arr, options.withKey, 0, options.usesTableLine);
         found = searchResult.found;
         foundIndex = searchResult.foundIndex;
     }
@@ -71,6 +79,7 @@ function readTable(table, options) {
             table = table.getPointer();
         }
         if (table instanceof types_1.Table && options.from instanceof types_1.Structure) {
+            const arr = table.array();
             const keys = (_b = (_a = table.getOptions()) === null || _a === void 0 ? void 0 : _a.primaryKey) === null || _b === void 0 ? void 0 : _b.keyFields;
             const isStructured = arr[0] instanceof types_1.Structure;
             if (keys !== undefined && isStructured === true) {

package/build/src/types/data_reference.d.ts

@@ -19,7 +19,7 @@ export declare class DataReference {
     clear(): void;
     get(): any;
     array(): any;
-    set(value: any): void | Float | ABAPObject | this | Structure;
+    set(value: any): void | Float | ABAPObject | this | Table | Structure;
     getOffset(input: {
         offset?: number | INumeric | Hex;
         length?: number | INumeric | Hex;

package/build/src/types/table.d.ts

@@ -25,7 +25,50 @@ export type ITableOptions = {
     secondary?: ITableKey[];
 };
 export type TableRowType = INumeric | Structure | ICharacter | Table | ABAPObject;
-export declare class Table {
+interface ITable {
+    getQualifiedName(): string | undefined;
+    getOptions(): ITableOptions | undefined;
+    getRowType(): TableRowType;
+    getLength(): number;
+    clear(): void;
+    set(tab: Table | TableRowType): ITable;
+    getHeader(): TableRowType;
+}
+export declare class TableFactory {
+    static construct(rowType: TableRowType, options?: ITableOptions, qualifiedName?: string): Table | HashedTable;
+}
+export declare class SortedTable {
+}
+export declare class HashedTable implements ITable {
+    private value;
+    private readonly header;
+    private readonly rowType;
+    private readonly loops;
+    private readonly options;
+    private readonly qualifiedName;
+    private secondaryIndexes;
+    constructor(rowType: TableRowType, options: ITableOptions, qualifiedName?: string);
+    getLength(): number;
+    getKeyByName(name: string): ITableKey | undefined;
+    getSecondaryIndex(name: string): any[];
+    insert(data: TableRowType): {
+        value: TableRowType | undefined;
+        subrc: number;
+    };
+    array(): readonly any[];
+    startLoop(start?: number): LoopIndex;
+    unregisterLoop(loop: LoopIndex): void;
+    insertIndex(_item: TableRowType, _index: number): void;
+    append(_item: TableRowType): void;
+    getQualifiedName(): string | undefined;
+    getOptions(): ITableOptions;
+    getRowType(): TableRowType;
+    clear(): void;
+    set(_tab: TableRowType): ITable;
+    getHeader(): TableRowType;
+    private getValue;
+}
+export declare class Table implements ITable {
     private value;
     private readonly header;
     private readonly rowType;
@@ -34,17 +77,18 @@ export declare class Table {
     private readonly qualifiedName;
     private readonly isStructured;
     private secondaryIndexes;
-    constructor(rowType: TableRowType, options?: ITableOptions, qualifiedName?: string);
+    constructor(rowType: TableRowType, options: ITableOptions, qualifiedName?: string);
+    getLength(): number;
     getKeyByName(name: string): ITableKey | undefined;
     getSecondaryIndex(name: string): TableRowType[];
     getQualifiedName(): string | undefined;
-    getOptions(): ITableOptions | undefined;
+    getOptions(): ITableOptions;
     startLoop(start?: number): LoopIndex;
     unregisterLoop(loop: LoopIndex): void;
     getRowType(): TableRowType;
     array(): readonly any[];
     clear(): void;
-    set(tab: Table | TableRowType): void;
+    set(tab: Table | TableRowType): this;
     getHeader(): TableRowType;
     insertIndex(item: TableRowType, index: number): any;
     deleteIndex(index: number): void;
@@ -53,3 +97,4 @@ export declare class Table {
     sort(compareFn: (a: TableRowType, b: TableRowType) => number): void;
     private getValue;
 }
+export {};

package/build/src/types/table.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Table = exports.LoopIndex = exports.TableAccessType = void 0;
+exports.Table = exports.HashedTable = exports.SortedTable = exports.TableFactory = exports.LoopIndex = exports.TableAccessType = void 0;
 const integer_1 = require("./integer");
 const string_1 = require("./string");
 const clone_1 = require("../clone");
@@ -23,6 +23,157 @@ class LoopIndex {
     }
 }
 exports.LoopIndex = LoopIndex;
+// eslint-disable-next-line prefer-const
+let featureHashedTables = false;
+class TableFactory {
+    static construct(rowType, options, qualifiedName) {
+        var _a;
+        if (options === undefined) {
+            options = {
+                primaryKey: {
+                    name: "primary_key",
+                    type: TableAccessType.standard,
+                    keyFields: [],
+                    isUnique: false,
+                },
+                withHeader: false,
+            };
+        }
+        if (featureHashedTables === true && ((_a = options.primaryKey) === null || _a === void 0 ? void 0 : _a.type) === TableAccessType.hashed) {
+            return new HashedTable(rowType, options, qualifiedName);
+        }
+        else {
+            return new Table(rowType, options, qualifiedName);
+        }
+    }
+}
+exports.TableFactory = TableFactory;
+class SortedTable {
+}
+exports.SortedTable = SortedTable;
+class HashedTable {
+    constructor(rowType, options, qualifiedName) {
+        this.value = {};
+        this.secondaryIndexes = {};
+        this.loops = new Set();
+        this.rowType = rowType;
+        this.options = options;
+        //    this.isStructured = rowType instanceof Structure;
+        this.options = options;
+        if ((options === null || options === void 0 ? void 0 : options.withHeader) === true) {
+            this.header = (0, clone_1.clone)(this.rowType);
+        }
+        this.qualifiedName = qualifiedName === null || qualifiedName === void 0 ? void 0 : qualifiedName.toUpperCase();
+    }
+    getLength() {
+        return Object.keys(this.value).length;
+    }
+    getKeyByName(name) {
+        var _a, _b;
+        return (_b = (_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.secondary) === null || _b === void 0 ? void 0 : _b.find(s => s.name.toUpperCase() === name.toUpperCase());
+    }
+    getSecondaryIndex(name) {
+        if (this.secondaryIndexes[name.toUpperCase()]) {
+            return this.secondaryIndexes[name.toUpperCase()];
+        }
+        const secondary = this.getKeyByName(name);
+        if (secondary === undefined) {
+            throw `Table, secondary key "${name}" not found`;
+        }
+        const copy = (0, clone_1.clone)([...this.array()]);
+        (0, sort_1.sort)(copy, { by: secondary.keyFields.map(k => { return { component: k.toLowerCase() }; }) });
+        this.secondaryIndexes[name.toUpperCase()] = copy;
+        return copy;
+    }
+    insert(data) {
+        if (this.loops.size !== 0) {
+            throw new Error("Hash table insert inside LOOP");
+        }
+        let hash = "";
+        for (const k of this.options.primaryKey.keyFields) {
+            // @ts-ignore
+            hash += k + ":" + data.get()[k.toLowerCase()].get();
+        }
+        if (this.value[hash] !== undefined) {
+            return { value: undefined, subrc: 4 };
+        }
+        else {
+            const val = this.getValue(data);
+            this.value[hash] = val;
+            return { value: val, subrc: 0 };
+        }
+    }
+    array() {
+        // used for LOOP
+        const ret = [];
+        for (const hash in this.value) {
+            ret.push(this.value[hash]);
+        }
+        return ret;
+    }
+    startLoop(start = 0) {
+        const l = new LoopIndex(start);
+        this.loops.add(l);
+        return l;
+    }
+    unregisterLoop(loop) {
+        this.loops.delete(loop);
+    }
+    insertIndex(_item, _index) {
+        throw new Error("Hash table insert index");
+    }
+    append(_item) {
+        throw new Error("Hash table append");
+    }
+    getQualifiedName() {
+        return this.qualifiedName;
+    }
+    getOptions() {
+        return this.options;
+    }
+    getRowType() {
+        return this.rowType;
+    }
+    clear() {
+        this.value = {};
+    }
+    set(_tab) {
+        throw new Error("Method not implemented, set hashed table");
+    }
+    getHeader() {
+        if (this.header === undefined) {
+            throw "table, getHeader";
+        }
+        return this.header;
+    }
+    ///////////////////////////
+    getValue(item) {
+        // make sure to do conversion if needed
+        if (typeof item === "number") {
+            const tmp = (0, clone_1.clone)(this.getRowType());
+            tmp.set(new integer_1.Integer().set(item));
+            return tmp;
+        }
+        else if (typeof item === "string") {
+            const tmp = (0, clone_1.clone)(this.getRowType());
+            tmp.set(new string_1.String().set(item));
+            return tmp;
+            // @ts-ignore
+            // eslint-disable-next-line max-len
+        }
+        else if (this.isStructured === true && item.getQualifiedName && this.rowType.getQualifiedName && item.getQualifiedName() !== "" && item.getQualifiedName() === this.rowType.getQualifiedName()) {
+            // types match, so no need to do conversions, just clone the item
+            const val = (0, clone_1.clone)(item);
+            return val;
+        }
+        else {
+            const tmp = (0, clone_1.clone)(this.getRowType());
+            tmp.set(item);
+            return tmp;
+        }
+    }
+}
+exports.HashedTable = HashedTable;
 class Table {
     constructor(rowType, options, qualifiedName) {
         this.value = [];
@@ -34,19 +185,11 @@ class Table {
         if ((options === null || options === void 0 ? void 0 : options.withHeader) === true) {
             this.header = (0, clone_1.clone)(this.rowType);
         }
-        if (this.options === undefined) {
-            this.options = {
-                primaryKey: {
-                    name: "primary_key",
-                    type: TableAccessType.standard,
-                    keyFields: [],
-                    isUnique: false,
-                },
-                withHeader: false,
-            };
-        }
         this.qualifiedName = qualifiedName === null || qualifiedName === void 0 ? void 0 : qualifiedName.toUpperCase();
     }
+    getLength() {
+        return this.value.length;
+    }
     getKeyByName(name) {
         var _a, _b;
         return (_b = (_a = this.getOptions()) === null || _a === void 0 ? void 0 : _a.secondary) === null || _b === void 0 ? void 0 : _b.find(s => s.name.toUpperCase() === name.toUpperCase());
@@ -106,6 +249,7 @@ class Table {
             // this clones the values, and add sorting if required
             (0, insert_internal_1.insertInternal)({ table: this, data: tab, lines: true });
         }
+        return this;
     }
     getHeader() {
         if (this.header === undefined) {

package/package.json

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