fix: pin AutoNumber tables to survive GC between DDL and DML

Jackcess's internal table cache holds Table instances only via
WeakReference. DISABLE/ENABLE AUTOINCREMENT ON toggles
allowAutoNumberInsert directly on the Table object returned by
getTable(), but nothing kept a strong reference to it afterwards. If
GC collected that table between the DDL statement and a subsequent
INSERT, the table was transparently reloaded with the flag reset to
its default, silently discarding explicit AutoNumber values in favor
of auto-generated ones.

DBReference now pins tables with an explicit allowAutoNumberInsert
toggle in a strongly-referenced map, cleared whenever dbIO is
reloaded. Add a regression test that forces GC passes between the
DDL and DML statements to catch this deterministically.

Author: spannm

src/main/java/net/ucanaccess/jdbc/AbstractExecute.java

@@ -1,5 +1,6 @@
 package net.ucanaccess.jdbc;
 
+import io.github.spannm.jackcess.Table;
 import net.ucanaccess.commands.DDLCommandEnlist;
 import net.ucanaccess.converters.Metadata;
 import net.ucanaccess.converters.SQLConverter;
@@ -65,7 +66,11 @@ private Object enableDisable(DDLType ddlType) throws SQLException, IOException {
             throw new TableNotFoundException(tableName);
         }
         boolean enableAutoIncr = ddlType.equals(DDLType.ENABLE_AUTOINCREMENT);
-        conn.getDbIO().getTable(rtn).setAllowAutoNumberInsert(!enableAutoIncr);
+        Table table = conn.getDbIO().getTable(rtn);
+        table.setAllowAutoNumberInsert(!enableAutoIncr);
+        // Jackcess only holds this Table via a WeakReference in its internal cache; pin it here so a GC pass
+        // between this DDL statement and a later DML statement can't silently reset the flag we just set.
+        conn.pinAutoNumberTable(rtn, table);
         if (this instanceof Execute) {
             return false;
         } else {

src/main/java/net/ucanaccess/jdbc/DBReference.java

@@ -29,6 +29,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -72,6 +73,14 @@ public class DBReference {
     private boolean                                 hsqldbShutdown;
     private File                                    mirrorFolder;
     private final Set<File>                         links             = new HashSet<>();
+    /**
+     * Holds strong references to {@link Table} instances on which a caller has explicitly toggled
+     * {@code allowAutoNumberInsert} (via {@code DISABLE}/{@code ENABLE AUTOINCREMENT ON}). Jackcess's internal
+     * table cache only holds {@link Table} objects via {@code WeakReference}s, so without this pin the GC could
+     * collect such a table between statements; the table would then be transparently reloaded on next access,
+     * silently resetting {@code allowAutoNumberInsert} to its default and losing the toggle.
+     */
+    private final Map<String, Table>                pinnedAutoNumberTables = new HashMap<>();
     private boolean                                 ignoreCase        = true;
     private boolean                                 mirrorReadOnly;
     private Integer                                 lobScale;
@@ -214,6 +223,7 @@ Connection checkLastModified(Connection conn, Session session) throws Ucanaccess
             closeHsqlDb(session);
             dbIO.flush();
             dbIO.close();
+            pinnedAutoNumberTables.clear();
             dbIO = open(dbFile, pwd);
             id = createId();
             firstConnection = true;
@@ -558,10 +568,19 @@ public void reloadDbIO() throws IOException {
         for (IOnReloadReferenceListener listener : onReloadListeners) {
             listener.onReload();
         }
+        pinnedAutoNumberTables.clear();
         dbIO = open(dbFile, pwd);
 
     }
 
+    /**
+     * Pins the given table so it is not garbage-collected while an explicit {@code allowAutoNumberInsert} toggle
+     * (from {@code DISABLE}/{@code ENABLE AUTOINCREMENT ON}) is in effect on it.
+     */
+    void pinAutoNumberTable(String tableName, Table table) {
+        pinnedAutoNumberTables.put(tableName, table);
+    }
+
     public void setInactivityTimeout(int inactivityTimeout) {
         memoryTimer.setInactivityTimeout(inactivityTimeout);
     }
@@ -586,6 +605,7 @@ void shutdown(Session session) throws Exception {
             }
         }
         memoryTimer.timer.cancel();
+        pinnedAutoNumberTables.clear();
         dbIO.flush();
         dbIO.close();
         closeHsqlDb(session);

src/main/java/net/ucanaccess/jdbc/UcanaccessConnection.java

@@ -1,6 +1,7 @@
 package net.ucanaccess.jdbc;
 
 import io.github.spannm.jackcess.Database;
+import io.github.spannm.jackcess.Table;
 import net.ucanaccess.commands.CompositeCommand;
 import net.ucanaccess.commands.ICommand;
 import net.ucanaccess.commands.ICommand.CommandType;
@@ -350,6 +351,10 @@ public Database getDbIO() {
         return ref.getDbIO();
     }
 
+    void pinAutoNumberTable(String tableName, Table table) {
+        ref.pinAutoNumberTable(tableName, table);
+    }
+
     @Override
     public int getHoldability() throws SQLException {
         try {

src/test/java/net/ucanaccess/jdbc/CounterTest.java

@@ -61,4 +61,38 @@ void testCreateTypes(AccessVersion accessVersion) throws SQLException, IOExcepti
 
     }
 
+    /**
+     * Regression test for a bug where Jackcess's internal table cache holds {@link io.github.spannm.jackcess.Table}
+     * instances only via {@code WeakReference}. Without pinning, a GC pass between the {@code DISABLE AUTOINCREMENT
+     * ON} DDL statement and a subsequent {@code INSERT} could collect the {@code Table} object whose
+     * {@code allowAutoNumberInsert} flag had just been toggled; the table would then be silently reloaded with the
+     * flag reset to its default, and an explicit AutoNumber value would be replaced by an auto-generated one.
+     */
+    @ParameterizedTest(name = "[{index}] {0}")
+    @AccessVersionSource(include = "V2016")
+    void testDisableAutoincrementSurvivesGc(AccessVersion accessVersion) throws SQLException, IOException {
+        init(accessVersion);
+
+        try (UcanaccessStatement st = ucanaccess.createStatement()) {
+            executeStatements(st, "DISABLE AUTOINCREMENT ON t_counter");
+            assertTrue(st.getConnection().getDbIO().getTable("t_counter").isAllowAutoNumberInsert());
+
+            for (int i = 0; i < 5; i++) {
+                System.gc();
+                try {
+                    Thread.sleep(50);
+                } catch (InterruptedException ex) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+            assertTrue(st.getConnection().getDbIO().getTable("t_counter").isAllowAutoNumberInsert(),
+                "allowAutoNumberInsert must survive a GC pass between DDL and DML");
+
+            executeStatements(st,
+                "INSERT INTO t_counter (cntr, chr, descr) VALUES (3, 'C', 'autoincr OFF, insert arbitrary AutoNumber value')");
+        }
+
+        checkQuery("SELECT cntr, chr FROM t_counter ORDER BY cntr", recs(rec(3, "C")));
+    }
+
 }