enforce foreign keys when reverting through dolt_workspace_TABLE (#11112)

DELETE on a dolt_workspace_* row reverts the pending change to the underlying
table, but the bespoke WriteSession used for that revert bypassed FK
enforcement. Reverting an added parent row could silently orphan children,
and a subsequent dolt_commit would persist the FK violation -- which
dolt_verify_constraints() then missed because its default check is the diff
from HEAD, and the orphans were already in HEAD.

Resolve the underlying table through the session catalog and wrap it in a
plan.ForeignKeyEditor (via the newly exported analyzer.BuildForeignKeyEditor)
so the workspace revert flows through the same FK machinery as ordinary DML:
RESTRICT rejects the revert, CASCADE/SET NULL/SET DEFAULT act on children.

The bespoke WriteSession is dropped from the DELETE path; UPDATE (staged
flag toggle) is unchanged. Adds two regression tests covering RESTRICT and
CASCADE on workspace DELETE of a parent row.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: macneale4

go/go.mod

@@ -64,7 +64,7 @@ require (
 	github.com/dolthub/dolt-mcp v0.3.4
 	github.com/dolthub/eventsapi_schema v0.0.0-20260310172945-37a9265ade69
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
-	github.com/dolthub/go-mysql-server v0.20.1-0.20260527162314-8764587064e4
+	github.com/dolthub/go-mysql-server v0.20.1-0.20260528203524-59a6a564f52a
 	github.com/dolthub/gozstd v0.0.0-20240423170813-23a2903bca63
 	github.com/edsrzf/mmap-go v1.2.0
 	github.com/esote/minmaxheap v1.0.0

go/go.sum

@@ -214,8 +214,8 @@ github.com/dolthub/fslock v0.0.4 h1:p0FcUPu81bO53349qPT1im7XyGu3CwZDsB0PEVdFcaE=
 github.com/dolthub/fslock v0.0.4/go.mod h1:895XJNoMTlL5N1TjOJbd9Pnpjtv1DW/Ddw9qShcAYsM=
 github.com/dolthub/go-icu-regex v0.0.0-20260412212219-49724d547866 h1:U6gSf5I0e6h6GP1/5Sa7D2lWW1CWfcVPtY5wkyHq6jY=
 github.com/dolthub/go-icu-regex v0.0.0-20260412212219-49724d547866/go.mod h1:F3cnm+vMRK1HaU6+rNqQrOCyR03HHhR1GWG2gnPOqaE=
-github.com/dolthub/go-mysql-server v0.20.1-0.20260527162314-8764587064e4 h1:ioyMzpxVr7PDwgwMQxZ0f66+2LUC0cECSSj94pDaFfg=
-github.com/dolthub/go-mysql-server v0.20.1-0.20260527162314-8764587064e4/go.mod h1:482+GNJMKMZ6F0iq1wiAJ0Gg9ha4Y+z3LlBmwZZIanY=
+github.com/dolthub/go-mysql-server v0.20.1-0.20260528203524-59a6a564f52a h1:Mgl9aWp9v2eQYtMPA1hjfcwHgb3mKDHpLgyygi6CwsM=
+github.com/dolthub/go-mysql-server v0.20.1-0.20260528203524-59a6a564f52a/go.mod h1:482+GNJMKMZ6F0iq1wiAJ0Gg9ha4Y+z3LlBmwZZIanY=
 github.com/dolthub/gozstd v0.0.0-20240423170813-23a2903bca63 h1:OAsXLAPL4du6tfbBgK0xXHZkOlos63RdKYS3Sgw/dfI=
 github.com/dolthub/gozstd v0.0.0-20240423170813-23a2903bca63/go.mod h1:lV7lUeuDhH5thVGDCKXbatwKy2KW80L4rMT46n+Y2/Q=
 github.com/dolthub/ishell v0.0.0-20260414231531-5f031e3e9037 h1:oIW9HwuWrhxv+4HZxA+QQSKHLqWFyXZ2FmNjUYwkdiM=

go/libraries/doltcore/sqle/dtables/workspace_table.go

@@ -21,6 +21,8 @@ import (
 	"io"
 
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/analyzer"
+	"github.com/dolthub/go-mysql-server/sql/plan"
 	gmstypes "github.com/dolthub/go-mysql-server/sql/types"
 	"github.com/dolthub/vitess/go/sqltypes"
 
@@ -31,6 +33,7 @@ import (
 	"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/index"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/overrides"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/writer"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table/editor"
@@ -88,6 +91,9 @@ var _ sql.RowUpdater = (*WorkspaceTableUpdater)(nil)
 
 type WorkspaceTableDeleter struct {
 	WorkspaceTableModifier
+	fkEditor      *plan.ForeignKeyEditor
+	fkUpdaters    []sql.ForeignKeyEditor
+	userTblEditor sql.ForeignKeyEditor
 }
 
 var _ sql.RowDeleter = (*WorkspaceTableDeleter)(nil)
@@ -202,15 +208,42 @@ func (wtu *WorkspaceTableUpdater) Close(c *sql.Context) error {
 	return nil
 }
 
+// StatementBegin resolves the underlying table through the session catalog so
+// the revert flows through the same writer ordinary DML uses, then wraps it in
+// a ForeignKeyEditor so FK actions fire on the revert.
 func (wtd *WorkspaceTableDeleter) StatementBegin(ctx *sql.Context) {
-	// Deletes are only allowed on WORKING, do not target staging.
-	sessionWriter, tableWriter, err := wtd.getWorkspaceTableWriter(ctx, false)
+	ds := dsess.DSessFromSess(ctx.Session)
+	catalog := analyzer.NewCatalog(ds.GenericProvider(), overrides.EngineOverridesFromContext(ctx))
+	catalog.AuthHandler = sql.NoopAuthorizationHandler{}
+
+	tbl, _, err := catalog.TableSchema(ctx, ctx.GetCurrentDatabase(), wtd.tableName.Schema, wtd.tableName.Name)
 	if err != nil {
 		wtd.err = &err
 		return
 	}
-	wtd.tableWriter = &tableWriter
-	wtd.sessionWriter = &sessionWriter
+	fkTbl, ok := tbl.(sql.ForeignKeyTable)
+	if !ok {
+		e := fmt.Errorf("workspace target table %s does not support foreign keys", wtd.tableName)
+		wtd.err = &e
+		return
+	}
+
+	fkEditor, updaters, err := analyzer.BuildForeignKeyEditor(ctx, catalog, fkTbl)
+	if err != nil {
+		wtd.err = &err
+		return
+	}
+
+	wtd.fkEditor = fkEditor
+	wtd.fkUpdaters = updaters
+	if fkEditor == nil {
+		wtd.userTblEditor = fkTbl.GetForeignKeyEditor(ctx)
+		wtd.userTblEditor.StatementBegin(ctx)
+		return
+	}
+	for _, u := range updaters {
+		u.StatementBegin(ctx)
+	}
 }
 
 func (wtd *WorkspaceTableDeleter) Delete(c *sql.Context, row sql.Row) error {
@@ -232,7 +265,6 @@ func (wtd *WorkspaceTableDeleter) Delete(c *sql.Context, row sql.Row) error {
 	toRow := row[3 : 3+schemaLen]
 	fromRow := row[3+schemaLen:]
 
-	// If to Row has any non-nil values, then we need to do an update. Otherwise, insert.
 	wasDelete := true
 	for _, val := range toRow {
 		if val != nil {
@@ -248,25 +280,77 @@ func (wtd *WorkspaceTableDeleter) Delete(c *sql.Context, row sql.Row) error {
 		}
 	}
 
-	tableWriter := (*wtd.tableWriter)
-	if tableWriter == nil {
-		return fmt.Errorf("Runtime error: table writer is nil")
+	if wtd.fkEditor != nil {
+		switch {
+		case wasInsert:
+			return wtd.fkEditor.Delete(c, toRow, 0)
+		case wasDelete:
+			for _, ref := range wtd.fkEditor.References {
+				if err := ref.CheckReference(c, fromRow); err != nil {
+					return err
+				}
+			}
+			return wtd.fkEditor.Editor.Insert(c, fromRow)
+		default:
+			return wtd.fkEditor.Update(c, toRow, fromRow, 0)
+		}
 	}
 
+	if wtd.userTblEditor == nil {
+		return fmt.Errorf("Runtime error: table writer is nil")
+	}
 	if wasInsert {
-		return tableWriter.Delete(c, toRow) // delete newly added row.
+		return wtd.userTblEditor.Delete(c, toRow)
 	} else if wasDelete {
-		return tableWriter.Insert(c, fromRow) // restore deleted row.
+		return wtd.userTblEditor.Insert(c, fromRow)
 	} else {
-		return tableWriter.Update(c, toRow, fromRow) // restore updated row.
+		return wtd.userTblEditor.Update(c, toRow, fromRow)
 	}
 }
 
 func (wtd *WorkspaceTableDeleter) Close(c *sql.Context) error {
-	// Resources released in StatementComplete
+	var firstErr error
+	for _, u := range wtd.fkUpdaters {
+		if err := u.Close(c); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	if wtd.userTblEditor != nil {
+		if err := wtd.userTblEditor.Close(c); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}
+
+func (wtd *WorkspaceTableDeleter) DiscardChanges(ctx *sql.Context, errorEncountered error) error {
+	for _, u := range wtd.fkUpdaters {
+		if err := u.DiscardChanges(ctx, errorEncountered); err != nil {
+			return err
+		}
+	}
+	if wtd.userTblEditor != nil {
+		return wtd.userTblEditor.DiscardChanges(ctx, errorEncountered)
+	}
 	return nil
 }
 
+func (wtd *WorkspaceTableDeleter) StatementComplete(ctx *sql.Context) error {
+	if wtd.err != nil {
+		return *wtd.err
+	}
+	for _, u := range wtd.fkUpdaters {
+		if err := u.StatementComplete(ctx); err != nil {
+			return err
+		}
+	}
+	if wtd.userTblEditor != nil {
+		return wtd.userTblEditor.StatementComplete(ctx)
+	}
+	return nil
+}
+
+
 func (wtm *WorkspaceTableModifier) getWorkspaceTableWriter(ctx *sql.Context, targetStaging bool) (dsess.WriteSession, dsess.TableWriter, error) {
 	ds := dsess.DSessFromSess(ctx.Session)
 	var setter dsess.SessionRootSetter
@@ -417,7 +501,7 @@ func (wt *WorkspaceTable) Deleter(ctx *sql.Context) sql.RowDeleter {
 	}
 
 	return &WorkspaceTableDeleter{
-		modifier,
+		WorkspaceTableModifier: modifier,
 	}
 }
 

go/libraries/doltcore/sqle/enginetest/dolt_queries_workspace.go

@@ -1126,4 +1126,52 @@ var DoltWorkspaceScriptTests = []queries.ScriptTest{
 			},
 		},
 	},
+	{
+		// Regression for #11112.
+		Name: "dolt_workspace_* delete restricted by foreign key",
+		SetUpScript: []string{
+			"create table lists (id int primary key, name varchar(100));",
+			"create table list_entries (id int primary key, list_id int not null, content varchar(255), foreign key (list_id) references lists(id));",
+			"call dolt_commit('-Am', 'schema');",
+			"insert into lists values (1, 'list_1');",
+			"insert into list_entries values (1, 1, 'entry_1'), (2, 1, 'entry_2');",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query:       "delete from dolt_workspace_lists where to_id = 1",
+				ExpectedErr: sql.ErrForeignKeyParentViolation,
+			},
+			{
+				Query:    "select id from lists order by id",
+				Expected: []sql.Row{{1}},
+			},
+			{
+				Query:    "select id, list_id from list_entries order by id",
+				Expected: []sql.Row{{1, 1}, {2, 1}},
+			},
+		},
+	},
+	{
+		Name: "dolt_workspace_* delete cascades through foreign key",
+		SetUpScript: []string{
+			"create table lists (id int primary key, name varchar(100));",
+			"create table list_entries (id int primary key, list_id int not null, content varchar(255), foreign key (list_id) references lists(id) on delete cascade);",
+			"call dolt_commit('-Am', 'schema');",
+			"insert into lists values (1, 'list_1');",
+			"insert into list_entries values (1, 1, 'entry_1'), (2, 1, 'entry_2');",
+		},
+		Assertions: []queries.ScriptTestAssertion{
+			{
+				Query: "delete from dolt_workspace_lists where to_id = 1",
+			},
+			{
+				Query:    "select id from lists order by id",
+				Expected: []sql.Row{},
+			},
+			{
+				Query:    "select id from list_entries order by id",
+				Expected: []sql.Row{},
+			},
+		},
+	},
 }