Add targeted Doltlite write-visibility probes

Seven minimal PHP/PDO probes to narrow where the remaining ALTER TABLE
failures come from: sequential DELETEs on rowid and composite-PK tables,
prepared-statement reuse, INSERT+DELETE ordering, NOCASE round-trip,
and the INSERT..SELECT table-rebuild path.

Author: JanJakes

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

@@ -119,6 +119,113 @@ jobs:
             exit 1
           fi
 
+      - name: Probe Doltlite write-visibility on info-schema-shaped tables
+        # The ALTER TABLE failures look like "the last DELETE/UPDATE against
+        # info_schema.columns isn't visible to the follow-up SELECT". Run
+        # a few targeted scenarios to narrow where the bug is.
+        run: |
+          php -r '
+          $db = new PDO("sqlite::memory:");
+          $db->exec("PRAGMA foreign_keys = ON");
+
+          function probe(PDO $db, string $label, string $setup, string $check, $expected): void {
+            $db->exec($setup);
+            $actual = $db->query($check)->fetchAll(PDO::FETCH_NUM);
+            $ok = json_encode($actual) === json_encode($expected);
+            printf("[%s] %s\n", $ok ? "PASS" : "FAIL", $label);
+            if (!$ok) {
+              printf("  setup: %s\n", str_replace("\n", " ", $setup));
+              printf("  check: %s\n", $check);
+              printf("  expected: %s\n", json_encode($expected));
+              printf("  actual:   %s\n", json_encode($actual));
+            }
+          }
+
+          // 1. Plain rowid table, two sequential DELETEs.
+          probe($db, "two DELETEs on rowid table",
+            "DROP TABLE IF EXISTS t1;
+             CREATE TABLE t1 (ts TEXT, tn TEXT, cn TEXT);
+             INSERT INTO t1 VALUES (\"s\",\"t\",\"a\"),(\"s\",\"t\",\"b\"),(\"s\",\"t\",\"c\");
+             DELETE FROM t1 WHERE ts=\"s\" AND tn=\"t\" AND cn=\"a\";
+             DELETE FROM t1 WHERE ts=\"s\" AND tn=\"t\" AND cn=\"b\";",
+            "SELECT cn FROM t1 ORDER BY cn",
+            [["c"]]
+          );
+
+          // 2. Same, but with the composite PK shape info_schema uses.
+          // (After our ROWID patch, this should be a rowid table + unique index.)
+          probe($db, "two DELETEs on composite-PK table (rowid-patched)",
+            "DROP TABLE IF EXISTS t2;
+             CREATE TABLE t2 (ts TEXT, tn TEXT, cn TEXT, PRIMARY KEY (ts, tn, cn));
+             INSERT INTO t2 VALUES (\"s\",\"t\",\"a\"),(\"s\",\"t\",\"b\"),(\"s\",\"t\",\"c\");
+             DELETE FROM t2 WHERE ts=\"s\" AND tn=\"t\" AND cn=\"a\";
+             DELETE FROM t2 WHERE ts=\"s\" AND tn=\"t\" AND cn=\"b\";",
+            "SELECT cn FROM t2 ORDER BY cn",
+            [["c"]]
+          );
+
+          // 3. Same, with prepared statements reused across the two DELETEs
+          //    (same shape the driver uses).
+          probe($db, "two prepared DELETEs on composite-PK table",
+            "DROP TABLE IF EXISTS t3;
+             CREATE TABLE t3 (ts TEXT, tn TEXT, cn TEXT, PRIMARY KEY (ts, tn, cn));
+             INSERT INTO t3 VALUES (\"s\",\"t\",\"a\"),(\"s\",\"t\",\"b\"),(\"s\",\"t\",\"c\");",
+            "SELECT cn FROM t3 WHERE cn NOT IN (\"a\",\"b\") ORDER BY cn",
+            [["c"]]
+          );
+          $stmt = $db->prepare("DELETE FROM t3 WHERE ts=? AND tn=? AND cn=?");
+          $stmt->execute(["s","t","a"]);
+          $stmt->execute(["s","t","b"]);
+          $after = $db->query("SELECT cn FROM t3 ORDER BY cn")->fetchAll(PDO::FETCH_NUM);
+          printf("[%s] two prepared DELETEs actual: %s (expect [[\"c\"]])\n",
+                 json_encode($after) === json_encode([["c"]]) ? "PASS" : "FAIL",
+                 json_encode($after));
+
+          // 4. INSERT then DELETE a different row, then SELECT.
+          probe($db, "INSERT then DELETE on composite-PK table",
+            "DROP TABLE IF EXISTS t4;
+             CREATE TABLE t4 (ts TEXT, tn TEXT, cn TEXT, PRIMARY KEY (ts, tn, cn));
+             INSERT INTO t4 VALUES (\"s\",\"t\",\"a\");
+             INSERT INTO t4 VALUES (\"s\",\"t\",\"b\");
+             DELETE FROM t4 WHERE ts=\"s\" AND tn=\"t\" AND cn=\"a\";",
+            "SELECT cn FROM t4 ORDER BY cn",
+            [["b"]]
+          );
+
+          // 5. NOCASE column: does Doltlite return the stored case or folded?
+          probe($db, "NOCASE column preserves original case",
+            "DROP TABLE IF EXISTS t5;
+             CREATE TABLE t5 (id INTEGER PRIMARY KEY, name TEXT COLLATE NOCASE);
+             INSERT INTO t5 VALUES (1, \"Johnny\");",
+            "SELECT name FROM t5",
+            [["Johnny"]]
+          );
+
+          // 6. Same NOCASE column, but covered by a unique index (what VARCHAR
+          //    PK columns look like in the driver).
+          probe($db, "NOCASE column with unique index preserves original case",
+            "DROP TABLE IF EXISTS t6;
+             CREATE TABLE t6 (id INTEGER PRIMARY KEY, name TEXT COLLATE NOCASE, UNIQUE(name));
+             INSERT INTO t6 VALUES (1, \"Johnny\");",
+            "SELECT name FROM t6",
+            [["Johnny"]]
+          );
+
+          // 7. Rebuild via INSERT...SELECT, similar to the ALTER TABLE
+          //    rewrite path; does the case survive the round-trip?
+          probe($db, "rebuild via INSERT..SELECT preserves case",
+            "DROP TABLE IF EXISTS t7_old;
+             DROP TABLE IF EXISTS t7_new;
+             CREATE TABLE t7_old (ID INTEGER NOT NULL, name TEXT COLLATE NOCASE NOT NULL, PRIMARY KEY (ID, name));
+             INSERT INTO t7_old VALUES (1, \"Johnny\");
+             CREATE TABLE t7_new (ID INTEGER NOT NULL, firstname TEXT COLLATE NOCASE, PRIMARY KEY (ID, firstname));
+             INSERT INTO t7_new (ID, firstname) SELECT ID, name FROM t7_old;",
+            "SELECT firstname FROM t7_new",
+            [["Johnny"]]
+          );
+          '
+        continue-on-error: true
+
       - name: Install Composer dependencies (root)
         uses: ramsey/composer-install@v3
         with: