schemadiff: temporal range partition rotation analysis and operation

go/mysql/config/config.go

@@ -3,3 +3,4 @@ package config
 const DefaultSQLMode = "ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION"
 const DefaultMySQLVersion = "8.0.30"
 const LegacyMySQLVersion = "5.7.31"
+const Lts84MySQLVersion = "8.4.3"

go/mysql/datetime/interval.go

@@ -80,6 +80,39 @@ var intervalSet = [...]intervalSetter{
 	intervalSetYear,
 }
 
+var (
+	intervalTypeNames = map[IntervalType]string{
+		IntervalYear:              "year",
+		IntervalQuarter:           "quarter",
+		IntervalMonth:             "month",
+		IntervalWeek:              "week",
+		IntervalDay:               "day",
+		IntervalHour:              "hour",
+		IntervalMinute:            "minute",
+		IntervalSecond:            "second",
+		IntervalMicrosecond:       "microsecond",
+		IntervalYearMonth:         "year_month",
+		IntervalDayHour:           "day_hour",
+		IntervalDayMinute:         "day_minute",
+		IntervalDaySecond:         "day_second",
+		IntervalHourMinute:        "hour_minute",
+		IntervalHourSecond:        "hour_second",
+		IntervalMinuteSecond:      "minute_second",
+		IntervalDayMicrosecond:    "day_microsecond",
+		IntervalHourMicrosecond:   "hour_microsecond",
+		IntervalMinuteMicrosecond: "minute_microsecond",
+		IntervalSecondMicrosecond: "second_microsecond",
+	}
+	namedIntervalTypes map[string]IntervalType
+)
+
+func init() {
+	namedIntervalTypes = make(map[string]IntervalType, len(intervalTypeNames))
+	for itv, name := range intervalTypeNames {
+		namedIntervalTypes[strings.ToLower(name)] = itv
+	}
+}
+
 // setter returns the setter method for this interval's type.
 // If this is a unary interval, it'll return the setter for the interval's unary type.
 // If this is a compound interval, it'll return the setter for the smallest unary type
