fix(core.utils): treat empty schema_meta as unknown-version for entries rebuild

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -1089,41 +1089,44 @@ def _connect_and_init(self) -> None:
 
         # Detect an existing schema version *before* creating any tables so
         # a structural migration (added columns / renamed indexes) can be
-        # handled by dropping the old tables outright.
+        # handled by dropping the old tables outright. Two cases yield
+        # "version unknown": schema_meta is missing entirely, or schema_meta
+        # exists but has no ``schema_version`` row. Both mean we can't trust
+        # any pre-existing ``entries`` layout -- CREATE TABLE IF NOT EXISTS
+        # would keep it and later reads/writes would fail with
+        # OperationalError instead of recovering to an empty cache.
         existing_version = None
-        schema_meta_missing = False
+        schema_version_known = False
         try:
             row = self._conn.execute(
                 "SELECT value FROM schema_meta WHERE key = ?",
                 ("schema_version",),
             ).fetchone()
             if row is not None:
                 existing_version = row[0]
+                schema_version_known = True
         except self._sqlite3.OperationalError:
             # schema_meta doesn't exist.
-            schema_meta_missing = True
+            pass
 
-        # If schema_meta is absent but an ``entries`` table is already
-        # present (e.g. the file was produced by a different tool or a
-        # pre-schema_meta version of this cache), treat the DB as
-        # incompatible: CREATE TABLE IF NOT EXISTS would keep the old
-        # ``entries`` layout and later reads/writes would fail with
-        # OperationalError instead of recovering to an empty cache.
-        entries_present_without_schema_meta = False
-        if schema_meta_missing:
+        # If the schema_version isn't known but an ``entries`` table exists,
+        # the DB came from a different tool or a pre-schema_meta revision;
+        # drop and rebuild. If both are present and match, leave in place.
+        entries_present_with_unknown_version = False
+        if not schema_version_known:
             row = self._conn.execute(
                 "SELECT name FROM sqlite_master WHERE type='table' AND name='entries'",
             ).fetchone()
-            entries_present_without_schema_meta = row is not None
+            entries_present_with_unknown_version = row is not None
 
         needs_drop = (
-            (existing_version is not None and existing_version != _SQLITE_SCHEMA_VERSION)
-            or entries_present_without_schema_meta
+            (schema_version_known and existing_version != _SQLITE_SCHEMA_VERSION)
+            or entries_present_with_unknown_version
         )
         if needs_drop:
             # Drop all cache tables -- ensures structural mismatch (whether
-            # a version bump or a foreign ``entries`` layout) can't leave a
-            # legacy table in place.
+            # a version bump or a foreign/pre-schema_meta ``entries``
+            # layout) can't leave a legacy table in place.
             self._conn.execute("DROP TABLE IF EXISTS entries")
             self._conn.execute("DROP TABLE IF EXISTS schema_meta")
 

cuda_core/tests/test_program_cache.py

@@ -1935,6 +1935,29 @@ def test_sqlite_cache_drops_foreign_entries_table_without_schema_meta(tmp_path):
         assert bytes(cache[b"k"].code) == b"v"
 
 
+@needs_sqlite3
+def test_sqlite_cache_drops_entries_when_schema_meta_is_empty(tmp_path):
+    """schema_meta exists but has no schema_version row: the cache version
+    is unknown, so any pre-existing ``entries`` table is untrusted and must
+    be dropped. Otherwise CREATE TABLE IF NOT EXISTS would keep the foreign
+    layout and later reads/writes would fail with OperationalError."""
+    import sqlite3
+
+    from cuda.core.utils import SQLiteProgramCache
+
+    db = tmp_path / "cache.db"
+    with sqlite3.connect(db) as conn:
+        conn.execute("CREATE TABLE schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute("CREATE TABLE entries (id INTEGER PRIMARY KEY, junk TEXT)")
+        conn.execute("INSERT INTO entries (id, junk) VALUES (1, 'legacy')")
+        conn.commit()
+
+    with SQLiteProgramCache(db) as cache:
+        assert len(cache) == 0
+        cache[b"k"] = _fake_object_code(b"v")
+        assert bytes(cache[b"k"].code) == b"v"
+
+
 @needs_sqlite3
 def test_sqlite_cache_schema_version_encodes_key_schema(tmp_path, monkeypatch):
     """Bumping ``_KEY_SCHEMA_VERSION`` must invalidate existing on-disk