fix fk time issues

Author: elianddb

enginetest/queries/script_queries.go

@@ -10856,81 +10856,68 @@ where
 		},
 		Assertions: []ScriptTestAssertion{
 			{
-				Skip:  true,
 				Query: "create table child_datetime0 (dt datetime, foreign key (dt) references parent_datetime6(dt));",
 				Expected: []sql.Row{
 					{types.NewOkResult(0)},
 				},
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child_datetime0 values ('2001-02-03 12:34:56');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 			{
-				Skip:  true,
 				Query: "create table child_datetime6 (dt datetime(6), foreign key (dt) references parent_datetime0(dt));",
 				Expected: []sql.Row{
 					{types.NewOkResult(0)},
 				},
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child_datetime6 values ('2001-02-03 12:34:56');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 
 			{
-				Skip:  true,
 				Query: "create table child1_timestamp0 (ts timestamp, foreign key (ts) references parent_datetime0(dt));",
 				Expected: []sql.Row{
 					{types.NewOkResult(0)},
 				},
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child1_timestamp0 values ('2001-02-03 12:34:56');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 			{
-				Skip:  true,
 				Query: "create table child2_timestamp0 (ts timestamp, foreign key (ts) references parent_datetime6(dt));",
 				Expected: []sql.Row{
 					{types.NewOkResult(0)},
 				},
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child2_timestamp0 values ('2001-02-03 12:34:56');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 
 			{
-				Skip:  true,
 				Query: "create table child1_timestamp6 (ts timestamp(6), foreign key (ts) references parent_datetime0(dt));",
 				Expected: []sql.Row{
 					{types.NewOkResult(0)},
 				},
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child1_timestamp6 values ('2001-02-03 12:34:56');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 			{
-				Skip:  true,
 				Query: "create table child2_timestamp6 (ts timestamp(6), foreign key (ts) references parent_datetime6(dt));",
 				Expected: []sql.Row{
 					{types.NewOkResult(0)},
 				},
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child2_timestamp6 values ('2001-02-03 12:34:56');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},
 			{
-				Skip:        true,
 				Query:       "insert into child2_timestamp6 values ('2001-02-03 12:34:56.123456');",
 				ExpectedErr: sql.ErrForeignKeyChildViolation,
 			},

sql/plan/alter_foreign_key.go

@@ -651,6 +651,16 @@ func foreignKeyComparableTypes(ctx *sql.Context, type1 sql.Type, type2 sql.Type)
 	t1 := type1.Type()
 	t2 := type2.Type()
 
+	// Handle time-related types with different precisions or cross-type references
+	if (types.IsTime(type1) || types.IsTimespan(type1)) && (types.IsTime(type2) || types.IsTimespan(type2)) {
+		// MySQL allows time-related types to reference each other in foreign keys:
+		// - DATETIME can reference DATETIME with different precision
+		// - TIMESTAMP can reference TIMESTAMP with different precision  
+		// - DATETIME can reference TIMESTAMP and vice versa
+		// - TIME can reference TIME with different precision
+		return true
+	}
+
 	// Handle same-type cases for special types
 	if t1 == t2 {
 		switch t1 {

sql/plan/foreign_key_editor.go

@@ -521,6 +521,9 @@ func (reference *ForeignKeyReferenceHandler) CheckReference(ctx *sql.Context, ro
 		if validationErr := reference.validateDecimalConstraints(row); validationErr != nil {
 			return validationErr
 		}
+		if validationErr := reference.validateTimeConstraints(row); validationErr != nil {
+			return validationErr
+		}
 		// We have a parent row so throw no error
 		return nil
 	}
@@ -581,6 +584,43 @@ func (reference *ForeignKeyReferenceHandler) validateDecimalConstraints(row sql.
 	return nil
 }
 
+// validateTimeConstraints checks that time-related foreign key columns have exact type and precision matches.
+// MySQL requires strict matching for time types in foreign keys - even logically equivalent values
+// like '2001-02-03 12:34:56' vs '2001-02-03 12:34:56.000000' are rejected if precision differs.
+func (reference *ForeignKeyReferenceHandler) validateTimeConstraints(row sql.Row) error {
+	if reference.RowMapper.Index == nil {
+		return nil
+	}
+	indexColumnTypes := reference.RowMapper.Index.ColumnExpressionTypes()
+	for parentIdx, parentCol := range indexColumnTypes {
+		if parentIdx >= len(reference.RowMapper.IndexPositions) {
+			break
+		}
+		parentType := parentCol.Type
+		childColIdx := reference.RowMapper.IndexPositions[parentIdx]
+		childType := reference.RowMapper.SourceSch[childColIdx].Type
+		
+		// Check if both types are time-related
+		isChildTime := types.IsTime(childType) || types.IsTimespan(childType)
+		isParentTime := types.IsTime(parentType) || types.IsTimespan(parentType)
+		
+		if !isChildTime || !isParentTime {
+			continue
+		}
+		
+		// MySQL requires exact type matching for time types in foreign key validation
+		if !childType.Equals(parentType) {
+			return sql.ErrForeignKeyChildViolation.New(
+				reference.ForeignKey.Name,
+				reference.ForeignKey.Table,
+				reference.ForeignKey.ParentTable,
+				reference.RowMapper.GetKeyString(row),
+			)
+		}
+	}
+	return nil
+}
+
 // CheckTable checks that every row in the table has an index entry in the referenced table.
 func (reference *ForeignKeyReferenceHandler) CheckTable(ctx *sql.Context, tbl sql.ForeignKeyTable) error {
 	partIter, err := tbl.Partitions(ctx)