fix: prevent table corruption when adding column after deleted var-length column

mutateAddColumn() wrote the current live var-column count instead of
the historical max, corrupting the table definition and later causing
raw ArrayIndexOutOfBoundsExceptions on read/write. Wrap remaining
inconsistencies as JackcessException instead of leaking unchecked
exceptions.

Reported-by: @congjun-yang
Closes #10

Author: spannm

src/main/java/io/github/spannm/jackcess/impl/TableImpl.java

@@ -28,6 +28,7 @@
 import java.lang.System.Logger;
 import java.lang.System.Logger.Level;
 import java.nio.BufferOverflowException;
+import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.time.LocalDateTime;
@@ -765,7 +766,21 @@ private static Object getRowColumn(JetFormat format, ByteBuffer rowBuffer, Colum
             // cache "raw" row value. see note about caching above
             rowState.withRowCacheValue(column.getColumnIndex(), ColumnImpl.rawDataWrapper(columnData));
 
-            return rowState.handleRowError(column, columnData, _ex);
+            Exception rowError = _ex;
+            if (_ex instanceof IndexOutOfBoundsException || _ex instanceof NegativeArraySizeException
+                || _ex instanceof BufferUnderflowException || _ex instanceof BufferOverflowException) {
+                // these particular runtime exceptions typically indicate corrupted or
+                // inconsistent table metadata (e.g. bad column offsets) rather than a
+                // normal, expected read failure. wrap them in a proper (checked)
+                // IOException so that callers relying on the declared "throws
+                // IOException" contract of the read methods do not have to also
+                // anticipate an arbitrary unchecked exception escaping
+                rowError = new JackcessException(
+                    "Likely data corruption encountered reading column " + column.getName()
+                        + " of table " + column.getTable().getName(), _ex);
+            }
+
+            return rowState.handleRowError(column, columnData, rowError);
         }
     }
 
@@ -1077,7 +1092,7 @@ protected ColumnImpl mutateAddColumn(TableUpdater mutator) throws IOException {
             // update various bits of the table def
             ByteUtil.forward(tableBuffer, 29);
             tableBuffer.putShort((short) (_maxColumnCount + 1));
-            short varColCount = (short) (_varColumns.size() + (isVarCol ? 1 : 0));
+            short varColCount = (short) (_maxVarColumnCount + (isVarCol ? 1 : 0));
             tableBuffer.putShort(varColCount);
             tableBuffer.putShort((short) (_columns.size() + 1));
 
@@ -2546,6 +2561,17 @@ private ByteBuffer createRow(Object[] rowArray, ByteBuffer buffer, int minRowSiz
             short[] varColumnOffsets = new short[_maxVarColumnCount];
             int varColumnOffsetsIndex = 0;
             for (ColumnImpl varCol : _varColumns) {
+                if (varCol.getVarLenTableIndex() >= varColumnOffsets.length) {
+                    // this indicates an inconsistency between the number of variable
+                    // length columns recorded in the table definition and the actual
+                    // columns present (e.g. a corrupted table definition); fail with a
+                    // clear, checked exception instead of an opaque
+                    // ArrayIndexOutOfBoundsException
+                    throw new JackcessException(withErrorContext(
+                        "Table definition is inconsistent: variable length column " + varCol.getName()
+                            + " has an out of range column offset index; the table definition may be corrupted"));
+                }
+
                 short offset = (short) buffer.position();
                 Object rowValue = varCol.getRowValue(rowArray);
                 if (rowValue != null) {

src/test/java/io/github/spannm/jackcess/DatabaseTest.java

@@ -304,6 +304,58 @@ void testReadWithDeletedCols(TestDb testDb) throws IOException {
         }
     }
 
+    @ParameterizedTest(name = "[{index}] {0}")
+    @TestDbSource(DEL_COL)
+    void testAddColumnAfterDeletedVarLenColumns(TestDb testDb) throws IOException {
+        // regression test for GH issue #10: adding a column to a table which
+        // previously had variable length columns deleted from it must not corrupt
+        // the table definition's variable column count. the corruption is only
+        // persisted to (and later observable from) disk, so the db must be closed
+        // and reopened to actually exercise the bug
+        File dbFile;
+        try (Database db = testDb.openCopy()) {
+            dbFile = db.getFile();
+            Table table = db.getTable("Table1");
+            DatabaseBuilder.newColumn("newCol", DataType.BOOLEAN).addToTable(table);
+        }
+
+        Map<String, Object> newRow = new LinkedHashMap<>(Map.of(
+            "id", 9, "id2", 9, "data", "baz", "data2", "baz2", "newCol", Boolean.TRUE));
+
+        try (Database db = DatabaseBuilder.open(dbFile)) {
+            Table table = db.getTable("Table1");
+            table.addRow(newRow.get("id"), newRow.get("id2"), newRow.get("data"), newRow.get("data2"), newRow.get("newCol"));
+        }
+
+        Map<String, Object> expectedRow0 = new LinkedHashMap<>(Map.of(
+            "id", 0, "id2", 2, "data", "foo", "data2", "foo2"));
+        expectedRow0.put("newCol", Boolean.FALSE);
+
+        Map<String, Object> expectedRow1 = new LinkedHashMap<>(Map.of(
+            "id", 3, "id2", 5, "data", "bar", "data2", "bar2"));
+        expectedRow1.put("newCol", Boolean.FALSE);
+
+        try (Database db = DatabaseBuilder.open(dbFile)) {
+            Table table = db.getTable("Table1");
+
+            int rowNum = 0;
+            Map<String, Object> row = null;
+            while ((row = table.getNextRow()) != null) {
+                if (rowNum == 0) {
+                    assertEquals(expectedRow0, row);
+                } else if (rowNum == 1) {
+                    assertEquals(expectedRow1, row);
+                } else if (rowNum == 2) {
+                    assertEquals(newRow, row);
+                } else {
+                    fail("should only have 3 rows");
+                }
+                rowNum++;
+            }
+            assertEquals(3, rowNum);
+        }
+    }
+
     @ParameterizedTest(name = "[{index}] {0}")
     @FileFormatSource
     void testCurrency(FileFormat fileFormat) throws IOException {