From e14ec93553fb0801220f4746afa5649a6f149939 Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Tue, 12 Aug 2025 00:50:24 -0700
Subject: [PATCH 01/11] feat(sql): make dolt_diff_summary respect dolt_ignore
 patterns

Add ignore pattern filtering to dolt_diff_summary table function to
match dolt diff command behavior. Tables matching patterns in
dolt_ignore are now filtered out from diff summary results.

Changes include:
- Add getIgnorePatternsFromContext() to retrieve ignore patterns from
dolt_ignore
- Add shouldIgnoreDelta() to check if table deltas should be ignored
- Add shouldFilterSystemTable() to filter out system tables (dolt_*
prefix)
- Apply filtering to both general queries and specific table queries
- Only ignore added/dropped tables, not modified/renamed tables

Tests added:
- 5 integration tests in dolt_queries_diff.go
- 4 bats tests in ignore.bats covering basic patterns, wildcards,
dropped tables, and specific table queries

Refs: #5861
---
 .../sqle/dtablefunctions/dolt_diff_summary.go |  93 ++++++++++++++++
 .../sqle/enginetest/dolt_queries_diff.go      | 104 ++++++++++++++++++
 integration-tests/bats/ignore.bats            |  91 +++++++++++++++
 3 files changed, 288 insertions(+)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 1991082545f..92662699398 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -25,6 +25,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/types"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/diff"
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dtables"
@@ -287,10 +288,24 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
 		return deltas[i].ToName.Less(deltas[j].ToName)
 	})
 
+	ignorePatterns, err := getIgnorePatternsFromContext(ctx, ds.database)
+	if err != nil {
+		return nil, err
+	}
+
 	// If tableNameExpr defined, return a single table diff summary result
 	if ds.tableNameExpr != nil {
 		delta := findMatchingDelta(deltas, tableName)
 
+		if shouldIgnoreDelta(delta, ignorePatterns) {
+			return NewDiffSummaryTableFunctionRowIter([]*diff.TableDeltaSummary{}), nil
+		}
+
+		// Check if the specific table is a system table
+		if shouldFilterSystemTable(delta) {
+			return NewDiffSummaryTableFunctionRowIter([]*diff.TableDeltaSummary{}), nil
+		}
+
 		summ, err := getSummaryForDelta(ctx, delta, sqledb, fromDetails, toDetails, true)
 		if err != nil {
 			return nil, err
@@ -306,6 +321,15 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
 
 	var diffSummaries []*diff.TableDeltaSummary
 	for _, delta := range deltas {
+		if shouldIgnoreDelta(delta, ignorePatterns) {
+			continue
+		}
+
+		// Filter out system tables (tables starting with "dolt_")
+		if shouldFilterSystemTable(delta) {
+			continue
+		}
+
 		summ, err := getSummaryForDelta(ctx, delta, sqledb, fromDetails, toDetails, false)
 		if err != nil {
 			return nil, err
@@ -438,3 +462,72 @@ func getRowFromSummary(ds *diff.TableDeltaSummary) sql.Row {
 		ds.SchemaChange,           // schema_change
 	}
 }
+
+// getIgnorePatternsFromContext retrieves ignore patterns from the dolt_ignore table.
+// This uses the same approach as the doltdb package's GetIgnoredTablePatterns function
+// but adapted to work within the table function context.
+func getIgnorePatternsFromContext(ctx *sql.Context, database sql.Database) (doltdb.IgnorePatterns, error) {
+	_, ok := database.(dsess.SqlDatabase)
+	if !ok {
+		return nil, fmt.Errorf("unexpected database type: %T", database)
+	}
+
+	sess := dsess.DSessFromSess(ctx.Session)
+	dbName := database.Name()
+
+	// Get the current working set root
+	workingRoot, _, _, err := sess.ResolveRootForRef(ctx, dbName, doltdb.Working)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create roots object for ignore pattern lookup
+	roots := doltdb.Roots{Working: workingRoot}
+	schemas := []string{""} // Default schema
+
+	ignorePatternMap, err := doltdb.GetIgnoredTablePatterns(ctx, roots, schemas)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return patterns for default schema
+	return ignorePatternMap[""], nil
+}
+
+// shouldIgnoreDelta determines if a table delta should be ignored based on dolt_ignore patterns.
+// This follows the same logic as the dolt diff command: only "added" or "dropped" tables
+// can be ignored, not modified/renamed tables.
+func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatterns) bool {
+	// Handle "added" tables (FromName is empty)
+	if delta.FromName.Name == "" {
+		ignoreResult, err := ignorePatterns.IsTableNameIgnored(delta.ToName)
+		if err != nil {
+			return false // On error, don't ignore
+		}
+		return ignoreResult == doltdb.Ignore
+	}
+
+	// Handle "dropped" tables (ToName is empty)
+	if delta.ToName.Name == "" {
+		ignoreResult, err := ignorePatterns.IsTableNameIgnored(delta.FromName)
+		if err != nil {
+			return false // On error, don't ignore
+		}
+		return ignoreResult == doltdb.Ignore
+	}
+
+	// For modified/renamed tables, don't ignore (consistent with dolt diff behavior)
+	return false
+}
+
+// shouldFilterSystemTable determines if a table delta should be filtered out because it's a system table.
+func shouldFilterSystemTable(delta diff.TableDelta) bool {
+	// Check if either the from or to table name starts with "dolt_"
+	if delta.FromName.Name != "" && strings.HasPrefix(delta.FromName.Name, "dolt_") {
+		return true
+	}
+	if delta.ToName.Name != "" && strings.HasPrefix(delta.ToName.Name, "dolt_") {
+		return true
+	}
+	return false
+}
diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
index e7ffd501b29..f41b6813f33 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
@@ -6762,4 +6762,108 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 			},
 		},
 	},
+	{
+		Name: "dolt_diff_summary respects dolt_ignore: basic ignore functionality",
+		SetUpScript: []string{
+			"CREATE TABLE ignored_table (pk int primary key, c1 int);",
+			"CREATE TABLE not_ignored_table (pk int primary key, c1 int);",
+			"CALL DOLT_ADD('.')",
+			"CALL DOLT_COMMIT('-m', 'add tables');",
+			"INSERT INTO dolt_ignore VALUES ('ignored_table', true);",
+			"CREATE TABLE ignored_table2 (pk int primary key, c2 int);",
+			"CREATE TABLE not_ignored_table2 (pk int primary key, c2 int);",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{1}}, // only not_ignored_table2 should appear
+			},
+			{
+				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{"not_ignored_table2"}},
+			},
+		},
+	},
+	{
+		Name: "dolt_diff_summary respects dolt_ignore: wildcard patterns",
+		SetUpScript: []string{
+			"CALL DOLT_COMMIT('-m', 'initial');",
+			"INSERT INTO dolt_ignore VALUES ('temp_*', true);",
+			"CREATE TABLE temp_table1 (pk int primary key);",
+			"CREATE TABLE temp_table2 (pk int primary key);",
+			"CREATE TABLE regular_table (pk int primary key);",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{1}}, // only regular_table should appear
+			},
+			{
+				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{"regular_table"}},
+			},
+		},
+	},
+	{
+		Name: "dolt_diff_summary respects dolt_ignore: mixed ignore/don't ignore patterns",
+		SetUpScript: []string{
+			"CALL DOLT_COMMIT('-m', 'initial');",
+			"INSERT INTO dolt_ignore VALUES ('temp_*', true);",
+			"INSERT INTO dolt_ignore VALUES ('temp_important', false);", // don't ignore this one
+			"CREATE TABLE temp_table1 (pk int primary key);",
+			"CREATE TABLE temp_important (pk int primary key);",
+			"CREATE TABLE regular_table (pk int primary key);",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{2}}, // temp_important and regular_table should appear
+			},
+			{
+				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING') ORDER BY to_table_name;",
+				Expected: []sql.Row{{"regular_table"}, {"temp_important"}},
+			},
+		},
+	},
+	{
+		Name: "dolt_diff_summary respects dolt_ignore: specific table query",
+		SetUpScript: []string{
+			"CALL DOLT_COMMIT('-m', 'initial');",
+			"INSERT INTO dolt_ignore VALUES ('ignored_table', true);",
+			"CREATE TABLE ignored_table (pk int primary key);",
+			"CREATE TABLE not_ignored_table (pk int primary key);",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING', 'ignored_table');",
+				Expected: []sql.Row{{0}}, // specific query for ignored table returns empty
+			},
+			{
+				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING', 'not_ignored_table');",
+				Expected: []sql.Row{{1}}, // specific query for non-ignored table works
+			},
+		},
+	},
+	{
+		Name: "dolt_diff_summary respects dolt_ignore: dropped tables",
+		SetUpScript: []string{
+			"CREATE TABLE will_be_ignored (pk int primary key);",
+			"CREATE TABLE will_not_be_ignored (pk int primary key);",
+			"CALL DOLT_ADD('.')",
+			"CALL DOLT_COMMIT('-m', 'add tables');",
+			"INSERT INTO dolt_ignore VALUES ('will_be_ignored', true);",
+			"DROP TABLE will_be_ignored;",
+			"DROP TABLE will_not_be_ignored;",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{1}}, // only will_not_be_ignored should appear as dropped
+			},
+			{
+				Query:    "SELECT from_table_name, diff_type FROM dolt_diff_summary('HEAD', 'WORKING');",
+				Expected: []sql.Row{{"will_not_be_ignored", "dropped"}},
+			},
+		},
+	},
 }
diff --git a/integration-tests/bats/ignore.bats b/integration-tests/bats/ignore.bats
index 3c0f9d7e5b4..b16958f3217 100644
--- a/integration-tests/bats/ignore.bats
+++ b/integration-tests/bats/ignore.bats
@@ -444,4 +444,95 @@ SQL
     [[ ! "$output" =~ "test2" ]] || false
     [[ ! "$output" =~ "test3" ]] || false
 
+}
+
+@test "ignore: dolt_diff_summary respects dolt_ignore patterns" {
+    # First commit some initial tables
+    dolt sql -q "CREATE TABLE initial_table (pk int primary key)"
+    dolt add .
+    dolt commit -m "Add initial table"
+
+    # Add ignore pattern and create new tables
+    dolt sql -q "INSERT INTO dolt_ignore VALUES ('should_ignore_new', true)"
+    dolt sql -q "CREATE TABLE should_ignore_new (pk int primary key)"
+    dolt sql -q "CREATE TABLE should_not_ignore_new (pk int primary key)"
+
+    # Test that dolt_diff_summary respects ignore patterns - should only show non-ignored tables
+    run dolt sql -q "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "1" ]] || false
+
+    # Verify which table is shown
+    run dolt sql -q "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "should_not_ignore_new" ]] || false
+    [[ ! "$output" =~ "should_ignore_new" ]] || false
+}
+
+@test "ignore: dolt_diff_summary respects wildcard ignore patterns" {
+    # First commit initial table
+    dolt sql -q "CREATE TABLE initial (pk int primary key)"
+    dolt add .
+    dolt commit -m "Add initial table"
+
+    # Add wildcard ignore pattern and create new tables
+    dolt sql -q "INSERT INTO dolt_ignore VALUES ('temp_*', true)"
+    dolt sql -q "CREATE TABLE temp_new_table (pk int primary key)"
+    dolt sql -q "CREATE TABLE regular_new_table (pk int primary key)"
+
+    # Should only show the regular table
+    run dolt sql -q "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "1" ]] || false
+
+    run dolt sql -q "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "regular_new_table" ]] || false
+    [[ ! "$output" =~ "temp_new_table" ]] || false
+}
+
+@test "ignore: dolt_diff_summary respects ignore patterns for dropped tables" {
+    # Create and commit tables that will be dropped
+    dolt sql -q "CREATE TABLE will_be_ignored (pk int primary key)"
+    dolt sql -q "CREATE TABLE will_not_be_ignored (pk int primary key)"
+    dolt add .
+    dolt commit -m "Add tables to be dropped"
+
+    # Add ignore pattern and drop tables
+    dolt sql -q "INSERT INTO dolt_ignore VALUES ('will_be_ignored', true)"
+    dolt sql -q "DROP TABLE will_be_ignored"
+    dolt sql -q "DROP TABLE will_not_be_ignored"
+
+    # Should only show the non-ignored dropped table
+    run dolt sql -q "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "1" ]] || false
+
+    run dolt sql -q "SELECT from_table_name, diff_type FROM dolt_diff_summary('HEAD', 'WORKING')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "will_not_be_ignored" ]] || false
+    [[ "$output" =~ "dropped" ]] || false
+    [[ ! "$output" =~ "will_be_ignored" ]] || false
+}
+
+@test "ignore: dolt_diff_summary specific table query respects ignore patterns" {
+    # Create and commit initial table
+    dolt sql -q "CREATE TABLE initial_table (pk int primary key)"
+    dolt add .
+    dolt commit -m "Add initial table"
+
+    # Add ignore pattern and create new tables
+    dolt sql -q "INSERT INTO dolt_ignore VALUES ('ignored_table_new', true)"
+    dolt sql -q "CREATE TABLE ignored_table_new (pk int primary key)"
+    dolt sql -q "CREATE TABLE not_ignored_table (pk int primary key)"
+
+    # Specific query for ignored table should return empty
+    run dolt sql -q "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING', 'ignored_table_new')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "0" ]] || false
+
+    # Specific query for non-ignored table should work
+    run dolt sql -q "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING', 'not_ignored_table')" -r csv
+    [ "$status" -eq 0 ]
+    [[ "$output" =~ "1" ]] || false
 }
\ No newline at end of file

From 93d8cf3683652db33fd1c019875abf33ac39156b Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Fri, 15 Aug 2025 02:38:17 -0700
Subject: [PATCH 02/11] fix(tests): resolve dolt_diff_summary ignore pattern
 test failures

Fix test setup issues that were causing failures in integration tests:
- Correct ignore pattern from 'ignored_table' to 'ignored_table2'
- Add initial table creation before commit in three test cases
- Remove "nothing to commit" errors by establishing proper baseline

All dolt_diff_summary ignore functionality tests now pass.

Refs: #5861
---
 .../doltcore/sqle/dtablefunctions/dolt_diff_summary.go    | 2 --
 .../doltcore/sqle/enginetest/dolt_queries_diff.go         | 8 +++++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 92662699398..5de85da0cdc 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -464,8 +464,6 @@ func getRowFromSummary(ds *diff.TableDeltaSummary) sql.Row {
 }
 
 // getIgnorePatternsFromContext retrieves ignore patterns from the dolt_ignore table.
