Add support for the foreign key referential action: SET DEFAULT

This is not supported by MySQL, but needed for Postgres support in Doltgres.

Author: fulghum

enginetest/queries/foreign_key_queries.go

@@ -134,6 +134,7 @@ var ForeignKeyTests = []ScriptTest{
 		},
 	},
 	{
+		// MySQL parses the SET DEFAULT referential action, but most engines, e.g. InnoDB, don't actually support it
 		Name: "SET DEFAULT not supported",
 		Assertions: []ScriptTestAssertion{
 			{

sql/analyzer/apply_foreign_keys.go

@@ -21,7 +21,9 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/transform"
 
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 )
 
 // applyForeignKeys handles the application and resolution of foreign keys and their tables.
@@ -380,7 +382,11 @@ func getForeignKeyRefActions(ctx *sql.Context, a *Analyzer, tbl sql.ForeignKeyTa
 		if err != nil {
 			return nil, err
 		}
-		childTblSch := childTbl.Schema()
+		childTblSch, err := resolveSchemaDefaults(ctx, a.Catalog, childTbl)
+		if err != nil {
+			return nil, err
+		}
+
 		childParentMapping, err := plan.GetChildParentMapping(tblSch, childTblSch, fk)
 		if err != nil {
 			return nil, err
@@ -429,6 +435,40 @@ func getForeignKeyRefActions(ctx *sql.Context, a *Analyzer, tbl sql.ForeignKeyTa
 	return fkEditor, nil
 }
 
+// resolveSchemaDefaults resolves the default values for the schema of |table|. This is primarily needed for column
+// default value expressions, since those don't get resolved during the planbuilder phase and assignExecIndexes
+// doesn't traverse through the ForeignKeyEditors and referential actions to find all of them. In addition to resolving
+// the expressions, this also ensures their GetField indexes are correct, knowing that those expressions will only
+// be evaluated in the context of a single table.
+func resolveSchemaDefaults(ctx *sql.Context, catalog *Catalog, table sql.Table) (sql.Schema, error) {
+	// Resolve any column default expressions in tblSch
+	builder := planbuilder.New(ctx, catalog, nil, sql.GlobalParser)
+	childTblSch := builder.ResolveSchemaDefaults(ctx.GetCurrentDatabase(), table.Name(), table.Schema())
+
+	// Field Indexes are off by one initially and don't fixed by assignExecIndexes because it doesn't traverse through
+	// the ForeignKeyEditors and referential actions, so we correct them here. This is safe because we know these fields
+	// will only ever be accessed within the scope of a single table, so all we have to do is decrement the index by 1.
+	for i, col := range childTblSch {
+		if col.Default != nil {
+			expr := col.Default.Expr
+			expr, identity, err := transform.Expr(expr, func(e sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
+				if gf, ok := e.(*expression.GetField); ok {
+					return gf.WithIndex(gf.Index() - 1), transform.NewTree, nil
+				}
+				return e, transform.SameTree, nil
+			})
+			if err != nil {
+				return nil, err
+			}
+			if identity == transform.NewTree {
+				childTblSch[i].Default.Expr = expr
+			}
+		}
+	}
+
+	return childTblSch, nil
+}
+
 // foreignKeyTableName is the combination of a table's database along with their name, both lowercased.
 type foreignKeyTableName struct {
 	dbName     string

sql/analyzer/rule_ids.go

@@ -68,17 +68,18 @@ const (
 	interpreterId                // interpreter
 
 	// validate
-	validateResolvedId          // validateResolved
-	validateOrderById           // validateOrderBy
-	validateGroupById           // validateGroupBy
-	validateSchemaSourceId      // validateSchemaSource
-	validateIndexCreationId     // validateIndexCreation
-	ValidateOperandsId          // validateOperands
-	validateIntervalUsageId     // validateIntervalUsage
-	validateSubqueryColumnsId   // validateSubqueryColumns
-	validateUnionSchemasMatchId // validateUnionSchemasMatch
-	validateAggregationsId      // validateAggregations
-	validateDeleteFromId        // validateDeleteFrom
+	validateResolvedId                     // validateResolved
+	validateOrderById                      // validateOrderBy
+	validateGroupById                      // validateGroupBy
+	validateSchemaSourceId                 // validateSchemaSource
+	validateIndexCreationId                // validateIndexCreation
+	ValidateOperandsId                     // validateOperands
+	validateIntervalUsageId                // validateIntervalUsage
+	validateSubqueryColumnsId              // validateSubqueryColumns
+	validateUnionSchemasMatchId            // validateUnionSchemasMatch
+	validateAggregationsId                 // validateAggregations
+	validateDeleteFromId                   // validateDeleteFrom
+	ValidateForeignKeyReferentialActionsId // validateForeignKeyReferentialActions
 
 	// after all
 	cacheSubqueryAliasesInJoinsId  // cacheSubqueryAliasesInJoins

sql/analyzer/ruleid_string.go

@@ -107,6 +107,7 @@ var DefaultValidationRules = []Rule{
 	{validateSubqueryColumnsId, validateSubqueryColumns},
 	{validateUnionSchemasMatchId, validateUnionSchemasMatch},
 	{validateAggregationsId, validateAggregations},
+	{ValidateForeignKeyReferentialActionsId, validateForeignKeyReferentialActions},
 }
 
 var OnceAfterAll []Rule

sql/analyzer/rules.go

@@ -95,6 +95,27 @@ func validateOffsetAndLimit(ctx *sql.Context, a *Analyzer, n sql.Node, scope *pl
 	return n, transform.SameTree, err
 }
 
+// validateForeignKeyReferentialActions checks |n| for foreign keys being created and validates that
+// their referential actions are valid for MySQL. This currently only checks for use of SET DEFAULT,
+// which MySQL supports in SQL syntax, but does not actually support that referential action and will
+// always throw an error if it is specified.
+func validateForeignKeyReferentialActions(ctx *sql.Context, _ *Analyzer, n sql.Node, _ *plan.Scope, _ RuleSelector, _ *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
+	span, ctx := ctx.Span("validate_fk_referential_actions")
+	defer span.End()
+
+	return transform.Node(n, func(n sql.Node) (sql.Node, transform.TreeIdentity, error) {
+		switch n := n.(type) {
+		case *plan.CreateForeignKey:
+			if n.FkDef.OnUpdate == sql.ForeignKeyReferentialAction_SetDefault ||
+				n.FkDef.OnDelete == sql.ForeignKeyReferentialAction_SetDefault {
+				return n, transform.SameTree, sql.ErrForeignKeySetDefault.New()
+			}
+		}
+
+		return n, transform.SameTree, nil
+	})
+}
+
 func validateResolved(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
 	span, ctx := ctx.Span("validate_is_resolved")
 	defer span.End()

sql/analyzer/validation_rules.go

@@ -36,7 +36,7 @@ const (
 // a number of referential actions, the majority of them are functionally ignored and default to RESTRICT.
 func (f ForeignKeyReferentialAction) IsEquivalentToRestrict() bool {
 	switch f {
-	case ForeignKeyReferentialAction_Cascade, ForeignKeyReferentialAction_SetNull:
+	case ForeignKeyReferentialAction_Cascade, ForeignKeyReferentialAction_SetNull, ForeignKeyReferentialAction_SetDefault:
 		return false
 	default:
 		return true

sql/constraints.go

@@ -368,11 +368,6 @@ func (c *CreateTable) CreateForeignKeys(ctx *sql.Context, tableNode sql.Table) e
 	}
 
 	for i, fkDef := range c.fkDefs {
-		if fkDef.OnUpdate == sql.ForeignKeyReferentialAction_SetDefault ||
-			fkDef.OnDelete == sql.ForeignKeyReferentialAction_SetDefault {
-			return sql.ErrForeignKeySetDefault.New()
-		}
-
 		if fkChecks.(int8) == 1 {
 			fkParentTbl := c.fkParentTbls[i]
 			// If a foreign key is self-referential then the analyzer uses a nil since the table does not yet exist

sql/plan/ddl.go

@@ -110,6 +110,7 @@ func (p *DeleteFrom) WithChildren(children ...sql.Node) (sql.Node, error) {
 	if len(children) != 1 {
 		return nil, sql.ErrInvalidChildrenNumber.New(p, len(children), 1)
 	}
+
 	return NewDeleteFrom(children[0], p.explicitTargets), nil
 }
 

sql/plan/delete.go

@@ -109,6 +109,7 @@ func (fkEditor *ForeignKeyEditor) Update(ctx *sql.Context, old sql.Row, new sql.
 			}
 		case sql.ForeignKeyReferentialAction_Cascade:
 		case sql.ForeignKeyReferentialAction_SetNull:
+		case sql.ForeignKeyReferentialAction_SetDefault:
 		}
 	}
 	if err := fkEditor.Editor.Update(ctx, old, new); err != nil {
@@ -124,6 +125,10 @@ func (fkEditor *ForeignKeyEditor) Update(ctx *sql.Context, old sql.Row, new sql.
 			if err := fkEditor.OnUpdateSetNull(ctx, refActionData, old, new, depth+1); err != nil {
 				return err
 			}
+		case sql.ForeignKeyReferentialAction_SetDefault:
+			if err := fkEditor.OnUpdateSetDefault(ctx, refActionData, old, new, depth+1); err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -190,6 +195,58 @@ func (fkEditor *ForeignKeyEditor) OnUpdateCascade(ctx *sql.Context, refActionDat
 	return err
 }
 
+// OnUpdateSetDefault handles the ON UPDATE SET DEFAULT referential action.
+func (fkEditor *ForeignKeyEditor) OnUpdateSetDefault(ctx *sql.Context, refActionData ForeignKeyRefActionData, old sql.Row, new sql.Row, depth int) error {
+	if ok, err := fkEditor.ColumnsUpdated(ctx, refActionData, old, new); err != nil {
+		return err
+	} else if !ok {
+		return nil
+	}
+
+	rowIter, err := refActionData.RowMapper.GetIter(ctx, old, false)
+	if err != nil {
+		return err
+	}
+	defer rowIter.Close(ctx)
+	var rowToDefault sql.Row
+	for rowToDefault, err = rowIter.Next(ctx); err == nil; rowToDefault, err = rowIter.Next(ctx) {
+		// MySQL seems to have a bug where cyclical foreign keys return an error at a depth of 15 instead of 16.
+		// This replicates the observed behavior, regardless of whether we're replicating a bug or intentional behavior.
+		if depth >= 15 {
+			if fkEditor.Cyclical {
+				return sql.ErrForeignKeyDepthLimit.New()
+			} else if depth > 15 {
+				return sql.ErrForeignKeyDepthLimit.New()
+			}
+		}
+
+		modifiedRow := make(sql.Row, len(rowToDefault))
+		for i := range rowToDefault {
+			// Row contents are nil by default, so we only need to assign the non-affected values
+			if refActionData.ChildParentMapping[i] == -1 {
+				modifiedRow[i] = rowToDefault[i]
+			} else {
+				col := refActionData.Editor.Schema[i]
+				if col.Default != nil {
+					newVal, err := col.Default.Eval(ctx, rowToDefault)
+					if err != nil {
+						return err
+					}
+					modifiedRow[i] = newVal
+				}
+			}
+		}
+		err = refActionData.Editor.Update(ctx, rowToDefault, modifiedRow, depth)
+		if err != nil {
+			return err
+		}
+	}
+	if err == io.EOF {
+		return nil
+	}
+	return err
+}
+
 // OnUpdateSetNull handles the ON UPDATE SET NULL referential action.
 func (fkEditor *ForeignKeyEditor) OnUpdateSetNull(ctx *sql.Context, refActionData ForeignKeyRefActionData, old sql.Row, new sql.Row, depth int) error {
 	if ok, err := fkEditor.ColumnsUpdated(ctx, refActionData, old, new); err != nil {
@@ -237,6 +294,7 @@ func (fkEditor *ForeignKeyEditor) Delete(ctx *sql.Context, row sql.Row, depth in
 			}
 		case sql.ForeignKeyReferentialAction_Cascade:
 		case sql.ForeignKeyReferentialAction_SetNull:
+		case sql.ForeignKeyReferentialAction_SetDefault:
 		}
 	}
 	if err := fkEditor.Editor.Delete(ctx, row); err != nil {
@@ -252,6 +310,10 @@ func (fkEditor *ForeignKeyEditor) Delete(ctx *sql.Context, row sql.Row, depth in
 			if err := fkEditor.OnDeleteSetNull(ctx, refActionData, row, depth+1); err != nil {
 				return err
 			}
+		case sql.ForeignKeyReferentialAction_SetDefault:
+			if err := fkEditor.OnDeleteSetDefault(ctx, refActionData, row, depth+1); err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -303,6 +365,52 @@ func (fkEditor *ForeignKeyEditor) OnDeleteCascade(ctx *sql.Context, refActionDat
 	return err
 }
 
+// OnDeleteSetDefault handles the ON DELETE SET DEFAULT referential action.
+func (fkEditor *ForeignKeyEditor) OnDeleteSetDefault(ctx *sql.Context, refActionData ForeignKeyRefActionData, row sql.Row, depth int) error {
+	rowIter, err := refActionData.RowMapper.GetIter(ctx, row, false)
+	if err != nil {
+		return err
+	}
+	defer rowIter.Close(ctx)
+	var rowToDefault sql.Row
+	for rowToDefault, err = rowIter.Next(ctx); err == nil; rowToDefault, err = rowIter.Next(ctx) {
+		// MySQL seems to have a bug where cyclical foreign keys return an error at a depth of 15 instead of 16.
+		// This replicates the observed behavior, regardless of whether we're replicating a bug or intentional behavior.
+		if depth >= 15 {
+			if fkEditor.Cyclical {
+				return sql.ErrForeignKeyDepthLimit.New()
+			} else if depth > 15 {
+				return sql.ErrForeignKeyDepthLimit.New()
+			}
+		}
+
+		modifiedRow := make(sql.Row, len(rowToDefault))
+		for i := range rowToDefault {
+			// Row contents are nil by default, so we only need to assign the non-affected values
+			if refActionData.ChildParentMapping[i] == -1 {
+				modifiedRow[i] = rowToDefault[i]
+			} else {
+				col := refActionData.Editor.Schema[i]
+				if col.Default != nil {
+					newVal, err := col.Default.Eval(ctx, rowToDefault)
+					if err != nil {
+						return err
+					}
+					modifiedRow[i] = newVal
+				}
+			}
+		}
+		err = refActionData.Editor.Update(ctx, rowToDefault, modifiedRow, depth)
+		if err != nil {
+			return err
+		}
+	}
+	if err == io.EOF {
+		return nil
+	}
+	return err
+}
+
 // OnDeleteSetNull handles the ON DELETE SET NULL referential action.
 func (fkEditor *ForeignKeyEditor) OnDeleteSetNull(ctx *sql.Context, refActionData ForeignKeyRefActionData, row sql.Row, depth int) error {
 	rowIter, err := refActionData.RowMapper.GetIter(ctx, row, false)