Fix a bug of duplicate record keys of indexed files.

libcobj/app/src/main/java/jp/osscons/opensourcecobol/libcobj/file/CobolIndexedFile.java

@@ -41,6 +41,7 @@ public class CobolIndexedFile extends CobolFile {
     private boolean indexedFirstRead = true;
     private boolean callStart = false;
     private boolean commitOnModification = true;
+    private int fetchKeyIndex = -1;
 
     /** TODO: 準備中 */
     public static final int COB_EQ = 1;
@@ -295,6 +296,7 @@ public int open_(String filename, int mode, int sharing) {
         this.indexedFirstRead = true;
         this.callStart = false;
 
+        this.fetchKeyIndex = -1;
         return 0;
     }
 
@@ -345,6 +347,7 @@ public int close_(int opt) {
         } catch (SQLException e) {
             return COB_STATUS_30_PERMANENT_ERROR;
         }
+        this.fetchKeyIndex = -1;
         return COB_STATUS_00_SUCCESS;
     }
 
@@ -366,6 +369,7 @@ public int indexed_start_internal(
                 break;
             }
         }
+        this.fetchKeyIndex = p.key_index;
 
         p.key = DBT_SET(key);
 
@@ -545,8 +549,12 @@ private int returnWith(IndexedFile p, boolean closeCursor, int index, int return
         return returnCode;
     }
 
-    /** Equivalent to indexed_write_internal in libcob/fileio.c */
     private int indexed_write_internal(boolean rewrite, int opt) {
+        return this.indexed_write_internal(rewrite, null, opt);
+    }
+
+    /** Equivalent to indexed_write_internal in libcob/fileio.c */
+    private int indexed_write_internal(boolean rewrite, int[] dupNumbers, int opt) {
         IndexedFile p = this.filei;
 
         boolean closeCursor;
@@ -592,7 +600,12 @@ private int indexed_write_internal(boolean rewrite, int opt) {
 
                 PreparedStatement insertStatement;
                 if (isDuplicateColumn(i)) {
-                    int dupNo = getNextKeyDupNo(p.connection, i, p.key);
+                    int dupNo;
+                    if (dupNumbers == null || dupNumbers[i] < 0 || i != this.fetchKeyIndex) {
+                        dupNo = getNextKeyDupNo(p.connection, i, p.key);
+                    } else {
+                        dupNo = dupNumbers[i];
+                    }
                     insertStatement =
                             p.connection.prepareStatement(
                                     String.format(
@@ -693,19 +706,25 @@ public int rewrite_(int opt) {
         }
 
         p.key = DBT_SET(this.keys[0].getField());
+        int[] dupNumbers = new int[this.nkeys];
+        java.util.Arrays.fill(dupNumbers, -1);
 
-        int ret = this.indexed_delete_internal(true);
+        int ret = this.indexed_delete_internal(true, dupNumbers);
 
         if (ret != COB_STATUS_00_SUCCESS) {
             p.write_cursor_open = false;
             return ret;
         }
 
-        return this.indexed_write_internal(true, opt);
+        return this.indexed_write_internal(true, dupNumbers, opt);
     }
 
-    /** Equivalent to indexed_delete_internal in libcob/fileio.c */
     private int indexed_delete_internal(boolean rewrite) {
+        return this.indexed_delete_internal(rewrite, null);
+    }
+
+    /** Equivalent to indexed_delete_internal in libcob/fileio.c */
+    private int indexed_delete_internal(boolean rewrite, int[] dupNumbers) {
         IndexedFile p = this.filei;
         boolean closeCursor;
 
@@ -731,6 +750,25 @@ private int indexed_delete_internal(boolean rewrite) {
 
         // delete data from sub tables
         for (int i = 1; i < this.nkeys; ++i) {
+            // save the duplicate number of the record to be deleted
+            if (isDuplicateColumn(i)) {
+                try (PreparedStatement statement =
+                        p.connection.prepareStatement(
+                                String.format(
+                                        "select dupNo from %s where value = ?", getTableName(i)))) {
+                    statement.setBytes(1, p.key);
+                    ResultSet rs = statement.executeQuery();
+                    if (rs.next()) {
+                        int dupNo = rs.getInt(1);
+                        if (dupNumbers != null) {
+                            dupNumbers[i] = dupNo;
+                        }
+                    }
+                } catch (SQLException e) {
+                    return returnWith(p, closeCursor, 0, COB_STATUS_30_PERMANENT_ERROR);
+                }
+            }
+            // delete the record
             try (PreparedStatement statement =
                     p.connection.prepareStatement(
                             String.format("delete from %s where value = ?", getTableName(i)))) {

tests/misc.src/record-key-duplicates-error.at

@@ -26,3 +26,80 @@ AT_CHECK([${COBJ} prog.cbl], [1], [],
 [prog.cbl:8: Error: Record keys with duplicates are not yet supported
 ])
 AT_CLEANUP
+
+AT_SETUP([Error on rewriting record keys with duplicates])
+
+AT_DATA([prog.cbl],
+[       IDENTIFICATION DIVISION.
+       PROGRAM-ID. prog.
+
+       ENVIRONMENT DIVISION.
+       INPUT-OUTPUT SECTION.
+       FILE-CONTROL.
+           SELECT DUP-FILE ASSIGN TO "dupfile.dat"
+               ORGANIZATION IS INDEXED
+               ACCESS MODE IS DYNAMIC
+               RECORD KEY IS DUP-KEY 
+               ALTERNATE RECORD KEY IS DUP-KEY2 WITH DUPLICATES
+               FILE STATUS IS FILE-STATUS.
+
+       DATA DIVISION.
+       FILE SECTION.
+       FD  DUP-FILE.
+       01  DUP-RECORD.
+           05  DUP-KEY      PIC X(5).
+           05  DUP-KEY2     PIC X(5).
+           05  DUP-DATA     PIC X(10).
+
+       WORKING-STORAGE SECTION.
+       01  FILE-STATUS      PIC XX.
+       01  WS-END-OF-FILE   PIC X VALUE 'N'.
+
+       PROCEDURE DIVISION.
+       MAIN-PROCEDURE.
+           OPEN OUTPUT DUP-FILE.
+           MOVE "11111AAAAAaaaaaaaaaa" TO DUP-RECORD.
+           WRITE DUP-RECORD.
+           MOVE "22222BBBBBbbbbbbbbbb" TO DUP-RECORD.
+           WRITE DUP-RECORD.
+           MOVE "33333BBBBBcccccccccc" TO DUP-RECORD.
+           WRITE DUP-RECORD.
+           MOVE "44444AAAAAdddddddddd" TO DUP-RECORD.
+           WRITE DUP-RECORD.
+           MOVE "55555CCCCCeeeeeeeeee" TO DUP-RECORD.
+           WRITE DUP-RECORD.
+           CLOSE DUP-FILE.
+
+           OPEN I-O DUP-FILE
+           IF FILE-STATUS NOT = "00"
+              DISPLAY "Error opening file: " FILE-STATUS
+              STOP RUN
+           END-IF.
+
+           MOVE "BBBBB" TO DUP-KEY2.
+           START DUP-FILE KEY IS >= DUP-KEY2.
+           IF FILE-STATUS = "00"
+               MOVE 'N' TO WS-END-OF-FILE
+               PERFORM UNTIL WS-END-OF-FILE = 'Y'
+                   READ DUP-FILE NEXT
+                       AT END
+                           MOVE 'Y' TO WS-END-OF-FILE
+                       NOT AT END
+                           REWRITE DUP-RECORD
+                           DISPLAY DUP-RECORD
+               END-PERFORM
+           ELSE
+               DISPLAY "Key not found"
+           END-IF.
+           CLOSE DUP-FILE.
+           STOP RUN.
+])
+
+AT_CHECK([${COBJ} prog.cbl])
+AT_CHECK([java prog], [0],
+[22222BBBBBbbbbbbbbbb
+33333BBBBBcccccccccc
+55555CCCCCeeeeeeeeee
+])
+
+AT_CLEANUP