Compose the named-stage master per object instead of adopting working wholesale

Tim · claude · Tim · commit 2d4dfe0ea2c4 · 2026-07-16T14:03:49.000-07:00
A named add previously adopted the whole working master root into the
staged catalog, dragging unstaged schema changes into the commit: an
unstaged ALTER on another table rode along, and an unstaged DROP INDEX
destroyed a staged index. The staged master is now composed row by row:
table and index rows of the named objects (adds, staged drops, vtab
shadows, retired rename names) come from working, everything else keeps
the previously staged rows, and views and triggers always keep staged
state.

Composed rows cross catalog numbering domains, so old-sourced table rows
are renumbered to the working table number their aligned entries carry,
and the serializer rejects two cross-domain pairings in constructed
arrays: an unnamed entry never pairs with a table row, and a named add
only pairs with an unnamed staged entry when the staged schema rows
identify that entry as the same table.

The index schema row comparison shared by status and diff summary moves
to a single helper.

Co-Authored-By: Claude Fable 5 &lt;noreply@anthropic.com&gt;
diff --git a/src/doltlite.c b/src/doltlite.c
@@ -991,6 +991,45 @@ static int addWriteStagedCatalog(
   return rc;
 }
 
+/* True when the two catalogs' index schema rows for zTable differ: any
+** index added, dropped, re-targeted, or redefined. Index changes carry no
+** named catalog entry, so every surface that reports per-table change
+** (status, the diff summary) attributes them through this comparison. */
+int doltliteIndexSchemaRowsDifferForTable(
+  SchemaEntry *aA, int nA,
+  SchemaEntry *aB, int nB,
+  const char *zTable
+){
+  int i, j, nMatchA = 0, nBForTable = 0;
+  for(i=0; i<nA; i++){
+    int found = 0;
+    if( !aA[i].zType || strcmp(aA[i].zType, "index")!=0
+     || !aA[i].zTblName || strcmp(aA[i].zTblName, zTable)!=0 ){
+      continue;
+    }
+    for(j=0; j<nB; j++){
+      if( aB[j].zType && strcmp(aB[j].zType, "index")==0
+       && aB[j].zTblName && strcmp(aB[j].zTblName, zTable)==0
+       && aB[j].zName && aA[i].zName
+       && strcmp(aB[j].zName, aA[i].zName)==0
+       && ((aB[j].zSql==0)==(aA[i].zSql==0))
+       && (aB[j].zSql==0 || strcmp(aB[j].zSql, aA[i].zSql)==0) ){
+        found = 1;
+        break;
+      }
+    }
+    if( !found ) return 1;
+    nMatchA++;
+  }
+  for(j=0; j<nB; j++){
+    if( aB[j].zType && strcmp(aB[j].zType, "index")==0
+     && aB[j].zTblName && strcmp(aB[j].zTblName, zTable)==0 ){
+      nBForTable++;
+    }
+  }
+  return nMatchA!=nBForTable;
+}
+
 /* True when the final staged entry list contains a table entry named
 ** zTbl. Index entries follow their parent table through -a staging, and
 ** the parent's presence decides whether an index entry belongs at all. */
@@ -1311,14 +1350,35 @@ static int addStageNamedTables(
   SchemaEntry *aStagedSchema = 0;
   int nWorkSchema = 0;
   int nStagedSchema = 0;
+  /* Objects whose master rows follow WORKING in this operation: the named
+  ** tables (adds and staged drops) plus a staged vtab's shadows. Names are
+  ** borrowed from the argv values and schema arrays, which outlive use. */
+  char **azTouched = 0;
+  int nTouched = 0;
 
   #define ADDNAMED_FREE_ALL() do { \
+    int ft_; \
+    for(ft_=0; ft_<nTouched; ft_++) sqlite3_free(azTouched[ft_]); \
+    sqlite3_free((void*)azTouched); \
     freeSchemaEntries(aWorkSchema, nWorkSchema); \
     freeSchemaEntries(aStagedSchema, nStagedSchema); \
     doltliteFreeCatalog(aWorking, nWorking); \
     doltliteFreeCatalog(aStaged, nStaged); \
   } while(0)
 
