@abaplint/runtime 2.13.92 → 2.13.93

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

@@ -1,7 +1,7 @@
-import { String } from "../types";
+import { FieldSymbol, String } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
 export declare function escape(input: {
-    val: ICharacter | string;
+    val: ICharacter | FieldSymbol | string;
     format: INumeric | number;
 }): String;

package/build/src/builtin/escape.js

@@ -3,8 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.escape = escape;
 const types_1 = require("../types");
 const _position_1 = require("./_position");
+const JSON_SHORT = {
+    "\\": "\\\\",
+    "\"": "\\\"",
+    "\b": "\\b",
+    "\t": "\\t",
+    "\n": "\\n",
+    "\f": "\\f",
+    "\r": "\\r",
+};
+// backslash, quote, and \b \t \n \f \r by their short forms; the other control
+// characters below U+0020 as \u00XX in upper case hex; U+007F and non-ASCII unchanged
+function escapeJsonCharacter(char) {
+    return JSON_SHORT[char] ?? "\\u" + char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0");
+}
 function escape(input) {
-    let val = typeof input.val === "string" ? input.val : input.val.get();
+    let source;
+    if (input.val instanceof types_1.FieldSymbol) {
+        const pointer = input.val.getPointer();
+        if (pointer === undefined) {
+            throw new Error("GETWA_NOT_ASSIGNED");
+        }
+        source = pointer;
+    }
+    else {
+        source = input.val;
+    }
+    // a c operand counts without its trailing blanks, as in the other string functions
+    let val = typeof source === "string" ? source
+        : source instanceof types_1.Character ? source.getTrimEnd() : source.get();
     const format = (0, _position_1.position)(input.format);
     // todo, optimize/cache regexes
     switch (format) {
@@ -34,9 +61,7 @@ function escape(input) {
             val = val.replace(/'/g, "\\'");
             break;
         case 24: // e_json_string
-            val = val.replace(/\\/g, "\\\\");
-            val = val.replace(/"/g, "\\\"");
-            val = val.replace(/\n/g, "\\n");
+            val = val.replace(/[\\"\u0000-\u001F]/g, escapeJsonCharacter);
             break;
         default:
         // todo, runtime error

package/build/src/compare/eq.js

@@ -4,7 +4,6 @@ exports.eq = eq;
 /* eslint-disable max-len */
 const types_1 = require("../types");
 const _parse_1 = require("../operators/_parse");
-const initial_1 = require("./initial");
 function compareTables(left, right) {
     const leftArray = left.array();
     const rightArray = right.array();
@@ -35,6 +34,14 @@ function compareStructures(left, right) {
     }
     return true;
 }
+// two x fields of different lengths: the shorter one is padded with 00 on the
+// right, so x'AB' = x'AB00'
+function eqHexPadded(left, right) {
+    const l = left.get();
+    const r = right.get();
+    const length = Math.max(l.length, r.length);
+    return l.padEnd(length, "0") === r.padEnd(length, "0");
+}
 // module locals instead of the imported bindings, as the CommonJS re-export
 // getters add overhead on every access in the hot path below
 const IntegerC = types_1.Integer;
@@ -107,7 +114,7 @@ function eq(left, right) {
         }
         else if (leftConstructor === HexC || leftConstructor === HexUInt8C) {
             if (left.getLength() !== right.getLength()) {
-                return (0, initial_1.initial)(left) && (0, initial_1.initial)(right);
+                return eqHexPadded(left, right);
             }
             return left.get() === right.get();
         }
@@ -211,7 +218,7 @@ function eq(left, right) {
         if (left instanceof types_1.Hex || left instanceof types_1.HexUInt8) {
             // @ts-ignore
             if (right.getLength && right.getLength() !== left.getLength()) {
-                return (0, initial_1.initial)(left) && (0, initial_1.initial)(right);
+                return eqHexPadded(left, right);
             }
             return right.get() === left.get();
         }

package/build/src/compare/gt.js

@@ -112,8 +112,14 @@ function gt(left, right) {
 }
 ///////////////////////////////////////////////////////////////////
 function gt_with_hex(left, right) {
-    const left_hex = get_hex_from_parameter(left);
-    const right_hex = get_hex_from_parameter(right);
+    let left_hex = get_hex_from_parameter(left);
+    let right_hex = get_hex_from_parameter(right);
+    if ((left instanceof types_1.Hex || left instanceof types_1.HexUInt8) && (right instanceof types_1.Hex || right instanceof types_1.HexUInt8)) {
+        // two x fields of different lengths: the shorter one is padded with 00 on the right
+        const length = Math.max(left_hex.length, right_hex.length);
+        left_hex = left_hex.padEnd(length, "0");
+        right_hex = right_hex.padEnd(length, "0");
+    }
     return left_hex > right_hex;
 }
 function get_hex_from_parameter(comparison_part) {

package/build/src/expand_in.js

@@ -1,42 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandIN = expandIN;
+function toSQLValue(value) {
+    if (typeof value === "number") {
+        return value.toString();
+    }
+    return `'` + String(value ?? "").replace(/'/g, "''") + "'";
+}
+// one row of a ranges table as a condition that is true when the row matches
+function rowCondition(field, sign, option, low, high) {
+    const lowValue = toSQLValue(low);
+    switch (option) {
+        case "EQ":
+            return `${field} = ${lowValue}`;
+        case "NE":
+            return `${field} <> ${lowValue}`;
+        case "GT":
+            return `${field} > ${lowValue}`;
+        case "GE":
+            return `${field} >= ${lowValue}`;
+        case "LT":
+            return `${field} < ${lowValue}`;
+        case "LE":
+            return `${field} <= ${lowValue}`;
+        case "BT":
+            return `(${field} >= ${lowValue} AND ${field} <= ${toSQLValue(high)})`;
+        case "NB":
+            return `NOT (${field} >= ${lowValue} AND ${field} <= ${toSQLValue(high)})`;
+        case "CP":
+        case "NP":
+            {
+                if (sign !== "I" || option !== "CP") {
+                    // the pattern rules come with a separate change; until then only I CP, as before
+                    throw new Error(`IN, ${sign} ${option} not supported`);
+                }
+                const like = `${field} LIKE '` + String(low ?? "").trimEnd().replace(/'/g, "''").replace(/\*/g, "%") + "'";
+                return option === "CP" ? like : `NOT ${like}`;
+            }
+        default:
+            throw new Error(`IN, ${sign} ${option} not supported`);
+    }
+}
 // note: must always return an expression, never return empty string
 // https://www.sqlite.org/lang_select.html
+// The rows with SIGN I are ORed, AND NOT the OR of the rows with SIGN E; a
+// table with E rows only excludes them from everything.
 function expandIN(fieldName, table) {
-    let ret = "";
     if (table.array().length === 0) {
         // " NOT IN ()" does not work on postgres
         // LIKE '%' does not work in snowflake with RTRIM collation
-        ret = `true`;
+        return `true`;
     }
-    else {
-        ret = `(`;
-        const values = [];
-        fieldName = fieldName.replace("~", `"."`);
-        for (const row of table.array()) {
-            const val = `'` + row.get().low?.get().replace(/'/g, "''") + "'";
-            if (row.get().sign?.get() === "I" && row.get().option?.get() === "EQ") {
-                values.push(`"${fieldName}" = ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "NE") {
-                values.push(`"${fieldName}" <> ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "GE") {
-                values.push(`"${fieldName}" >= ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "LE") {
-                values.push(`"${fieldName}" <= ` + val);
-            }
-            else if (row.get().sign?.get() === "I" && row.get().option?.get() === "CP") {
-                values.push(`"${fieldName}" LIKE '` + row.get().low?.get().trimEnd().replace(/'/g, "''").replace(/\*/g, "%") + "'");
-            }
-            else {
-                throw new Error(`IN, ${row.get().sign?.get()} ${row.get().option?.get()} not supported`);
-            }
+    const field = `"${fieldName.replace("~", `"."`)}"`;
+    const include = [];
+    const exclude = [];
+    for (const row of table.array()) {
+        const sign = row.get().sign?.get();
+        const option = row.get().option?.get();
+        if (sign !== "I" && sign !== "E") {
+            throw new Error(`IN, ${sign} ${option} not supported`);
+        }
+        const cond = rowCondition(field, sign, option, row.get().low?.get(), row.get().high?.get());
+        if (sign === "I") {
+            include.push(cond);
         }
-        ret += values.join(" OR ") + ")";
+        else {
+            exclude.push(cond);
+        }
+    }
+    const parts = [];
+    if (include.length > 0) {
+        parts.push("(" + include.join(" OR ") + ")");
+    }
+    if (exclude.length > 0) {
+        parts.push("NOT (" + exclude.join(" OR ") + ")");
     }
-    return ret;
+    return "(" + parts.join(" AND ") + ")";
 }
 //# sourceMappingURL=expand_in.js.map

package/build/src/operators/_bit_operations.d.ts

@@ -1,6 +1,2 @@
 import { XString } from "../types";
-export declare function get_bit_operation_chunks(left: XString, right: XString): {
-    leftChunk: number;
-    rightChunk: number;
-    chunkLen: number;
-}[];
+export declare function bit_operation(left: XString, right: XString, op: (l: number, r: number) => number): XString;

package/build/src/operators/_bit_operations.js

@@ -1,29 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.get_bit_operation_chunks = get_bit_operation_chunks;
-function get_bit_operation_chunks(left, right) {
-    const ret = [];
-    let leftFull = left.get();
-    const leftLen = leftFull.length;
-    leftFull = leftFull.padEnd(Math.ceil(leftLen / 2) * 2, "0");
-    let rightFull = right.get();
-    const rightLen = rightFull.length;
-    rightFull = rightFull.padEnd(Math.ceil(rightLen / 2) * 2, "0");
-    const maxLen = leftFull.length > rightFull.length ? leftFull.length : rightFull.length;
-    // Using 3-byte chunkgs (6 hex positions) to avoid JavaScript negative values for extreme cases
-    const chunks = maxLen / 6;
-    for (let pass = chunks; pass > 0; pass--) {
-        const chunkStart = maxLen - pass * 6;
-        const chunkEnd = maxLen - (pass - 1) * 6;
-        let leftSlice = leftFull.slice(chunkStart, chunkEnd);
-        let rightSlice = rightFull.slice(chunkStart, chunkEnd);
-        const chunkLen = leftSlice.length > rightSlice.length ? leftSlice.length : rightSlice.length;
-        leftSlice = leftSlice.padEnd(chunkLen, "0");
-        rightSlice = rightSlice.padEnd(chunkLen, "0");
-        const leftChunk = parseInt(leftSlice, 16);
-        const rightChunk = parseInt(rightSlice, 16);
-        ret.push({ leftChunk: leftChunk, rightChunk: rightChunk, chunkLen: chunkLen });
+exports.bit_operation = bit_operation;
+/*eslint no-bitwise: ["error", { "allow": [">>>"] }] */
+const types_1 = require("../types");
+// the shorter operand is padded with hex 0 on the right
+function bit_operation(left, right, op) {
+    let leftHex = left.get();
+    let rightHex = right.get();
+    const maxLen = Math.ceil(Math.max(leftHex.length, rightHex.length) / 2) * 2;
+    leftHex = leftHex.padEnd(maxLen, "0");
+    rightHex = rightHex.padEnd(maxLen, "0");
+    let result;
+    if (maxLen > 0 && maxLen <= 8) {
+        // up to 4 bytes in one 32 bit operation, >>> 0 makes the result unsigned
+        result = (op(parseInt(leftHex, 16), parseInt(rightHex, 16)) >>> 0).toString(16).padStart(maxLen, "0");
     }
+    else {
+        const l = Buffer.from(leftHex, "hex");
+        const r = Buffer.from(rightHex, "hex");
+        for (let i = 0; i < l.length; i++) {
+            l[i] = op(l[i], r[i]);
+        }
+        result = l.toString("hex");
+    }
+    const ret = new types_1.XString();
+    ret.set(result.toUpperCase());
     return ret;
 }
 //# sourceMappingURL=_bit_operations.js.map

package/build/src/operators/bit-and.js

@@ -1,18 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bitand = bitand;
-/*eslint no-bitwise: ["error", { "allow": ["&"] }] */
-const types_1 = require("../types");
 const _bit_operations_1 = require("./_bit_operations");
 function bitand(left, right) {
-    let and = "";
-    const chunks = (0, _bit_operations_1.get_bit_operation_chunks)(left, right);
-    // eslint-disable-next-line no-cond-assign
-    for (let i = 0, chunk; chunk = chunks[i]; i++) {
-        and = and + (chunk.leftChunk & chunk.rightChunk).toString(16).toUpperCase().padStart(chunk.chunkLen, "0");
-    }
-    const ret = new types_1.XString();
-    ret.set(and);
-    return ret;
+    return (0, _bit_operations_1.bit_operation)(left, right, (l, r) => l & r);
 }
 //# sourceMappingURL=bit-and.js.map

package/build/src/operators/bit-or.js

@@ -1,18 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bitor = bitor;
-/*eslint no-bitwise: ["error", { "allow": ["|"] }] */
-const types_1 = require("../types");
 const _bit_operations_1 = require("./_bit_operations");
 function bitor(left, right) {
-    let or = "";
-    const chunks = (0, _bit_operations_1.get_bit_operation_chunks)(left, right);
-    // eslint-disable-next-line no-cond-assign
-    for (let i = 0, chunk; chunk = chunks[i]; i++) {
-        or = or + (chunk.leftChunk | chunk.rightChunk).toString(16).toUpperCase().padStart(chunk.chunkLen, "0");
-    }
-    const ret = new types_1.XString();
-    ret.set(or);
-    return ret;
+    return (0, _bit_operations_1.bit_operation)(left, right, (l, r) => l | r);
 }
 //# sourceMappingURL=bit-or.js.map

package/build/src/operators/bit-xor.js

@@ -1,18 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bitxor = bitxor;
-/*eslint no-bitwise: ["error", { "allow": ["^"] }] */
-const types_1 = require("../types");
 const _bit_operations_1 = require("./_bit_operations");
 function bitxor(left, right) {
-    let xor = "";
-    const chunks = (0, _bit_operations_1.get_bit_operation_chunks)(left, right);
-    // eslint-disable-next-line no-cond-assign
-    for (let i = 0, chunk; chunk = chunks[i]; i++) {
-        xor = xor + (chunk.leftChunk ^ chunk.rightChunk).toString(16).toUpperCase().padStart(chunk.chunkLen, "0");
-    }
-    const ret = new types_1.XString();
-    ret.set(xor);
-    return ret;
+    return (0, _bit_operations_1.bit_operation)(left, right, (l, r) => l ^ r);
 }
 //# sourceMappingURL=bit-xor.js.map

package/build/src/primary_key.d.ts

@@ -0,0 +1,2 @@
+import { Table } from "./types";
+export declare function primaryKeyValues(target: Table, row: any): any[];

package/build/src/primary_key.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primaryKeyValues = primaryKeyValues;
+const types_1 = require("./types");
+// the standard key, all character-like and byte-like components, substructures expanded
+function standardKeyValues(row) {
+    if (!(row instanceof types_1.Structure)) {
+        return [row];
+    }
+    const ret = [];
+    for (const component of Object.values(row.get())) {
+        if (component instanceof types_1.Structure) {
+            ret.push(...standardKeyValues(component));
+        }
+        else if (component instanceof types_1.Character
+            || component instanceof types_1.Numc
+            || component instanceof types_1.Date
+            || component instanceof types_1.Time
+            || component instanceof types_1.String
+            || component instanceof types_1.Hex
+            || component instanceof types_1.HexUInt8
+            || component instanceof types_1.XString) {
+            ret.push(component);
+        }
+    }
+    return ret;
+}
+// values of the primary key, an empty key gives no values
+function primaryKeyValues(target, row) {
+    const options = target.getOptions();
+    if (options?.keyType === types_1.TableKeyType.empty) {
+        return [];
+    }
+    const keyFields = options?.primaryKey?.keyFields ?? [];
+    if (keyFields.length === 0) {
+        return standardKeyValues(row);
+    }
+    return keyFields.map(k => {
+        if (k.toUpperCase() === "TABLE_LINE") {
+            return row;
+        }
+        let value = row;
+        for (const name of k.toLowerCase().split("-")) {
+            value = value.get()[name];
+        }
+        return value;
+    });
+}
+//# sourceMappingURL=primary_key.js.map

package/build/src/statements/concatenate.js

@@ -2,6 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.concatenate = concatenate;
 const types_1 = require("../types");
+// sy-subrc 4 when a c target cuts the result, else 0
+function setTarget(target, result) {
+    let subrc = 0;
+    const pointer = target instanceof types_1.FieldSymbol ? target.getPointer() : target;
+    if (pointer instanceof types_1.Character && result.trimEnd().length > pointer.getLength()) {
+        subrc = 4;
+    }
+    target.set(result);
+    abap.builtin.sy.get().subrc.set(subrc);
+}
 function concatenate(input) {
     if (input.byteMode === true) {
         concatenateByteMode(input);
@@ -32,7 +42,7 @@ function concatenate(input) {
                 result += respectingBlanks === true ? value : value.trimEnd();
             }
         }
-        input.target.set(result);
+        setTarget(input.target, result);
     }
     else {
         let result = "";
@@ -60,7 +70,7 @@ function concatenate(input) {
         if (sep.length > 0 && result.length > 0) {
             result = result.slice(0, result.length - sep.length);
         }
-        input.target.set(result);
+        setTarget(input.target, result);
     }
 }
 function rawByteValue(source) {
@@ -99,6 +109,6 @@ function concatenateByteMode(input) {
     if (sep.length > 0 && result.length > 0) {
         result = result.slice(0, result.length - sep.length);
     }
-    input.target.set(result);
+    setTarget(input.target, result);
 }
 //# sourceMappingURL=concatenate.js.map

package/build/src/statements/delete_database.js

@@ -15,14 +15,29 @@ async function deleteDatabase(table, options, context) {
         table = table.get().trimEnd();
     }
     if (options.table) {
+        // one DELETE per row; sy-subrc is 4 when any row was not found,
+        // sy-dbcnt counts the rows deleted
+        let subrc = 0;
+        let dbcnt = 0;
         for (const row of options.table.array()) {
             await deleteDatabase(table, { from: row }, context);
+            if (abap.builtin.sy.get().subrc.get() !== 0) {
+                subrc = 4;
+            }
+            dbcnt += abap.builtin.sy.get().dbcnt.get();
         }
+        abap.builtin.sy.get().subrc.set(subrc);
+        abap.builtin.sy.get().dbcnt.set(dbcnt);
     }
     else if (options.from) {
         let where = [];
+        // the row is found by its primary key, the other fields are not compared
+        const keys = abap.DDIC[table.toUpperCase()]?.keyFields;
         const structure = options.from.get();
         for (const k of Object.keys(structure)) {
+            if (keys !== undefined && keys.length > 0 && keys.includes(k.toUpperCase()) === false) {
+                continue;
+            }
             const str = `"${k.toLowerCase()}"` + " = " + (0, insert_database_1.toValue)(structure[k].get());
             where.push(str);
         }

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

@@ -5,6 +5,7 @@ export interface IDeleteInternalOptions {
     index?: INumeric;
     adjacent?: boolean;
     comparing?: string[];
+    allFields?: boolean;
     fromValue?: any;
     from?: any;
     to?: any;

package/build/src/statements/delete_internal.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteInternal = deleteInternal;
 const types_1 = require("../types");
 const compare_1 = require("../compare");
+const primary_key_1 = require("../primary_key");
 const loop_1 = require("./loop");
 async function deleteInternal(target, options) {
     let index = 0;
@@ -50,7 +51,12 @@ async function deleteInternal(target, options) {
         for (let index = array.length - 1; index > 0; index--) {
             const prev = array[index - 1];
             const i = array[index];
-            if (options?.comparing) {
+            if (options?.allFields === true) {
+                if ((0, compare_1.eq)(prev, i) === true) {
+                    target.deleteIndex(index);
+                }
+            }
+            else if (options?.comparing) {
                 let match = false;
                 for (const compareField of options.comparing) {
                     match = (0, compare_1.eq)(prev.get()[compareField], i.get()[compareField]);
@@ -62,8 +68,13 @@ async function deleteInternal(target, options) {
                     target.deleteIndex(index);
                 }
             }
-            else if ((0, compare_1.eq)(prev, i) === true) {
-                target.deleteIndex(index);
+            else {
+                // without COMPARING, rows are compared by the primary key, nothing is deleted if the key is empty
+                const prevKey = (0, primary_key_1.primaryKeyValues)(target, prev);
+                const key = (0, primary_key_1.primaryKeyValues)(target, i);
+                if (key.length > 0 && key.every((value, n) => (0, compare_1.eq)(prevKey[n], value))) {
+                    target.deleteIndex(index);
+                }
             }
         }
         return;

package/build/src/statements/describe.js

@@ -2,6 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describe = describe;
 const types_1 = require("../types");
+// a structure is deep when a component is a string, a table or a reference,
+// or a deep structure itself: type kind v, a flat structure is u
+function isDeep(structure) {
+    for (const component of Object.values(structure.get())) {
+        if (component instanceof types_1.String
+            || component instanceof types_1.XString
+            || component instanceof types_1.Table
+            || component instanceof types_1.HashedTable
+            || component instanceof types_1.DataReference
+            || component instanceof types_1.ABAPObject
+            || (component instanceof types_1.Structure && isDeep(component))) {
+            return true;
+        }
+    }
+    return false;
+}
 function describe(input) {
     //  console.dir(input);
     if (input.type) {
@@ -49,7 +65,7 @@ function describe(input) {
             input.type.set("e");
         }
         else if (input.field instanceof types_1.Structure) {
-            input.type.set("u");
+            input.type.set(isDeep(input.field) ? "v" : "u");
         }
         else if (input.field instanceof types_1.ABAPObject) {
             input.type.set("r");

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

@@ -6,5 +6,6 @@ export interface IInsertDatabaseOptions {
     values?: Structure;
     table?: Table;
     connection?: string;
+    acceptingDuplicateKeys?: boolean;
 }
 export declare function insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions, context: Context): Promise<number | undefined>;

package/build/src/statements/insert_database.js

@@ -4,6 +4,7 @@ exports.toValue = toValue;
 exports.insertDatabase = insertDatabase;
 const prefix_1 = require("../prefix");
 const types_1 = require("../types");
+const throw_error_1 = require("../throw_error");
 function toValue(value) {
     if (typeof value === "string") {
         // postgres requires ' for values
@@ -21,6 +22,8 @@ async function insertDatabase(table, options, context) {
         throw new Error("insertDatabase, wrong input");
     }
     if (options.table !== undefined) {
+        const subrcBefore = abap.builtin.sy.get().subrc.get();
+        const dbcntBefore = abap.builtin.sy.get().dbcnt.get();
         let subrc = 0;
         let dbcnt = 0;
         for (const row of options.table.array()) {
@@ -28,6 +31,14 @@ async function insertDatabase(table, options, context) {
             subrc = Math.max(subrc, abap.builtin.sy.get().subrc.get());
             dbcnt += abap.builtin.sy.get().dbcnt.get();
         }
+        if (subrc !== 0 && options.acceptingDuplicateKeys !== true) {
+            // without ACCEPTING DUPLICATE KEYS a row that cannot be inserted raises
+            // CX_SY_OPEN_SQL_DB; the other rows stay inserted and sy-subrc and
+            // sy-dbcnt keep the values they had before the statement
+            abap.builtin.sy.get().subrc.set(subrcBefore);
+            abap.builtin.sy.get().dbcnt.set(dbcntBefore);
+            await (0, throw_error_1.throwErrorWithParameters)("CX_SY_OPEN_SQL_DB", { sqlmsg: new types_1.String().set(`INSERT ${typeof table === "string" ? table : table.get().trimEnd()} FROM TABLE: a row could not be inserted (duplicate key?)`) });
+        }
         abap.builtin.sy.get().subrc.set(subrc);
         abap.builtin.sy.get().dbcnt.set(dbcnt);
         return;

package/build/src/statements/shift.js

@@ -37,11 +37,17 @@ function shift_character_mode(target, options) {
     else if (options?.places) {
         const p = options.places.get();
         if (options.circular) {
-            value = value.substr(p) + value.substr(0, p);
+            if (options.direction === "RIGHT") {
+                value = value.substr(value.length - p) + value.substr(0, value.length - p);
+            }
+            else {
+                value = value.substr(p) + value.substr(0, p);
+            }
         }
         else {
             if (options.direction === "RIGHT") {
-                value = " ".repeat(options.places.get()) + value.substring(0, options.places.get());
+                // set() cuts a fixed length target, a string gets longer
+                value = " ".repeat(p) + value;
             }
             else {
                 value = value.substr(p);
@@ -69,6 +75,9 @@ function shift_character_mode(target, options) {
             value = value.substr(1) + value.substr(0, 1);
         }
     }
+    else if (options?.direction === "RIGHT") {
+        value = " " + value;
+    }
     else {
         value = value.substr(1);
     }
@@ -107,7 +116,8 @@ function shift_byte_mode(target, options) {
         else {
             const p = options.places.get() * 2;
             if (options.direction === "RIGHT") {
-                value = "0".repeat(p) + value.substring(0, p);
+                // set() cuts a fixed length target, an xstring gets longer
+                value = "0".repeat(p) + value;
             }
             else {
                 value = value.substr(p);
@@ -128,7 +138,15 @@ function shift_byte_mode(target, options) {
         }
     }
     else if (options?.circular) {
-        value = value.substr(2) + value.substr(0, 2);
+        if (options.direction === "RIGHT") {
+            value = value.substr(value.length - 2) + value.substr(0, value.length - 2);
+        }
+        else {
+            value = value.substr(2) + value.substr(0, 2);
+        }
+    }
+    else if (options?.direction === "RIGHT") {
+        value = "00" + value;
     }
     else {
         value = value.substr(2);

package/build/src/statements/sort.js

@@ -4,6 +4,7 @@ exports.compareRows = compareRows;
 exports.sort = sort;
 const types_1 = require("../types");
 const compare_1 = require("../compare");
+const primary_key_1 = require("../primary_key");
 function compare(a, b, input) {
     const componentName = input.component;
     const descending = input.descending;
@@ -124,6 +125,27 @@ function sort(input, options) {
             return 0;
         });
     }
+    else if (input instanceof types_1.Table
+        && input.getRowType() instanceof types_1.Structure
+        && input.getOptions()?.keyType !== types_1.TableKeyType.empty) {
+        // without BY, rows of a structure are sorted by the primary key
+        const descending = options?.descending === true;
+        const keys = new Map();
+        for (const row of input.array()) {
+            keys.set(row, (0, primary_key_1.primaryKeyValues)(input, row));
+        }
+        input.sort((a, b) => {
+            const keyA = keys.get(a);
+            const keyB = keys.get(b);
+            for (let i = 0; i < keyA.length; i++) {
+                const result = compareWholeRows(keyA[i], keyB[i]);
+                if (result !== 0) {
+                    return descending ? -result : result;
+                }
+            }
+            return 0;
+        });
+    }
     else {
         const descending = options?.descending === true;
         input.sort((a, b) => {

package/build/src/statements/write.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WriteStatement = void 0;
 const types_1 = require("../types");
+const field_symbol_1 = require("../types/field_symbol");
 const NO_DEICMAL_CURRENCIES = ["HUF", "KRW", "JPY"];
 class WriteStatement {
     context;
@@ -28,19 +29,21 @@ class WriteStatement {
                 const obj = source.getCharacter();
                 this.write(obj, { ...options });
             }
-            else if (source instanceof types_1.Float) {
+            else if (source instanceof types_1.Float || (source instanceof field_symbol_1.FieldSymbol && source.getPointer() instanceof types_1.Float)) {
+                // a float behind a field symbol is formatted the same way
+                const float = source instanceof field_symbol_1.FieldSymbol ? source.getPointer() : source;
                 if (options?.exponent?.get() === 0) {
-                    const tens = source.getRaw().toFixed(0).length - 1;
-                    if (options.noSign === true && source.getRaw() < 0) {
-                        result = source.getRaw().toFixed(17 - tens).replace(".", ",");
+                    const tens = float.getRaw().toFixed(0).length - 1;
+                    if (options.noSign === true && float.getRaw() < 0) {
+                        result = float.getRaw().toFixed(17 - tens).replace(".", ",");
                         result = result.replace("-", "");
                     }
                     else {
-                        result = source.getRaw().toFixed(16 - tens).replace(".", ",");
+                        result = float.getRaw().toFixed(16 - tens).replace(".", ",");
                     }
                 }
                 else {
-                    result = source.get().toString();
+                    result = float.get().toString();
                 }
             }
             else if (source instanceof types_1.Packed) {

package/build/src/types/date.js

@@ -32,7 +32,13 @@ class Date {
         else if (value instanceof float_1.Float) {
             this.set(Math.round(value.getRaw()));
         }
+        else if (value instanceof string_1.String) {
+            // an empty string is the initial date, a shorter one is filled with blanks
+            const str = value.get();
+            this.value = str === "" ? "00000000" : str;
+        }
         else if (typeof value === "string") {
+            // raw character results, eg. from CONCATENATE, are filled with blanks
             this.value = value;
         }
         else {

package/build/src/types/hex.js

@@ -6,7 +6,7 @@ const float_1 = require("./float");
 const xstring_1 = require("./xstring");
 const throw_error_1 = require("../throw_error");
 const integer8_1 = require("./integer8");
-const REGEXP = /^(?![A-F0-9])/;
+const HEX_PREFIX = /^[A-F0-9]*/;
 class Hex {
     value;
     length;
@@ -73,9 +73,12 @@ class Hex {
                 return this.set(v);
             }
             else {
-                this.value = v;
-                if (this.value.match(REGEXP)) {
-                    this.value = "";
+                // c -> x: the leading hexadecimal digits, upper case only, and a
+                // trailing half byte padded with 0; the first other character ends
+                // the conversion, so "ABG1" is AB, "0a1B" is 00
+                this.value = HEX_PREFIX.exec(v)[0];
+                if (this.value.length % 2 === 1) {
+                    this.value += "0";
                 }
             }
         }

package/build/src/types/integer.js

@@ -93,14 +93,11 @@ class Integer {
             this.set(roundHalfAwayFromZero(value.getRaw()));
         }
         else if (value instanceof hex_1.Hex || value instanceof xstring_1.XString || value instanceof hex_uint8_1.HexUInt8) {
-            const hex = value.get();
-            let num = parseInt(hex, 16);
-            // handle two complement, the first bit is the sign
-            if (hex.length >= 8) {
-                const maxVal = Math.pow(2, hex.length / 2 * 8);
-                if (num > maxVal / 2 - 1) {
-                    num = num - maxVal;
-                }
+            // the last four bytes, 00 on the left, as a signed integer; an empty xstring is 0
+            const hex = value.get().slice(-8);
+            let num = hex === "" ? 0 : parseInt(hex, 16);
+            if (hex.length === 8 && num > 0x7FFFFFFF) {
+                num = num - 0x100000000;
             }
             this.set(num);
         }

package/package.json

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