Adjustments for v22

Signed-off-by: Matt Lord <mattalord@gmail.com>

Author: mattlord

go/vt/vtctl/workflow/sequences.go

@@ -166,18 +166,21 @@ func (ts *trafficSwitcher) getMaxSequenceValue(ctx context.Context, seq *sequenc
 			Query:   []byte(query.Query),
 			MaxRows: 1,
 		})
-		if terr != nil || len(qr.Rows) != 1 {
+		if terr != nil {
 			return vterrors.Errorf(vtrpcpb.Code_INTERNAL,
 				"failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v",
 				ts.targetKeyspace, seq.usingTableName, topoproto.TabletAliasString(primary.Alias), terr)
 		}
-		rawVal := sqltypes.Proto3ToResult(qr).Rows[0][0]
 		maxID := int64(0)
-		if !rawVal.IsNull() { // If it's NULL then there are no rows and 0 remains the max
-			maxID, terr = rawVal.ToInt64()
-			if terr != nil {
-				return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v",
-					ts.targetKeyspace, seq.usingTableName, topoproto.TabletAliasString(primary.Alias), terr)
+		// If no rows are returned, max remains 0.
+		if len(qr.Rows) != 0 {
+			rawVal := sqltypes.Proto3ToResult(qr).Rows[0][0]
+			if !rawVal.IsNull() { // If it's NULL then 0 remains the max
+				maxID, terr = rawVal.ToInt64()
+				if terr != nil {
+					return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the max used sequence value for target table %s.%s on tablet %s in order to initialize the backing sequence table: %v",
+						ts.targetKeyspace, seq.usingTableName, topoproto.TabletAliasString(primary.Alias), terr)
+				}
 			}
 		}
 		setMaxSequenceValue(maxID)
@@ -250,27 +253,9 @@ func (ts *trafficSwitcher) getCurrentSequenceValue(ctx context.Context, seq *seq
 	return currentVal, nil
 }
 
-<<<<<<< HEAD
 func (ts *trafficSwitcher) updateSequenceValue(ctx context.Context, seq *sequenceMetadata, currentMaxValue int64) error {
 	if err := seq.escapeValues(); err != nil {
 		return err
-=======
-func (ts *trafficSwitcher) updateSequenceValues(ctx context.Context, sequences []*sequenceMetadata, maxValues map[string]int64) error {
-	sequencesByShard := map[string][]*tabletmanagerdatapb.UpdateSequenceTablesRequest_SequenceMetadata{}
-	for _, seq := range sequences {
-		maxValue := maxValues[seq.backingTableName]
-		sequenceShard, ierr := ts.TopoServer().GetOnlyShard(ctx, seq.backingTableKeyspace)
-		if ierr != nil || sequenceShard == nil || sequenceShard.PrimaryAlias == nil {
-			return vterrors.Errorf(vtrpcpb.Code_INTERNAL, "failed to get the primary tablet for keyspace %s: %v",
-				seq.backingTableKeyspace, ierr)
-		}
-		tabletAliasStr := topoproto.TabletAliasString(sequenceShard.PrimaryAlias)
-		sequencesByShard[tabletAliasStr] = append(sequencesByShard[tabletAliasStr], &tabletmanagerdatapb.UpdateSequenceTablesRequest_SequenceMetadata{
-			BackingTableName:   seq.backingTableName,
-			BackingTableDbName: seq.backingTableDBName,
-			MaxValue:           maxValue,
-		})
->>>>>>> 81356abde1 (VReplication: Properly Handle Sequence Table Initialization For Empty Tables (#19226))
 	}
 	nextVal := currentMaxValue + 1
 	log.Infof("Updating sequence %s.%s to %d", seq.backingTableDBName, seq.backingTableName, nextVal)
@@ -370,9 +355,6 @@ func (ts *trafficSwitcher) initializeTargetSequences(ctx context.Context, sequen
 	}
 	for _, sm := range sequencesByBackingTable {
 		maxValue := maxValues[sm.backingTableName]
-		if maxValue == 0 {
-			continue
-		}
 		if err := ts.updateSequenceValue(ctx, sm, maxValue); err != nil {
 			return err
 		}

go/vt/vtctl/workflow/sequences_test.go

@@ -28,12 +28,13 @@ import (
 	"vitess.io/vitess/go/sqlescape"
 	"vitess.io/vitess/go/sqltypes"
 	"vitess.io/vitess/go/vt/mysqlctl/tmutils"
-	tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata"
 	"vitess.io/vitess/go/vt/proto/vschema"
-	vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata"
 	"vitess.io/vitess/go/vt/sqlparser"
 	"vitess.io/vitess/go/vt/topo"
 	"vitess.io/vitess/go/vt/vttablet/tabletmanager/vreplication"
+
+	tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata"
+	vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata"
 )
 
 func TestInitializeTargetSequences(t *testing.T) {
@@ -89,121 +90,48 @@ func TestInitializeTargetSequences(t *testing.T) {
 		},
 	}
 
-<<<<<<< HEAD
-	env.tmc.expectVRQuery(200, "/select max.*", sqltypes.MakeTestResult(sqltypes.MakeTestFields("maxval", "int64"), "34"))
-	// Expect the insert query to be executed with 35 as a params, since we provide a maxID of 34 in the last query
-	env.tmc.expectVRQuery(100, "/insert into.*35.*", &sqltypes.Result{RowsAffected: 1})
-=======
 	type testCase struct {
-		name                  string
-		maxValueRequest       *getMaxValueForSequencesRequestResponse
-		updateSeqTableRequest *tabletmanagerdatapb.UpdateSequenceTablesRequest
+		name            string
+		selectMaxQuery  string
+		selectMaxResult *sqltypes.Result
+		insertQuery     string
 	}
 
 	testCases := []testCase{
 		{
-			name: "initialize sequences",
-			maxValueRequest: &getMaxValueForSequencesRequestResponse{
-				req: &tabletmanagerdatapb.GetMaxValueForSequencesRequest{
-					Sequences: []*tabletmanagerdatapb.GetMaxValueForSequencesRequest_SequenceMetadata{
-						{
-							BackingTableName:        "my-seq1",
-							UsingColEscaped:         "`my-col`",
-							UsingTableNameEscaped:   fmt.Sprintf("`%s`", tableName),
-							UsingTableDbNameEscaped: "`vt_targetks`",
-						},
-						{
-							BackingTableName:        "my-seq2",
-							UsingColEscaped:         "`my-col-2`",
-							UsingTableNameEscaped:   fmt.Sprintf("`%s`", tableName2),
-							UsingTableDbNameEscaped: "`vt_targetks`",
-						},
-					},
-				},
-				res: &tabletmanagerdatapb.GetMaxValueForSequencesResponse{
-					MaxValuesBySequenceTable: map[string]int64{
-						"my-seq1": 34,
-						"my-seq2": 10,
-					},
-				},
-			},
-			updateSeqTableRequest: &tabletmanagerdatapb.UpdateSequenceTablesRequest{
-				Sequences: []*tabletmanagerdatapb.UpdateSequenceTablesRequest_SequenceMetadata{
-					{
-						BackingTableName:   "my-seq1",
-						BackingTableDbName: "vt_" + sourceKeyspaceName,
-						MaxValue:           34,
-					},
-					{
-						BackingTableName:   "my-seq2",
-						BackingTableDbName: "vt_" + sourceKeyspaceName,
-						MaxValue:           10,
-					},
-				},
-			},
+			name:           "initialize sequences",
+			selectMaxQuery: "/select max.*",
+			selectMaxResult: sqltypes.MakeTestResult(
+				sqltypes.MakeTestFields("maxval", "int64"),
+				"34",
+			),
+			insertQuery: "/insert into.*35.*",
 		},
 		{
-			name: "initialize sequences for empty tables",
-			maxValueRequest: &getMaxValueForSequencesRequestResponse{
-				req: &tabletmanagerdatapb.GetMaxValueForSequencesRequest{
-					Sequences: []*tabletmanagerdatapb.GetMaxValueForSequencesRequest_SequenceMetadata{
-						{
-							BackingTableName:        "my-seq1",
-							UsingColEscaped:         "`my-col`",
-							UsingTableNameEscaped:   fmt.Sprintf("`%s`", tableName),
-							UsingTableDbNameEscaped: "`vt_targetks`",
-						},
-						{
-							BackingTableName:        "my-seq2",
-							UsingColEscaped:         "`my-col-2`",
-							UsingTableNameEscaped:   fmt.Sprintf("`%s`", tableName2),
-							UsingTableDbNameEscaped: "`vt_targetks`",
-						},
-					},
-				},
-				res: &tabletmanagerdatapb.GetMaxValueForSequencesResponse{
-					MaxValuesBySequenceTable: map[string]int64{},
-				},
-			},
-			updateSeqTableRequest: &tabletmanagerdatapb.UpdateSequenceTablesRequest{
-				Sequences: []*tabletmanagerdatapb.UpdateSequenceTablesRequest_SequenceMetadata{
-					{
-						BackingTableName:   "my-seq1",
-						BackingTableDbName: "vt_" + sourceKeyspaceName,
-						MaxValue:           0,
-					},
-					{
-						BackingTableName:   "my-seq2",
-						BackingTableDbName: "vt_" + sourceKeyspaceName,
-						MaxValue:           0,
-					},
-				},
-			},
+			name:           "initialize sequences for empty tables",
+			selectMaxQuery: "/select max.*",
+			selectMaxResult: sqltypes.MakeTestResult(
+				sqltypes.MakeTestFields("maxval", "int64"),
+			),
+			insertQuery: "/insert into.*1.*",
 		},
 	}
->>>>>>> 81356abde1 (VReplication: Properly Handle Sequence Table Initialization For Empty Tables (#19226))
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			require.NotNil(t, tc.maxValueRequest)
-			require.NotNil(t, tc.updateSeqTableRequest)
-			env.tmc.expectGetMaxValueForSequencesRequest(200, tc.maxValueRequest)
-			env.tmc.expectUpdateSequenceTablesRequest(100, tc.updateSeqTableRequest)
-
-<<<<<<< HEAD
-	// Expect the queries to be cleared
-	assert.Emptyf(t, env.tmc.vrQueries[100], "expected no queries to be executed, found: %q", env.tmc.vrQueries[100])
-	assert.Empty(t, env.tmc.vrQueries[200], "expected no queries to be executed, found: %q", env.tmc.vrQueries[200])
-=======
+			// Expect the select max query to be executed
+			env.tmc.expectVRQuery(200, tc.selectMaxQuery, tc.selectMaxResult)
+			// Expect the insert query to be executed
+			env.tmc.expectVRQuery(100, tc.insertQuery, &sqltypes.Result{RowsAffected: 1})
+
 			err = sw.initializeTargetSequences(ctx, sequencesByBackingTable)
 			assert.NoError(t, err)
 
-			// Expect the requests to be cleared.
-			assert.Emptyf(t, env.tmc.updateSequenceTablesRequests, "expected no remaining UpdateSequenceTables requests")
-			assert.Emptyf(t, env.tmc.getMaxValueForSequencesRequests, "expected no remaining GetMaxValueForSequences requests")
+			// Expect the queries to be cleared
+			assert.Emptyf(t, env.tmc.vrQueries[100], "expected no queries to be executed, found: %q", env.tmc.vrQueries[100])
+			assert.Empty(t, env.tmc.vrQueries[200], "expected no queries to be executed, found: %q", env.tmc.vrQueries[200])
 		})
 	}
->>>>>>> 81356abde1 (VReplication: Properly Handle Sequence Table Initialization For Empty Tables (#19226))
 }
 
 func TestGetTargetSequenceMetadata(t *testing.T) {