+  #define ADDNAMED_TOUCH(zN) do { \
+    char **azNew = sqlite3_realloc((void*)azTouched, \
+        (nTouched+1)*(int)sizeof(char*)); \
+    char *zOwn_ = azNew ? sqlite3_mprintf("%s", (zN)) : 0; \
+    if( azNew ) azTouched = azNew; \
+    if( !azNew || !zOwn_ ){ \
+      ADDNAMED_FREE_ALL(); \
+      sqlite3_result_error_nomem(context); \
+      return SQLITE_NOMEM; \
+    } \
+    azTouched[nTouched++] = zOwn_; \
+  } while(0)
+
   rc = addLoadWorkingAndStagedCatalogs(db, pWorkingHash,
                                        &aWorking, &nWorking,
                                        &aStaged, &nStaged);
@@ -1369,6 +1429,7 @@ static int addStageNamedTables(
     {
       Table *pLive = sqlite3FindTable(db, zTable, "main");
       if( pLive && IsVirtual(pLive) ){
+        int w;
         rc = addStageShadowTablesOf(db, context, &aStaged, &nStaged,
                                     aWorking, nWorking,
                                     aWorkSchema, nWorkSchema,
@@ -1377,6 +1438,16 @@ static int addStageNamedTables(
           ADDNAMED_FREE_ALL();
           return rc;
         }
+        ADDNAMED_TOUCH(zTable);
+        for(w=0; w<nWorkSchema; w++){
+          if( aWorkSchema[w].zType
+           && strcmp(aWorkSchema[w].zType, "table")==0
+           && aWorkSchema[w].zName
+           && strcmp(aWorkSchema[w].zName, zTable)!=0
+           && sqlite3IsShadowTableOf(db, pLive, aWorkSchema[w].zName) ){
+            ADDNAMED_TOUCH(aWorkSchema[w].zName);
+          }
+        }
         updateMaster = 1;
         continue;
       }
@@ -1422,6 +1493,7 @@ static int addStageNamedTables(
         addRemoveShadowEntriesOfDroppedVtab(aStaged, &nStaged,
                                             aStagedSchema, nStagedSchema,
                                             aWorking, nWorking, zTable);
+        ADDNAMED_TOUCH(zTable);
         updateMaster = 1;
       }
       if( !found ){
@@ -1446,21 +1518,44 @@ static int addStageNamedTables(
           int nameMatch = aStaged[k].zName && aWorking[j].zName
             && strcmp(aStaged[k].zName, aWorking[j].zName)==0;
           int rootMatch = aStaged[k].iTable==iTable;
-          int unnamedRootMatch = rootMatch
-            && (!aStaged[k].zName || !aWorking[j].zName);
+          /* An unnamed staged entry on a bare number match can be a
+          ** cross-domain collision with an index entry; pair only when
+          ** the staged catalog's own schema rows say the entry at this
+          ** number is this very table. */
+          int unnamedRootMatch = 0;
           int renameRootMatch = rootMatch
             && aStaged[k].zName && aWorking[j].zName
             && strcmp(aStaged[k].zName, aWorking[j].zName)!=0
             && !addFindEntryByName(aWorking, nWorking, aStaged[k].zName)
             && !addFindEntryByName(aStaged, nStaged, aWorking[j].zName);
+          if( rootMatch && !aStaged[k].zName && aWorking[j].zName ){
+            int r;
+            for(r=0; r<nStagedSchema; r++){
+              if( aStagedSchema[r].iRootpage==aStaged[k].iTable
+               && aStagedSchema[r].zType
+               && strcmp(aStagedSchema[r].zType, "table")==0
+               && aStagedSchema[r].zName
+               && strcmp(aStagedSchema[r].zName, aWorking[j].zName)==0 ){
+                unnamedRootMatch = 1;
+                break;
+              }
+            }
+          }
           if( nameMatch || unnamedRootMatch || renameRootMatch ){
             int schemaChanged =
               prollyHashCompare(&aStaged[k].schemaHash, &aWorking[j].schemaHash)!=0;
             int nameChanged =
               (!aStaged[k].zName) != (!aWorking[j].zName)
               || (aStaged[k].zName && aWorking[j].zName
                   && strcmp(aStaged[k].zName, aWorking[j].zName)!=0);
-            char *zDup = aWorking[j].zName
+            char *zDup;
+            /* A rename retires the old name: its rows (and its indexes'
+            ** rows, keyed by the old tbl_name) must follow WORKING too,
+            ** where they no longer exist. */
+            if( nameChanged && aStaged[k].zName ){
+              ADDNAMED_TOUCH(aStaged[k].zName);
+            }
+            zDup = aWorking[j].zName
                            ? sqlite3_mprintf("%s", aWorking[j].zName) : 0;
             if( aWorking[j].zName && !zDup ){
               ADDNAMED_FREE_ALL();
@@ -1504,6 +1599,7 @@ static int addStageNamedTables(
           ADDNAMED_FREE_ALL();
           return rc;
         }
+        ADDNAMED_TOUCH(zTable);
         break;
       }
     }
@@ -1523,6 +1619,7 @@ static int addStageNamedTables(
               &pWorkingMaster->root, pWorkingMaster->flags,
               pStagedMaster ? &pStagedMaster->root : 0,
               pStagedMaster ? pStagedMaster->flags : 0,
+              (const char**)azTouched, nTouched,
               &composedRoot);
       if( rc!=SQLITE_OK ){
         ADDNAMED_FREE_ALL();
@@ -1549,6 +1646,7 @@ static int addStageNamedTables(
   addAlignStagedEntriesToWorking(aWorking, nWorking, aStaged, nStaged);
   rc = addWriteStagedCatalog(db, cs, aStaged, nStaged);
   ADDNAMED_FREE_ALL();
+  #undef ADDNAMED_TOUCH
   #undef ADDNAMED_FREE_ALL
   if( rc!=SQLITE_OK ){
     sqlite3_result_error_code(context, rc);
diff --git a/src/doltlite_diff.c b/src/doltlite_diff.c
@@ -282,45 +282,6 @@ static int batchAppend(DoltliteDiffCursor *pCur,
   return SQLITE_OK;
 }
 
-/* Index changes carry no named entry of their own: attribute them to the
-** parent table by comparing each catalog's index schema rows (name + sql),
-** so an index-only commit reports the table with schema_change=1 the way
-** Dolt does. */
-static int indexRowsDifferForTable(
-  SchemaEntry *aA, int nA,
-  SchemaEntry *aB, int nB,
-  const char *zTable
-){
-  int i, j, nMatchA = 0, nB4T = 0;
-  for(i=0; i<nA; i++){
-    int found = 0;
-    if( !aA[i].zType || strcmp(aA[i].zType, "index")!=0
-     || !aA[i].zTblName || strcmp(aA[i].zTblName, zTable)!=0 ){
-      continue;
-    }
-    for(j=0; j<nB; j++){
-      if( aB[j].zType && strcmp(aB[j].zType, "index")==0
-       && aB[j].zTblName && strcmp(aB[j].zTblName, zTable)==0
-       && aB[j].zName && aA[i].zName
-       && strcmp(aB[j].zName, aA[i].zName)==0
-       && ((aB[j].zSql==0)==(aA[i].zSql==0))
-       && (aB[j].zSql==0 || strcmp(aB[j].zSql, aA[i].zSql)==0) ){
-        found = 1;
-        break;
-      }
-    }
-    if( !found ) return 1;
-    nMatchA++;
-  }
-  for(j=0; j<nB; j++){
-    if( aB[j].zType && strcmp(aB[j].zType, "index")==0
-     && aB[j].zTblName && strcmp(aB[j].zTblName, zTable)==0 ){
-      nB4T++;
-    }
-  }
-  return nMatchA!=nB4T;
-}
-
 static int loadIndexSchemaRows(
   sqlite3 *db,
   const ProllyHash *pCatHash,
@@ -388,7 +349,7 @@ static int diffFilteredTableRoots(
         rc = loadIndexSchemaRows(db, pParentCat, &aParentRows, &nParentRows);
       }
       if( rc==SQLITE_OK
-       && indexRowsDifferForTable(aChildRows, nChildRows,
+       && doltliteIndexSchemaRowsDifferForTable(aChildRows, nChildRows,
                                   aParentRows, nParentRows,
                                   pCur->zFilterTable) ){
         schemaChange = 1;
@@ -515,7 +476,7 @@ static int diffCatalogPair(
       dataChange   = (prollyHashCompare(&e->root, &p->root) != 0) ? 1 : 0;
       schemaChange = (prollyHashCompare(&e->schemaHash, &p->schemaHash) != 0) ? 1 : 0;
       if( !schemaChange
-       && indexRowsDifferForTable(aChildRows, nChildRows,
+       && doltliteIndexSchemaRowsDifferForTable(aChildRows, nChildRows,
                                   aParentRows, nParentRows, e->zName) ){
         schemaChange = 1;
       }
diff --git a/src/doltlite_internal.h b/src/doltlite_internal.h
@@ -922,9 +922,12 @@ int doltliteMergeCatalogs(sqlite3 *db,
     int bPreferOurMaster,
     char ***pazReindex, int *pnReindex);
 void doltliteFreeNameList(char **az, int n);
+int doltliteIndexSchemaRowsDifferForTable(SchemaEntry *aA, int nA,
+    SchemaEntry *aB, int nB, const char *zTable);
 int doltliteBuildNamedStageMasterRoot(sqlite3 *db,
     const ProllyHash *pWorkingMaster, u8 workingFlags,
     const ProllyHash *pOldMaster, u8 oldFlags,
+    const char **azTouched, int nTouched,
     ProllyHash *pNewRoot);
 int doltliteReindexNamedIndexes(sqlite3 *db, char **az, int n);
 
diff --git a/src/doltlite_status.c b/src/doltlite_status.c
@@ -361,15 +361,6 @@ static int statusRowExists(
   return 0;
 }
 
-static int statusSchemaSqlChanged(const SchemaEntry *pA, const SchemaEntry *pB){
-  const char *zA;
-  const char *zB;
-  if( !pA || !pB ) return 1;
-  zA = pA->zSql ? pA->zSql : "";
-  zB = pB->zSql ? pB->zSql : "";
-  return strcmp(zA, zB)!=0;
-}
-
 static int statusMaybeAddParentSchemaChange(
   DoltliteStatusCursor *pCur,
   const char *zParent,
@@ -396,7 +387,7 @@ static int statusCompareIndexSchemaObjects(
   SchemaEntry *aTo = 0;
   int nFrom = 0;
   int nTo = 0;
-  int i;
+  int i, j;
   int rc;
 
   if( !cs || !pCache ) return SQLITE_OK;
@@ -405,30 +396,28 @@ static int statusCompareIndexSchemaObjects(
   rc = loadSchemaFromCatalog(db, cs, pCache, pToCat, &aTo, &nTo);
   if( rc!=SQLITE_OK ) goto index_schema_done;
 
-  for(i=0; i<nTo; i++){
-    SchemaEntry *pOld;
-    if( !aTo[i].zType || strcmp(aTo[i].zType, "index")!=0 ) continue;
-    if( !aTo[i].zName || !aTo[i].zTblName ) continue;
-    pOld = findSchemaEntry(aFrom, nFrom, aTo[i].zName);
-    if( !pOld
-     || !pOld->zType
-     || strcmp(pOld->zType, "index")!=0
-     || !pOld->zTblName
-     || strcmp(pOld->zTblName, aTo[i].zTblName)!=0
-     || statusSchemaSqlChanged(pOld, &aTo[i]) ){
-      rc = statusMaybeAddParentSchemaChange(pCur, aTo[i].zTblName,
-                                            staged, zFilter);
-      if( rc!=SQLITE_OK ) goto index_schema_done;
+  /* One comparison per distinct parent table across both row sets; the
+  ** shared comparator decides whether that table's index set changed. */
+  for(i=0; i<nFrom+nTo; i++){
+    SchemaEntry *pRow = i<nFrom ? &aFrom[i] : &aTo[i-nFrom];
+    int seen = 0;
+    if( !pRow->zType || strcmp(pRow->zType, "index")!=0
+     || !pRow->zTblName ){
+      continue;
     }
-  }
-
-  for(i=0; i<nFrom; i++){
-    SchemaEntry *pNew;
-    if( !aFrom[i].zType || strcmp(aFrom[i].zType, "index")!=0 ) continue;
-    if( !aFrom[i].zName || !aFrom[i].zTblName ) continue;
-    pNew = findSchemaEntry(aTo, nTo, aFrom[i].zName);
-    if( !pNew || !pNew->zType || strcmp(pNew->zType, "index")!=0 ){
-      rc = statusMaybeAddParentSchemaChange(pCur, aFrom[i].zTblName,
+    for(j=0; j<i; j++){
+      SchemaEntry *pPrev = j<nFrom ? &aFrom[j] : &aTo[j-nFrom];
+      if( pPrev->zType && strcmp(pPrev->zType, "index")==0
+       && pPrev->zTblName
+       && strcmp(pPrev->zTblName, pRow->zTblName)==0 ){
+        seen = 1;
+        break;
+      }
+    }
+    if( seen ) continue;
+    if( doltliteIndexSchemaRowsDifferForTable(aFrom, nFrom, aTo, nTo,
+                                              pRow->zTblName) ){
+      rc = statusMaybeAddParentSchemaChange(pCur, pRow->zTblName,
                                             staged, zFilter);
       if( rc!=SQLITE_OK ) goto index_schema_done;
     }
diff --git a/src/prolly_btree.c b/src/prolly_btree.c
diff --git a/test/doltlite_commit.sh b/test/doltlite_commit.sh