-// This uses the same approach as the doltdb package's GetIgnoredTablePatterns function
-// but adapted to work within the table function context.
 func getIgnorePatternsFromContext(ctx *sql.Context, database sql.Database) (doltdb.IgnorePatterns, error) {
 	_, ok := database.(dsess.SqlDatabase)
 	if !ok {
diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
index f41b6813f33..ae05f6f3ecf 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
@@ -6769,7 +6769,7 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 			"CREATE TABLE not_ignored_table (pk int primary key, c1 int);",
 			"CALL DOLT_ADD('.')",
 			"CALL DOLT_COMMIT('-m', 'add tables');",
-			"INSERT INTO dolt_ignore VALUES ('ignored_table', true);",
+			"INSERT INTO dolt_ignore VALUES ('ignored_table2', true);",
 			"CREATE TABLE ignored_table2 (pk int primary key, c2 int);",
 			"CREATE TABLE not_ignored_table2 (pk int primary key, c2 int);",
 		},
@@ -6787,6 +6787,8 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 	{
 		Name: "dolt_diff_summary respects dolt_ignore: wildcard patterns",
 		SetUpScript: []string{
+			"CREATE TABLE initial_table (pk int primary key);",
+			"CALL DOLT_ADD('.');",
 			"CALL DOLT_COMMIT('-m', 'initial');",
 			"INSERT INTO dolt_ignore VALUES ('temp_*', true);",
 			"CREATE TABLE temp_table1 (pk int primary key);",
@@ -6807,6 +6809,8 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 	{
 		Name: "dolt_diff_summary respects dolt_ignore: mixed ignore/don't ignore patterns",
 		SetUpScript: []string{
+			"CREATE TABLE initial_table (pk int primary key);",
+			"CALL DOLT_ADD('.');",
 			"CALL DOLT_COMMIT('-m', 'initial');",
 			"INSERT INTO dolt_ignore VALUES ('temp_*', true);",
 			"INSERT INTO dolt_ignore VALUES ('temp_important', false);", // don't ignore this one
@@ -6828,6 +6832,8 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 	{
 		Name: "dolt_diff_summary respects dolt_ignore: specific table query",
 		SetUpScript: []string{
+			"CREATE TABLE initial_table (pk int primary key);",
+			"CALL DOLT_ADD('.');",
 			"CALL DOLT_COMMIT('-m', 'initial');",
 			"INSERT INTO dolt_ignore VALUES ('ignored_table', true);",
 			"CREATE TABLE ignored_table (pk int primary key);",

From ae65e41244b2861134a25039862c2f0de7eff31c Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Tue, 19 Aug 2025 00:57:56 -0700
Subject: [PATCH 03/11] refactor(diff): filter only dolt_ignore table in diff
 summary

Changed from filtering all dolt_* system tables to only filtering
the dolt_ignore table itself in dolt_diff_summary. This maintains
ignore pattern functionality while being more conservative about
which system tables are filtered, fixing bats test failures.

Refs: #5861
---
 .../sqle/dtablefunctions/dolt_diff_summary.go | 21 +++++++------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 5de85da0cdc..6e7a6296892 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -301,8 +301,8 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
 			return NewDiffSummaryTableFunctionRowIter([]*diff.TableDeltaSummary{}), nil
 		}
 
-		// Check if the specific table is a system table
-		if shouldFilterSystemTable(delta) {
+		// Filter out dolt_ignore table itself to match dolt diff behavior
+		if shouldFilterDoltIgnoreTable(delta) {
 			return NewDiffSummaryTableFunctionRowIter([]*diff.TableDeltaSummary{}), nil
 		}
 
@@ -325,8 +325,8 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
 			continue
 		}
 
-		// Filter out system tables (tables starting with "dolt_")
-		if shouldFilterSystemTable(delta) {
+		// Filter out dolt_ignore table itself to match dolt diff behavior
+		if shouldFilterDoltIgnoreTable(delta) {
 			continue
 		}
 
@@ -518,14 +518,7 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 	return false
 }
 
-// shouldFilterSystemTable determines if a table delta should be filtered out because it's a system table.
-func shouldFilterSystemTable(delta diff.TableDelta) bool {
-	// Check if either the from or to table name starts with "dolt_"
-	if delta.FromName.Name != "" && strings.HasPrefix(delta.FromName.Name, "dolt_") {
-		return true
-	}
-	if delta.ToName.Name != "" && strings.HasPrefix(delta.ToName.Name, "dolt_") {
-		return true
-	}
-	return false
+// shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
+func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
+	return delta.FromName.Name == "dolt_ignore" || delta.ToName.Name == "dolt_ignore"
 }

From 7ab1d4464371528dc8c34cde4d8bb45b5cf146fd Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Tue, 2 Sep 2025 12:36:33 -0700
Subject: [PATCH 04/11] PR Suggestions

---
 .../sqle/dtablefunctions/dolt_diff_summary.go | 27 +++++--------------
 1 file changed, 7 insertions(+), 20 deletions(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 6e7a6296892..5d8983714f6 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -465,25 +465,14 @@ func getRowFromSummary(ds *diff.TableDeltaSummary) sql.Row {
 
 // getIgnorePatternsFromContext retrieves ignore patterns from the dolt_ignore table.
 func getIgnorePatternsFromContext(ctx *sql.Context, database sql.Database) (doltdb.IgnorePatterns, error) {
-	_, ok := database.(dsess.SqlDatabase)
-	if !ok {
-		return nil, fmt.Errorf("unexpected database type: %T", database)
-	}
-
 	sess := dsess.DSessFromSess(ctx.Session)
 	dbName := database.Name()
-
-	// Get the current working set root
-	workingRoot, _, _, err := sess.ResolveRootForRef(ctx, dbName, doltdb.Working)
-	if err != nil {
-		return nil, err
+	roots, ok := sess.GetRoots(ctx, dbName)
+	if !ok {
+		return nil, fmt.Errorf("Could not load database %s", dbName)
 	}
 
-	// Create roots object for ignore pattern lookup
-	roots := doltdb.Roots{Working: workingRoot}
-	schemas := []string{""} // Default schema
-
-	ignorePatternMap, err := doltdb.GetIgnoredTablePatterns(ctx, roots, schemas)
+	ignorePatternMap, err := doltdb.GetIgnoredTablePatterns(ctx, roots, []string{""})
 	if err != nil {
 		return nil, err
 	}
@@ -496,8 +485,7 @@ func getIgnorePatternsFromContext(ctx *sql.Context, database sql.Database) (dolt
 // This follows the same logic as the dolt diff command: only "added" or "dropped" tables
 // can be ignored, not modified/renamed tables.
 func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatterns) bool {
-	// Handle "added" tables (FromName is empty)
-	if delta.FromName.Name == "" {
+	if delta.IsAdd() {
 		ignoreResult, err := ignorePatterns.IsTableNameIgnored(delta.ToName)
 		if err != nil {
 			return false // On error, don't ignore
@@ -505,8 +493,7 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 		return ignoreResult == doltdb.Ignore
 	}
 
-	// Handle "dropped" tables (ToName is empty)
-	if delta.ToName.Name == "" {
+	if delta.IsDrop() {
 		ignoreResult, err := ignorePatterns.IsTableNameIgnored(delta.FromName)
 		if err != nil {
 			return false // On error, don't ignore
@@ -520,5 +507,5 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 
 // shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
 func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
-	return delta.FromName.Name == "dolt_ignore" || delta.ToName.Name == "dolt_ignore"
+	return delta.FromName.Name == doltdb.IgnoreTableName || delta.ToName.Name == doltdb.IgnoreTableName
 }

From e8fbfd9c6282770b3a05247b3907a7459d20a26e Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Sun, 19 Oct 2025 00:49:42 -0700
Subject: [PATCH 05/11] fix(diff): use case-insensitive comparison for
 dolt_ignore filter

Update shouldFilterDoltIgnoreTable to use strings.EqualFold instead
of case-sensitive equality comparison when filtering dolt_ignore
tables from diff summary results.

In DoltgreSQL (PostgreSQL mode), table names may have different case
representations internally. The case-sensitive comparison (==) was
failing to properly filter out dolt_ignore tables, causing them to
appear in dolt_diff_summary results when they should be excluded.

Using strings.EqualFold ensures the filter works consistently
regardless of case variations, matching the behavior of other table
name comparisons in the codebase (e.g., findMatchingDelta).

This fixes DoltgreSQL integration test failures in
TestUserSpaceDoltTables/dolt_ignore test cases.

Refs: #5861
---
 go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 5d8983714f6..3de9b6a3b54 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -507,5 +507,5 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 
 // shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
 func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
-	return delta.FromName.Name == doltdb.IgnoreTableName || delta.ToName.Name == doltdb.IgnoreTableName
+	return strings.EqualFold(delta.FromName.Name, doltdb.IgnoreTableName) || strings.EqualFold(delta.ToName.Name, doltdb.IgnoreTableName)
 }

From 0da111a8805f819d24703f58fb95b04c57758463 Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Tue, 21 Oct 2025 00:16:27 -0700
Subject: [PATCH 06/11] fix(diff): handle schema-qualified table names in
 dolt_ignore filter

Update dolt_diff_summary to properly filter dolt_ignore table in
DoltgreSQL by handling schema-qualified table names (e.g.,
"public.dolt_ignore"). The previous implementation only checked
for exact matches against "dolt_ignore", which failed when table
names included schema prefixes.

Changes:
- Add isIgnoreTable helper function to check both simple and
  qualified table names
- Extract base table name from schema-qualified names using
  LastIndex for dot separator
- Maintain backward compatibility with unqualified names

This should fix the DoltgreSQL integration test failures where
dolt_ignore tables were incorrectly appearing in diff summaries.

Refs: #5861
---
 .../sqle/dtablefunctions/dolt_diff_summary.go | 20 ++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 3de9b6a3b54..458c08a60dd 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -507,5 +507,23 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 
 // shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
 func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
-	return strings.EqualFold(delta.FromName.Name, doltdb.IgnoreTableName) || strings.EqualFold(delta.ToName.Name, doltdb.IgnoreTableName)
+	return isIgnoreTable(delta.FromName) || isIgnoreTable(delta.ToName)
+}
+
+// isIgnoreTable checks if a TableName refers to the dolt_ignore table,
+// handling both simple names and schema-qualified names (e.g., "public.dolt_ignore" in DoltgreSQL).
+func isIgnoreTable(tableName doltdb.TableName) bool {
+	// Check unqualified name
+	if strings.EqualFold(tableName.Name, doltdb.IgnoreTableName) {
+		return true
+	}
+
+	// Check if Name contains a schema-qualified reference (e.g., "public.dolt_ignore")
+	// Extract the base table name by splitting on the last dot
+	if idx := strings.LastIndex(tableName.Name, "."); idx != -1 {
+		baseTableName := tableName.Name[idx+1:]
+		return strings.EqualFold(baseTableName, doltdb.IgnoreTableName)
+	}
+
+	return false
 }

From bdc3341f61e8f16b51b15d52b7022c951bad6a10 Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Tue, 21 Oct 2025 22:45:17 -0700
Subject: [PATCH 07/11] test: add some log calls to diagnose doltgresql
 integration test fails

Refs: #5861
---
 .../sqle/dtablefunctions/dolt_diff_summary.go | 25 +++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 458c08a60dd..96a903ac38a 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -17,6 +17,7 @@ package dtablefunctions
 import (
 	"fmt"
 	"io"
+	"log"
 	"sort"
 	"strings"
 
@@ -507,14 +508,30 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 
 // shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
 func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
-	return isIgnoreTable(delta.FromName) || isIgnoreTable(delta.ToName)
+	fromMatch := isIgnoreTable(delta.FromName)
+	toMatch := isIgnoreTable(delta.ToName)
+
+	// DEBUG: Temporary logging to diagnose DoltgreSQL test failure
+	if fromMatch || toMatch {
+		log.Printf("[DEBUG] shouldFilterDoltIgnoreTable: FromName(Name='%s', Schema='%s', Match=%v), ToName(Name='%s', Schema='%s', Match=%v)\n",
+			delta.FromName.Name, delta.FromName.Schema, fromMatch,
+			delta.ToName.Name, delta.ToName.Schema, toMatch)
+	}
+
+	return fromMatch || toMatch
 }
 
 // isIgnoreTable checks if a TableName refers to the dolt_ignore table,
 // handling both simple names and schema-qualified names (e.g., "public.dolt_ignore" in DoltgreSQL).
 func isIgnoreTable(tableName doltdb.TableName) bool {
+	// DEBUG: investigating DoltgreSQL dolt_ignore filter issue
+	log.Printf("[DEBUG] isIgnoreTable called: Name='%s', Schema='%s', IgnoreTableName='%s'\n",
+		tableName.Name, tableName.Schema, doltdb.IgnoreTableName)
+
 	// Check unqualified name
 	if strings.EqualFold(tableName.Name, doltdb.IgnoreTableName) {
+		log.Printf("[DEBUG] isIgnoreTable: MATCH on Name='%s' (Schema='%s', Constant='%s')\n",
+			tableName.Name, tableName.Schema, doltdb.IgnoreTableName)
 		return true
 	}
 
@@ -522,7 +539,11 @@ func isIgnoreTable(tableName doltdb.TableName) bool {
 	// Extract the base table name by splitting on the last dot
 	if idx := strings.LastIndex(tableName.Name, "."); idx != -1 {
 		baseTableName := tableName.Name[idx+1:]
-		return strings.EqualFold(baseTableName, doltdb.IgnoreTableName)
+		if strings.EqualFold(baseTableName, doltdb.IgnoreTableName) {
+			log.Printf("[DEBUG] isIgnoreTable: MATCH on qualified Name='%s' extracted='%s' (Schema='%s', Constant='%s')\n",
+				tableName.Name, baseTableName, tableName.Schema, doltdb.IgnoreTableName)
+			return true
+		}
 	}
 
 	return false

From 987fae6a81f5bc53682886193a41117adb31bbd7 Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Wed, 22 Oct 2025 00:11:38 -0700
Subject: [PATCH 08/11] fix(diff): allow explicit queries of dolt_ignore in
 dolt_diff_summary

Remove dolt_ignore auto-filter when user explicitly requests the
table by name. Previously, querying dolt_diff_summary with
dolt_ignore as the table parameter would incorrectly return empty
results even though the table was explicitly requested.

The dolt_ignore table is still auto-filtered from general listings
(when no table name is provided), but can now be queried directly
when specified by name, matching expected behavior where users can
query any table explicitly.

This fixes DoltgreSQL integration test failures where explicit
dolt_ignore queries were being blocked, something I missed in my
implementation originally.

Refs: #5861
---
 .../sqle/dtablefunctions/dolt_diff_summary.go | 46 +------------------
 1 file changed, 1 insertion(+), 45 deletions(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index 96a903ac38a..b549fbd4de2 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -17,7 +17,6 @@ package dtablefunctions
 import (
 	"fmt"
 	"io"
-	"log"
 	"sort"
 	"strings"
 
@@ -302,11 +301,6 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
 			return NewDiffSummaryTableFunctionRowIter([]*diff.TableDeltaSummary{}), nil
 		}
 
-		// Filter out dolt_ignore table itself to match dolt diff behavior
-		if shouldFilterDoltIgnoreTable(delta) {
-			return NewDiffSummaryTableFunctionRowIter([]*diff.TableDeltaSummary{}), nil
-		}
-
 		summ, err := getSummaryForDelta(ctx, delta, sqledb, fromDetails, toDetails, true)
 		if err != nil {
 			return nil, err
@@ -508,43 +502,5 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 
 // shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
 func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
-	fromMatch := isIgnoreTable(delta.FromName)
-	toMatch := isIgnoreTable(delta.ToName)
-
-	// DEBUG: Temporary logging to diagnose DoltgreSQL test failure
-	if fromMatch || toMatch {
-		log.Printf("[DEBUG] shouldFilterDoltIgnoreTable: FromName(Name='%s', Schema='%s', Match=%v), ToName(Name='%s', Schema='%s', Match=%v)\n",
-			delta.FromName.Name, delta.FromName.Schema, fromMatch,
-			delta.ToName.Name, delta.ToName.Schema, toMatch)
-	}
-
-	return fromMatch || toMatch
-}
-
-// isIgnoreTable checks if a TableName refers to the dolt_ignore table,
-// handling both simple names and schema-qualified names (e.g., "public.dolt_ignore" in DoltgreSQL).
-func isIgnoreTable(tableName doltdb.TableName) bool {
-	// DEBUG: investigating DoltgreSQL dolt_ignore filter issue
-	log.Printf("[DEBUG] isIgnoreTable called: Name='%s', Schema='%s', IgnoreTableName='%s'\n",
-		tableName.Name, tableName.Schema, doltdb.IgnoreTableName)
-
-	// Check unqualified name
-	if strings.EqualFold(tableName.Name, doltdb.IgnoreTableName) {
-		log.Printf("[DEBUG] isIgnoreTable: MATCH on Name='%s' (Schema='%s', Constant='%s')\n",
-			tableName.Name, tableName.Schema, doltdb.IgnoreTableName)
-		return true
-	}
-
-	// Check if Name contains a schema-qualified reference (e.g., "public.dolt_ignore")
-	// Extract the base table name by splitting on the last dot
-	if idx := strings.LastIndex(tableName.Name, "."); idx != -1 {
-		baseTableName := tableName.Name[idx+1:]
-		if strings.EqualFold(baseTableName, doltdb.IgnoreTableName) {
-			log.Printf("[DEBUG] isIgnoreTable: MATCH on qualified Name='%s' extracted='%s' (Schema='%s', Constant='%s')\n",
-				tableName.Name, baseTableName, tableName.Schema, doltdb.IgnoreTableName)
-			return true
-		}
-	}
-
-	return false
+	return strings.EqualFold(delta.FromName.Name, doltdb.IgnoreTableName) || strings.EqualFold(delta.ToName.Name, doltdb.IgnoreTableName)
 }

From 2ab39d8f10729f28a07833d1e63e56e29508318c Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Wed, 22 Oct 2025 19:30:09 -0700
Subject: [PATCH 09/11] fix(diff): remove filtering of dolt_ignore table in
 dolt_diff_summary

Remove the shouldFilterDoltIgnoreTable function and its usage, which was
filtering out the dolt_ignore table itself from diff results in
dolt_diff_summary.

From my understanding of code, dolt_ignore table should appear in
diff summaries just like any other table. Only tables that match
patterns defined IN the dolt_ignore table should be filtered from
results, which is correctly handled by the shouldIgnoreDelta function.

This is an attempts to fix the DoltgreSQL integration test failure in
TestUserSpaceDoltTables/dolt_ignore which expects dolt_ignore table
changes to be visible in diff_summary results.

Refs: #5861
---
 .../doltcore/sqle/dtablefunctions/dolt_diff_summary.go | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
index b549fbd4de2..060e1e9153e 100644
--- a/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
+++ b/go/libraries/doltcore/sqle/dtablefunctions/dolt_diff_summary.go
@@ -320,11 +320,6 @@ func (ds *DiffSummaryTableFunction) RowIter(ctx *sql.Context, row sql.Row) (sql.
 			continue
 		}
 
-		// Filter out dolt_ignore table itself to match dolt diff behavior
-		if shouldFilterDoltIgnoreTable(delta) {
-			continue
-		}
-
 		summ, err := getSummaryForDelta(ctx, delta, sqledb, fromDetails, toDetails, false)
 		if err != nil {
 			return nil, err
@@ -499,8 +494,3 @@ func shouldIgnoreDelta(delta diff.TableDelta, ignorePatterns doltdb.IgnorePatter
 	// For modified/renamed tables, don't ignore (consistent with dolt diff behavior)
 	return false
 }
-
-// shouldFilterDoltIgnoreTable filters out the dolt_ignore table itself to match dolt diff behavior.
-func shouldFilterDoltIgnoreTable(delta diff.TableDelta) bool {
-	return strings.EqualFold(delta.FromName.Name, doltdb.IgnoreTableName) || strings.EqualFold(delta.ToName.Name, doltdb.IgnoreTableName)
-}

From bdd250cc2d1edc79482ae0f2ad51241790a80a5c Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Wed, 22 Oct 2025 21:47:31 -0700
Subject: [PATCH 10/11] test(diff): fix dolt_ignore expectations in
 dolt_diff_summary tests

Update test expectations to correctly reflect that the dolt_ignore
table itself should appear in dolt_diff_summary results when
modified.

Fixed four tests in dolt_queries_diff.go:
- basic ignore functionality: expect dolt_ignore + filtered tables
- wildcard patterns: expect dolt_ignore + non-matching tables
- mixed patterns: expect dolt_ignore + explicitly included tables
- dropped tables: expect dolt_ignore as "modified" when updated

These tests were originally written with incorrect expectations that
dolt_ignore would be filtered from results. The DoltgreSQL
integration tests had the correct expectations all along.

Refs: #5861
---
 .../sqle/enginetest/dolt_queries_diff.go      | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
index ae05f6f3ecf..c8d556888bf 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
@@ -6776,11 +6776,11 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 		Assertions: []queries.ScriptTestAssertion{
 			{
 				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{1}}, // only not_ignored_table2 should appear
+				Expected: []sql.Row{{2}}, // dolt_ignore and not_ignored_table2 should appear
 			},
 			{
-				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{"not_ignored_table2"}},
+				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING') ORDER BY to_table_name;",
+				Expected: []sql.Row{{"dolt_ignore"}, {"not_ignored_table2"}},
 			},
 		},
 	},
@@ -6798,11 +6798,11 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 		Assertions: []queries.ScriptTestAssertion{
 			{
 				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{1}}, // only regular_table should appear
+				Expected: []sql.Row{{2}}, // dolt_ignore and regular_table should appear
 			},
 			{
-				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{"regular_table"}},
+				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING') ORDER BY to_table_name;",
+				Expected: []sql.Row{{"dolt_ignore"}, {"regular_table"}},
 			},
 		},
 	},
@@ -6821,11 +6821,11 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 		Assertions: []queries.ScriptTestAssertion{
 			{
 				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{2}}, // temp_important and regular_table should appear
+				Expected: []sql.Row{{3}}, // dolt_ignore, temp_important and regular_table should appear
 			},
 			{
 				Query:    "SELECT to_table_name FROM dolt_diff_summary('HEAD', 'WORKING') ORDER BY to_table_name;",
-				Expected: []sql.Row{{"regular_table"}, {"temp_important"}},
+				Expected: []sql.Row{{"dolt_ignore"}, {"regular_table"}, {"temp_important"}},
 			},
 		},
 	},
@@ -6864,11 +6864,11 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 		Assertions: []queries.ScriptTestAssertion{
 			{
 				Query:    "SELECT COUNT(*) FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{1}}, // only will_not_be_ignored should appear as dropped
+				Expected: []sql.Row{{2}}, // dolt_ignore (modified) and will_not_be_ignored (dropped)
 			},
 			{
-				Query:    "SELECT from_table_name, diff_type FROM dolt_diff_summary('HEAD', 'WORKING');",
-				Expected: []sql.Row{{"will_not_be_ignored", "dropped"}},
+				Query:    "SELECT from_table_name, diff_type FROM dolt_diff_summary('HEAD', 'WORKING') ORDER BY from_table_name;",
+				Expected: []sql.Row{{"dolt_ignore", "modified"}, {"will_not_be_ignored", "dropped"}},
 			},
 		},
 	},

From afb159b56b7f3e0d1747da2c1bf1c0bb6b50a076 Mon Sep 17 00:00:00 2001
From: David Dansby <39511285+codeaucafe@users.noreply.github.com>
Date: Wed, 22 Oct 2025 22:17:28 -0700
Subject: [PATCH 11/11] test(diff): fix dropped tables test setup for
 dolt_ignore

Fix the "dropped tables" test to ensure dolt_ignore exists in HEAD
before modifying it, so it correctly appears as "modified" instead
of "added" in diff results.

The test now inserts a dummy row into dolt_ignore before the initial
commit, then deletes it and adds the real pattern after. This makes
dolt_ignore show diff_type "modified" rather than "added".

Refs: #5861
---
 go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
index 4cb19e26465..cb1b29b690f 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
@@ -6897,11 +6897,13 @@ var QueryDiffTableScriptTests = []queries.ScriptTest{
 	{
 		Name: "dolt_diff_summary respects dolt_ignore: dropped tables",
 		SetUpScript: []string{
+			"INSERT INTO dolt_ignore VALUES ('dummy', true);", // Create dolt_ignore in initial commit
 			"CREATE TABLE will_be_ignored (pk int primary key);",
 			"CREATE TABLE will_not_be_ignored (pk int primary key);",
 			"CALL DOLT_ADD('.')",
 			"CALL DOLT_COMMIT('-m', 'add tables');",
-			"INSERT INTO dolt_ignore VALUES ('will_be_ignored', true);",
+			"DELETE FROM dolt_ignore WHERE pattern = 'dummy';",          // Remove dummy row
+			"INSERT INTO dolt_ignore VALUES ('will_be_ignored', true);", // Now this modifies dolt_ignore
 			"DROP TABLE will_be_ignored;",
 			"DROP TABLE will_not_be_ignored;",
 		},