@abaplint/runtime 2.13.92 → 2.13.94

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/create_data.js

@@ -21,6 +21,18 @@ function createDataRefTo(target, name) {
     }
     target.assign(new abap.types.ABAPObject({ qualifiedName: name, RTTIName: name }));
 }
+/** CREATE DATA ... LIKE dobj takes the type of dobj, never its content: the
+ * created data object starts initial. A table is created empty right away
+ * instead of copying its rows first. */
+function initialLike(like) {
+    if (like instanceof types_1.Table || like instanceof types_1.HashedTable) {
+        const TableType = like.constructor;
+        return new TableType(like.getRowType(), like.getOptions(), like.getQualifiedName());
+    }
+    const copy = like.clone();
+    copy.clear();
+    return copy;
+}
 function createData(target, options) {
     // console.dir(options);
     if (target instanceof types_1.FieldSymbol) {
@@ -208,10 +220,10 @@ function createData(target, options) {
             options.like = options.like.getPointer();
         }
         if (options.table === true) {
-            target.assign(new abap.types.Table(options.like.clone(), tableOptions));
+            target.assign(new abap.types.Table(initialLike(options.like), tableOptions));
         }
         else {
-            target.assign(options.like.clone());
+            target.assign(initialLike(options.like));
         }
     }
     else {

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/read_table.js

@@ -90,6 +90,73 @@ async function searchWithKeyPromise(arr, withKey, startIndex = 0, usesTableLine)
     };
 }
 /////////////////
+function toRow(a, isStructured, usesTableLine) {
+    if (usesTableLine === false && isStructured === true) {
+        return a.get();
+    }
+    return isStructured ? { table_line: a, ...a.get() } : { table_line: a };
+}
+/** READ with a key on a SORTED table: binary search over the leading key components that are given,
+ *  a miss gives sy-subrc 4 and sy-tabix of the row the key would be inserted before,
+ *  or sy-subrc 8 and sy-tabix lines + 1 when it would be inserted after the last row */
+/** true when every component of the condition is a component of the key */
+function onlyKeyComponents(keyFields, options) {
+    const key = keyFields.map(k => k.toLowerCase());
+    return Object.keys(options.withKeySimple || {}).every(n => key.includes(n.toLowerCase()));
+}
+function readSortedWithKey(arr, keyFields, options) {
+    const names = Object.keys(options.withKeySimple).map(n => n.toLowerCase());
+    const prefix = [];
+    for (const keyField of keyFields) {
+        const index = names.indexOf(keyField.toLowerCase());
+        if (index < 0) {
+            break;
+        }
+        prefix.push(options.withKeyValue[index]);
+    }
+    if (prefix.length === 0) {
+        const searchResult = searchWithKey(arr, options.withKey, 0, options.usesTableLine);
+        return { found: searchResult.found, foundIndex: searchResult.foundIndex, subrc: undefined };
+    }
+    const isStructured = arr[0] instanceof types_1.Structure;
+    const comparePrefix = (row) => {
+        for (const p of prefix) {
+            const value = p.key(row);
+            // eq first, lt and gt compare a c operand with its trailing blanks against a string
+            if ((0, compare_1.eq)(value, p.value)) {
+                continue;
+            }
+            else if ((0, compare_1.lt)(value, p.value)) {
+                return -1;
+            }
+            else if ((0, compare_1.gt)(value, p.value)) {
+                return 1;
+            }
+        }
+        return 0;
+    };
+    let left = 0;
+    let right = arr.length;
+    while (left < right) {
+        const middle = Math.floor((left + right) / 2);
+        if (comparePrefix(toRow(arr[middle], isStructured, options.usesTableLine)) < 0) {
+            left = middle + 1;
+        }
+        else {
+            right = middle;
+        }
+    }
+    for (let index = left; index < arr.length; index++) {
+        const row = toRow(arr[index], isStructured, options.usesTableLine);
+        if (comparePrefix(row) !== 0) {
+            break;
+        }
+        if (options.withKey(row) === true) {
+            return { found: arr[index], foundIndex: index + 1, subrc: undefined };
+        }
+    }
+    return { found: undefined, foundIndex: left + 1, subrc: left >= arr.length ? 8 : 4 };
+}
 function readTable(table, options) {
     let found = undefined;
     let foundIndex = 0;
@@ -187,15 +254,34 @@ function readTable(table, options) {
             // fallback
             return readTable(table, { ...options, withKeySimple: undefined });
         }
-        const startIndex = (0, binary_search_1.binarySearchFrom)(arr, 0, arr.length, firstKeyName.toLowerCase(), firstValue) - 1;
-        //    console.dir("startindex: " + startIndex);
-        if (startIndex >= 0) {
-            const searchResult = searchWithKeyEarlyExit(arr, options.withKey, startIndex, options.usesTableLine, firstKeyName, firstValue);
-            //      console.dir(searchResult);
-            found = searchResult.found;
-            foundIndex = searchResult.foundIndex;
+        if (keyInformation?.type === types_1.TableAccessType.sorted
+            && options.withKeyValue
+            && onlyKeyComponents(keyInformation.keyFields, options)) {
+            const result = readSortedWithKey(arr, keyInformation.keyFields, options);
+            found = result.found;
+            foundIndex = result.foundIndex;
+            binarySubrc = result.subrc;
+        }
+        else {
+            const startIndex = (0, binary_search_1.binarySearchFrom)(arr, 0, arr.length, firstKeyName.toLowerCase(), firstValue) - 1;
+            if (startIndex >= 0) {
+                const searchResult = searchWithKeyEarlyExit(arr, options.withKey, startIndex, options.usesTableLine, firstKeyName, firstValue);
+                found = searchResult.found;
+                foundIndex = searchResult.foundIndex;
+            }
         }
     }
+    else if (options?.withTableKey === true
+        && options.withKeyValue
+        && options.withKeySimple
+        && options.withKey
+        && table.getOptions().primaryKey?.type === types_1.TableAccessType.sorted
+        && onlyKeyComponents(table.getOptions().primaryKey?.keyFields || [], options)) {
+        const result = readSortedWithKey(table.array(), table.getOptions().primaryKey?.keyFields || [], options);
+        found = result.found;
+        foundIndex = result.foundIndex;
+        binarySubrc = result.subrc;
+    }
     else if ((options?.binarySearch === true || options?.withTableKey === true)
         && options.withKeyValue
         && (options?.binarySearch === true || table.getOptions().primaryKey?.type !== types_1.TableAccessType.standard)

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) {