Try Turso pager patch: treat 0-byte page read as empty (SQLite-compat)

The previous Turso patch (effective_temp_store always Memory) also
crashed testReconstructTable, so even compile-time changes to temp
table routing trip Turso's pager hypersensitivity.

Try a more targeted Turso patch: in `sqlite3_ondisk::begin_read_page`,
match SQLite's behaviour and treat a 0-byte read as a zero-filled
page instead of returning ShortRead. This is the root cause of the
"short read on page N: expected 4096 bytes, got 0" error that breaks
the temp-table tests; the existing code already has an empty-buffer
fallback path for when `allow_empty_read` is true — we just route
the bytes_read==0 case there unconditionally. Truncated reads
(1..buf_len-1) are still rejected.

Author: JanJakes

.github/workflows/phpunit-tests-turso.yml

@@ -595,49 +595,44 @@ jobs:
           print('patched CreateTrigger to preserve original SQL text')
           PY_TRIGGER_SQL
 
-          # Force temp tables to use MemoryIO under all conditions, to
-          # bypass the disk-temp pager's state-dependent
-          # `short read on page N` bug that breaks
-          # testCreateTemporaryTable + testTemporaryTableHasPriorityOverStandardTable.
-          #
-          # Setting this via runtime PRAGMA temp_store = MEMORY crashes
-          # testReconstructTable in the pager (memory:
-          # project_turso_testreconstructtable_fragile). Instead, patch
-          # `effective_temp_store` so it returns `TempStore::Memory`
-          # unconditionally — a compile-time change that doesn't go
-          # through `set_temp_store` / `bump_prepare_context_generation`,
-          # so testReconstructTable's prepared-statement cache is
-          # untouched.
-          python3 - <<'PY_TEMP_MEMORY'
-          p = 'core/connection.rs'
+          # Treat 0-byte page reads as empty pages instead of erroring.
+          # SQLite's pager treats reads past EOF as zero-filled; Turso
+          # bails with `short read on page N: expected 4096 bytes, got 0`,
+          # which surfaces as a state-dependent failure mid-suite for
+          # testCreateTemporaryTable and testTemporaryTableHasPriorityOverStandardTable.
+          # Drop the !allow_empty_read special case for the bytes_read==0
+          # branch so the existing empty-buffer path runs instead — match
+          # SQLite's "zeros past EOF" behaviour.
+          python3 - <<'PY_PAGER_EMPTY_READ'
+          p = 'core/storage/sqlite3_ondisk.rs'
           s = open(p).read()
           old = (
-              "    fn effective_temp_store(&self) -> crate::TempStore {\n"
-              "        let temp_store = self.get_temp_store();\n"
-              "        #[cfg(feature = \"fs\")]\n"
-              "        {\n"
-              "            temp_store\n"
-              "        }\n"
-              "        #[cfg(not(feature = \"fs\"))]\n"
-              "        {\n"
-              "            let _ = temp_store;\n"
-              "            crate::TempStore::Memory\n"
-              "        }\n"
-              "    }\n"
+              "        // Handle truncated database files: if we read fewer bytes than expected\n"
+              "        // (and it's not an intentional empty read), return a ShortRead error.\n"
+              "        if bytes_read == 0 {\n"
+              "            if !allow_empty_read {\n"
+              "                tracing::error!(\"short read on page {page_idx}: expected {buf_len} bytes, got 0\");\n"
+              "                page.clear_locked();\n"
+              "                return Some(CompletionError::ShortRead {\n"
+              "                    page_idx,\n"
+              "                    expected: buf_len,\n"
+              "                    actual: 0,\n"
+              "                });\n"
+              "            }\n"
+              "        } else if bytes_read != buf_len as i32 {\n"
           )
           new = (
-              "    fn effective_temp_store(&self) -> crate::TempStore {\n"
-              "        // Always use MemoryIO for temp tables: avoids a state-dependent\n"
-              "        // `short read on page N` bug in the disk-temp pager that breaks\n"
-              "        // testCreateTemporaryTable mid-suite under PHPUnit.\n"
-              "        let _ = self.get_temp_store();\n"
-              "        crate::TempStore::Memory\n"
-              "    }\n"
+              "        // Match SQLite: a read of 0 bytes (page beyond EOF / not yet\n"
+              "        // written) is treated as a zero-filled page instead of an error.\n"
+              "        // Truncated reads (1..buf_len-1 bytes) are still rejected.\n"
+              "        if bytes_read == 0 {\n"
+              "            // fall through to the empty-buffer path below\n"
+              "        } else if bytes_read != buf_len as i32 {\n"
           )
-          assert old in s, 'effective_temp_store block not found'
+          assert old in s, 'sqlite3_ondisk short-read block not found'
           open(p, 'w').write(s.replace(old, new, 1))
-          print('patched effective_temp_store to always return TempStore::Memory')
-          PY_TEMP_MEMORY
+          print('patched sqlite3_ondisk to treat 0-byte page read as empty (SQLite-compatible)')
+          PY_PAGER_EMPTY_READ
 
           echo '--- Patched stub! macro ---'
           sed -n '/macro_rules! stub/,/^}$/p' sqlite3/src/lib.rs