Merge pull request #2944 from dolthub/fulghum/fk_ref_actions

Add support for the `SET DEFAULT` foreign key referential action

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,19 @@ func getForeignKeyRefActions(ctx *sql.Context, a *Analyzer, tbl sql.ForeignKeyTa
 		if err != nil {
 			return nil, err
 		}
-		childTblSch := childTbl.Schema()
+
+		// TODO: Foreign key information is not fully added to the plan node until these FK rules in the analyzer,
+		//       but it should be added during the binding phase, in planbuilder. Because this information is added
+		//       late, we have to do extra work here to resolve the schema defaults, which normally would happen
+		//       during binding. This extra FK information also doesn't get its exec indexes fixed up, so we have to
+		//       manually do that here. Moving all the FK information into the binding, planbuilder, phase would
+		//       clean this up. We should also fix assignExecIndexes to find all these FK schema references and fix
+		//       their exec indexes.
+		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 +443,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/constraints.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/plan/ddl.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/delete.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/foreign_key_editor.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)

sql/planbuilder/ddl.go

@@ -715,6 +715,9 @@ func (b *Builder) buildAlterConstraint(inScope *scope, ddl *ast.DDL, table *plan
 				c.SchemaName = ds.SchemaName()
 			}
 
+			if err := b.validateOnUpdateOnDeleteRefActions(c); err != nil {
+				b.handleErr(err)
+			}
 			alterFk := plan.NewAlterAddForeignKey(c)
 			alterFk.DbProvider = b.cat
 			outScope.node = alterFk
@@ -782,6 +785,9 @@ func (b *Builder) buildConstraintsDefs(inScope *scope, tname ast.TableName, spec
 		case *sql.ForeignKeyConstraint:
 			constraint.Database = tname.DbQualifier.String()
 			constraint.Table = tname.Name.String()
+			if err := b.validateOnUpdateOnDeleteRefActions(constraint); err != nil {
+				b.handleErr(err)
+			}
 			if constraint.Database == "" {
 				constraint.Database = b.ctx.GetCurrentDatabase()
 			}
@@ -1573,6 +1579,40 @@ func (b *Builder) modifySchemaTarget(inScope *scope, n sql.SchemaTarget, sch sql
 	return ret
 }
 
+// ResolveSchemaDefaults resolves any column default value expressions for the specified |schema|, for the table
+// named |tableName| and returns the schema with the default value expressions resolved. Note that any GetField
+// expressions in the column default value expressions have not had their indexes corrected yet.
+func (b *Builder) ResolveSchemaDefaults(db string, tableName string, schema sql.Schema) sql.Schema {
+	tableScope := b.newScope()
+	for _, c := range schema {
+		tableScope.newColumn(scopeColumn{
+			table:       strings.ToLower(tableName),
+			db:          strings.ToLower(db),
+			col:         strings.ToLower(c.Name),
+			originalCol: c.Name,
+			typ:         c.Type,
+			nullable:    c.Nullable,
+		})
+	}
+
+	return b.resolveSchemaDefaults(tableScope, schema)
+}
+
+// validateOnUpdateOnDeleteRefActions validates that the specified |constraint| is using referential actions
+// supported by the current dialect. For example, MySQL parses the syntax for the SET DEFAULT referential action,
+// but doesn't actually support it, so if the MySQL parser is in use, this method will return an error stating
+// that SET DEFAULT is not supported.
+func (b *Builder) validateOnUpdateOnDeleteRefActions(constraint *sql.ForeignKeyConstraint) error {
+	if _, ok := b.parser.(*sql.MysqlParser); ok {
+		if constraint.OnUpdate == sql.ForeignKeyReferentialAction_SetDefault ||
+			constraint.OnDelete == sql.ForeignKeyReferentialAction_SetDefault {
+			return sql.ErrForeignKeySetDefault.New()
+		}
+	}
+
+	return nil
+}
+
 func (b *Builder) resolveSchemaDefaults(inScope *scope, schema sql.Schema) sql.Schema {
 	if len(schema) == 0 {
 		return nil

sql/rowexec/ddl.go

@@ -1184,9 +1184,6 @@ func (b *BaseBuilder) buildAlterTableCollation(ctx *sql.Context, n *plan.AlterTa
 }
 
 func (b *BaseBuilder) buildCreateForeignKey(ctx *sql.Context, n *plan.CreateForeignKey, row sql.Row) (sql.RowIter, error) {
-	if n.FkDef.OnUpdate == sql.ForeignKeyReferentialAction_SetDefault || n.FkDef.OnDelete == sql.ForeignKeyReferentialAction_SetDefault {
-		return nil, sql.ErrForeignKeySetDefault.New()
-	}
 	db, err := n.DbProvider.Database(ctx, n.FkDef.Database)
 	if err != nil {
 		return nil, err