@@ -120,50 +153,18 @@ func (itv IntervalType) NeedsPrecision() bool {
 
 // ToString returns the type as a string
 func (itv IntervalType) ToString() string {
-	switch itv {
-	case IntervalYear:
-		return "year"
-	case IntervalQuarter:
-		return "quarter"
-	case IntervalMonth:
-		return "month"
-	case IntervalWeek:
-		return "week"
-	case IntervalDay:
-		return "day"
-	case IntervalHour:
-		return "hour"
-	case IntervalMinute:
-		return "minute"
-	case IntervalSecond:
-		return "second"
-	case IntervalMicrosecond:
-		return "microsecond"
-	case IntervalYearMonth:
-		return "year_month"
-	case IntervalDayHour:
-		return "day_hour"
-	case IntervalDayMinute:
-		return "day_minute"
-	case IntervalDaySecond:
-		return "day_second"
-	case IntervalHourMinute:
-		return "hour_minute"
-	case IntervalHourSecond:
-		return "hour_second"
-	case IntervalMinuteSecond:
-		return "minute_second"
-	case IntervalDayMicrosecond:
-		return "day_microsecond"
-	case IntervalHourMicrosecond:
-		return "hour_microsecond"
-	case IntervalMinuteMicrosecond:
-		return "minute_microsecond"
-	case IntervalSecondMicrosecond:
-		return "second_microsecond"
-	default:
-		return "[unknown IntervalType]"
+	if name, ok := intervalTypeNames[itv]; ok {
+		return name
+	}
+	return "[unknown IntervalType]"
+}
+
+// IntervalTypeFromString parses a string into an IntervalType. This is the inverse function of IntervalType.ToString().
+func IntervalTypeFromString(s string) IntervalType {
+	if itv, ok := namedIntervalTypes[strings.ToLower(s)]; ok {
+		return itv
 	}
+	return IntervalNone
 }
 
 func intervalSetYear(tp *Interval, val int) {

go/mysql/datetime/interval_test.go

@@ -17,9 +17,12 @@ limitations under the License.
 package datetime
 
 import (
+	"math"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"vitess.io/vitess/go/mysql/decimal"
 )
@@ -367,3 +370,47 @@ func TestInRange(t *testing.T) {
 		assert.Equal(t, tc.wantInRange, got)
 	}
 }
+
+func TestIntervalTypeFromString(t *testing.T) {
+	intervals := []IntervalType{
+		IntervalMicrosecond,
+		IntervalSecond,
+		IntervalMinute,
+		IntervalHour,
+		IntervalDay,
+		IntervalWeek,
+		IntervalMonth,
+		IntervalQuarter,
+		IntervalYear,
+		IntervalSecondMicrosecond,
+		IntervalMinuteMicrosecond,
+		IntervalMinuteSecond,
+		IntervalHourMicrosecond,
+		IntervalHourSecond,
+		IntervalHourMinute,
+		IntervalDayMicrosecond,
+		IntervalDaySecond,
+		IntervalDayMinute,
+		IntervalDayHour,
+		IntervalYearMonth,
+	}
+	for _, interval := range intervals {
+		s := interval.ToString()
+		t.Run(s, func(t *testing.T) {
+			require.NotEmpty(t, s)
+			require.NotEqual(t, "[unknown IntervalType]", s)
+			parsed := IntervalTypeFromString(s)
+			assert.NotEqual(t, IntervalNone, parsed)
+			assert.Equal(t, interval, parsed)
+
+			parsed = IntervalTypeFromString(strings.ToUpper(s))
+			assert.NotEqual(t, IntervalNone, parsed)
+			assert.Equal(t, interval, parsed)
+		})
+	}
+	interval := IntervalType(math.MaxUint8)
+	s := interval.ToString()
+	assert.Equal(t, "[unknown IntervalType]", s)
+	parsed := IntervalTypeFromString(s)
+	assert.Equal(t, IntervalNone, parsed)
+}

go/vt/schemadiff/diff_test.go

@@ -587,9 +587,11 @@ func TestDiffSchemas(t *testing.T) {
 		diffs       []string
 		cdiffs      []string
 		expectError string
-		tableRename int
 		annotated   []string
+		// hints:
+		tableRename int
 		fkStrategy  int
+		rotation    int
 	}{
 		{
 			name: "identical tables",
@@ -922,6 +924,35 @@ func TestDiffSchemas(t *testing.T) {
 				"ALTER TABLE `t` RENAME INDEX `i_idx` TO `i_alternative`",
 			},
 		},
+		// Partitions
+		{
+			name:     "change partitioning range: statements, add",
+			from:     "create table t1 (id int primary key) partition by range (id) (partition p1 values less than (10), partition p2 values less than (20))",
+			to:       "create table t1 (id int primary key) partition by range (id) (partition p1 values less than (10), partition p2 values less than (20), partition p3 values less than (30))",
+			rotation: RangeRotationDistinctStatements,
+			diffs: []string{
+				"alter table t1 add partition (partition p3 values less than (30))",
+			},
+			cdiffs: []string{
+				"ALTER TABLE `t1` ADD PARTITION (PARTITION `p3` VALUES LESS THAN (30))",
+			},
+		},
+		{
+			name:     "change partitioning range: statements, multiple drops, distinct",
+			from:     "create table t1 (id int primary key) partition by range (id) (partition p1 values less than (10), partition p2 values less than (20), partition p3 values less than (30))",
+			to:       "create table t1 (id int primary key) partition by range (id) (partition p3 values less than (30))",
+			rotation: RangeRotationDistinctStatements,
+			diffs:    []string{"alter table t1 drop partition p1, p2"},
+			cdiffs:   []string{"ALTER TABLE `t1` DROP PARTITION `p1`, `p2`"},
+		},
+		{
+			name:     "change partitioning range: statements, multiple, assorted",
+			from:     "create table t1 (id int primary key) partition by range (id) (partition p1 values less than (10), partition p2 values less than (20), partition p3 values less than (30))",
+			to:       "create table t1 (id int primary key) partition by range (id) (partition p2 values less than (20), partition p3 values less than (30), partition p4 values less than (40))",
+			rotation: RangeRotationDistinctStatements,
+			diffs:    []string{"alter table t1 drop partition p1", "alter table t1 add partition (partition p4 values less than (40))"},
+			cdiffs:   []string{"ALTER TABLE `t1` DROP PARTITION `p1`", "ALTER TABLE `t1` ADD PARTITION (PARTITION `p4` VALUES LESS THAN (40))"},
+		},
 		// Views
 		{
 			name: "identical views",
@@ -1043,6 +1074,7 @@ func TestDiffSchemas(t *testing.T) {
 			hints := &DiffHints{
 				TableRenameStrategy:     ts.tableRename,
 				ForeignKeyCheckStrategy: ts.fkStrategy,
+				RangeRotationStrategy:   ts.rotation,
 			}
 			diff, err := DiffSchemasSQL(env, ts.from, ts.to, hints)
 			if ts.expectError != "" {

go/vt/schemadiff/env.go

@@ -17,6 +17,13 @@ func NewTestEnv() *Environment {
 	}
 }
 
+func New84TestEnv() *Environment {
+	return &Environment{
+		Environment: vtenv.New84TestEnv(),
+		DefaultColl: collations.MySQL8().DefaultConnectionCharset(),
+	}
+}
+
 func NewEnv(env *vtenv.Environment, defaultColl collations.ID) *Environment {
 	return &Environment{
 		Environment: env,