storage: remove MVCCIterator.Key method

pkg/ccl/backupccl/full_cluster_backup_restore_test.go

@@ -220,7 +220,7 @@ CREATE TABLE data2.foo (a int);
 		it.SeekGE(storage.MVCCKey{Key: startKey})
 		hasKey, err := it.Valid()
 		require.NoError(t, err)
-		require.False(t, hasKey, "did not expect to find a key, found %s", it.Key())
+		require.False(t, hasKey, "did not expect to find a key, found %s", it.UnsafeKey())
 	})
 
 	// Allow the restore to make progress after we've checked the pre-restore

pkg/ccl/backupccl/restore_data_processor_test.go

@@ -127,7 +127,7 @@ func slurpSSTablesLatestKey(
 		if err != nil {
 			t.Fatal(err)
 		}
-		kvs = append(kvs, storage.MVCCKeyValue{Key: it.Key(), Value: val.Value.RawBytes})
+		kvs = append(kvs, storage.MVCCKeyValue{Key: it.UnsafeKey().Clone(), Value: val.Value.RawBytes})
 	}
 	return kvs
 }

pkg/ccl/streamingccl/replicationutils/utils.go

@@ -76,7 +76,7 @@ func ScanSST(
 			return err
 		}
 		if err = mvccKeyValOp(storage.MVCCKeyValue{
-			Key:   pointIter.Key(),
+			Key:   pointIter.UnsafeKey().Clone(),
 			Value: v,
 		}); err != nil {
 			return err

pkg/ccl/streamingccl/streamingest/replication_random_client_test.go

@@ -329,18 +329,18 @@ func assertExactlyEqualKVs(
 			}
 			break
 		}
-		if maxKVTimestampSeen.Less(it.Key().Timestamp) {
-			maxKVTimestampSeen = it.Key().Timestamp
+		if maxKVTimestampSeen.Less(it.UnsafeKey().Timestamp) {
+			maxKVTimestampSeen = it.UnsafeKey().Timestamp
 		}
-		newKey := (prevKey != nil && !it.Key().Key.Equal(prevKey)) || prevKey == nil
-		prevKey = it.Key().Key
+		newKey := (prevKey != nil && !it.UnsafeKey().Key.Equal(prevKey)) || prevKey == nil
+		prevKey = it.UnsafeKey().Clone().Key
 
 		if newKey {
 			// All value ts should have been drained at this point, otherwise there is
 			// a mismatch between the streamed and ingested data.
 			require.Equal(t, 0, len(valueTimestampTuples))
 			valueTimestampTuples, err = streamValidator.getValuesForKeyBelowTimestamp(
-				string(it.Key().Key), frontierTimestamp)
+				string(it.UnsafeKey().Key), frontierTimestamp)
 			require.NoError(t, err)
 		}
 
@@ -357,10 +357,10 @@ func assertExactlyEqualKVs(
 		v, err := it.Value()
 		require.NoError(t, err)
 		require.Equal(t, roachpb.KeyValue{
-			Key: it.Key().Key,
+			Key: it.UnsafeKey().Key,
 			Value: roachpb.Value{
 				RawBytes:  v,
-				Timestamp: it.Key().Timestamp,
+				Timestamp: it.UnsafeKey().Timestamp,
 			},
 		}, latestVersionInChain)
 		matchingKVs++

pkg/ccl/streamingccl/streamingest/stream_ingestion_processor_test.go

@@ -385,19 +385,19 @@ func assertEqualKVs(
 
 		// We only want to process MVCC KVs with a ts less than or equal to the max
 		// resolved ts for this partition.
-		if partitionTimestamp.Less(it.Key().Timestamp) {
+		if partitionTimestamp.Less(it.UnsafeKey().Timestamp) {
 			continue
 		}
 
-		newKey := (prevKey != nil && !it.Key().Key.Equal(prevKey)) || prevKey == nil
-		prevKey = it.Key().Key
+		newKey := (prevKey != nil && !it.UnsafeKey().Key.Equal(prevKey)) || prevKey == nil
+		prevKey = it.UnsafeKey().Clone().Key
 
 		if newKey {
 			// All value ts should have been drained at this point, otherwise there is
 			// a mismatch between the streamed and ingested data.
 			require.Equal(t, 0, len(valueTimestampTuples))
 			valueTimestampTuples, err = streamValidator.getValuesForKeyBelowTimestamp(
-				string(it.Key().Key), partitionTimestamp)
+				string(it.UnsafeKey().Key), partitionTimestamp)
 			require.NoError(t, err)
 		}
 
@@ -408,10 +408,10 @@ func assertEqualKVs(
 		v, err := it.Value()
 		require.NoError(t, err)
 		require.Equal(t, roachpb.KeyValue{
-			Key: it.Key().Key,
+			Key: it.UnsafeKey().Key,
 			Value: roachpb.Value{
 				RawBytes:  v,
-				Timestamp: it.Key().Timestamp,
+				Timestamp: it.UnsafeKey().Timestamp,
 			},
 		}, latestVersionInChain)
 		// Truncate the latest version which we just checked against in preparation

pkg/kv/kvnemesis/validator.go

@@ -631,7 +631,7 @@ func (v *validator) processOp(op Operation) {
 					}
 				}
 
-				key := iter.Key().Key
+				key := iter.UnsafeKey().Clone().Key
 				rawValue, err := iter.Value()
 				if err != nil {
 					return err

pkg/kv/kvnemesis/watcher.go

@@ -346,7 +346,7 @@ func (w *Watcher) handleSSTable(ctx context.Context, data []byte) error {
 		}
 
 		// Add point keys.
-		key := iter.Key()
+		key := iter.UnsafeKey().Clone()
 		rawValue, err := iter.Value()
 		if err != nil {
 			return err

pkg/kv/kvserver/batch_spanset_test.go

@@ -171,20 +171,20 @@ func TestSpanSetBatchBoundaries(t *testing.T) {
 		if ok, err := iter.Valid(); !ok || err != nil {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), insideKey) {
-			t.Fatalf("expected key %s, got %s", insideKey, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), insideKey) {
+			t.Fatalf("expected key %s, got %s", insideKey, iter.UnsafeKey())
 		}
 		iter.Next()
 		if ok, err := iter.Valid(); !ok || err != nil {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), insideKey2) {
-			t.Fatalf("expected key %s, got %s", insideKey2, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), insideKey2) {
+			t.Fatalf("expected key %s, got %s", insideKey2, iter.UnsafeKey())
 		}
 		// Scan out of bounds.
 		iter.Next()
 		if ok, err := iter.Valid(); ok {
-			t.Fatalf("expected invalid iterator; found valid at key %s", iter.Key())
+			t.Fatalf("expected invalid iterator; found valid at key %s", iter.UnsafeKey())
 		} else if err != nil {
 			// Scanning out of bounds sets Valid() to false but is not an error.
 			t.Errorf("unexpected error on iterator: %+v", err)
@@ -210,20 +210,20 @@ func TestSpanSetBatchBoundaries(t *testing.T) {
 		if ok, err := iter.Valid(); !ok || err != nil {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), insideKey2) {
-			t.Fatalf("expected key %s, got %s", insideKey2, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), insideKey2) {
+			t.Fatalf("expected key %s, got %s", insideKey2, iter.UnsafeKey())
 		}
 		iter.Prev()
 		if ok, err := iter.Valid(); !ok || err != nil {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), insideKey) {
-			t.Fatalf("expected key %s, got %s", insideKey, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), insideKey) {
+			t.Fatalf("expected key %s, got %s", insideKey, iter.UnsafeKey())
 		}
 		// Scan out of bounds.
 		iter.Prev()
 		if ok, err := iter.Valid(); ok {
-			t.Fatalf("expected invalid iterator; found valid at key %s", iter.Key())
+			t.Fatalf("expected invalid iterator; found valid at key %s", iter.UnsafeKey())
 		} else if err != nil {
 			t.Errorf("unexpected error on iterator: %+v", err)
 		}
@@ -236,7 +236,7 @@ func TestSpanSetBatchBoundaries(t *testing.T) {
 		// SeekLT to the lower bound is invalid.
 		iter.SeekLT(insideKey)
 		if ok, err := iter.Valid(); ok {
-			t.Fatalf("expected invalid iterator; found valid at key %s", iter.Key())
+			t.Fatalf("expected invalid iterator; found valid at key %s", iter.UnsafeKey())
 		} else if !isReadSpanErr(err) {
 			t.Fatalf("SeekLT: unexpected error %v", err)
 		}
@@ -390,16 +390,16 @@ func TestSpanSetIteratorTimestamps(t *testing.T) {
 		if ok, err := iter.Valid(); !ok {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), k1) {
-			t.Fatalf("expected key %s, got %s", k1, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), k1) {
+			t.Fatalf("expected key %s, got %s", k1, iter.UnsafeKey())
 		}
 
 		iter.Next()
 		if ok, err := iter.Valid(); !ok {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), k2) {
-			t.Fatalf("expected key %s, got %s", k2, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), k2) {
+			t.Fatalf("expected key %s, got %s", k2, iter.UnsafeKey())
 		}
 	}()
 
@@ -410,15 +410,15 @@ func TestSpanSetIteratorTimestamps(t *testing.T) {
 
 		iter.SeekGE(k1)
 		if ok, _ := iter.Valid(); ok {
-			t.Fatalf("expected invalid iterator; found valid at key %s", iter.Key())
+			t.Fatalf("expected invalid iterator; found valid at key %s", iter.UnsafeKey())
 		}
 
 		iter.SeekGE(k2)
 		if ok, err := iter.Valid(); !ok {
 			t.Fatalf("expected valid iterator, err=%v", err)
 		}
-		if !reflect.DeepEqual(iter.Key(), k2) {
-			t.Fatalf("expected key %s, got %s", k2, iter.Key())
+		if !reflect.DeepEqual(iter.UnsafeKey(), k2) {
+			t.Fatalf("expected key %s, got %s", k2, iter.UnsafeKey())
 		}
 	}()
 
@@ -430,12 +430,12 @@ func TestSpanSetIteratorTimestamps(t *testing.T) {
 
 		iter.SeekGE(k1)
 		if ok, _ := iter.Valid(); ok {
-			t.Fatalf("expected invalid iterator; found valid at key %s", iter.Key())
+			t.Fatalf("expected invalid iterator; found valid at key %s", iter.UnsafeKey())
 		}
 
 		iter.SeekGE(k2)
 		if ok, _ := iter.Valid(); ok {
-			t.Fatalf("expected invalid iterator; found valid at key %s", iter.Key())
+			t.Fatalf("expected invalid iterator; found valid at key %s", iter.UnsafeKey())
 		}
 	}
 

pkg/kv/kvserver/batcheval/cmd_add_sstable.go

@@ -388,7 +388,7 @@ func EvalAddSSTable(
 		if ok, err := existingIter.Valid(); err != nil {
 			return result.Result{}, errors.Wrap(err, "error while searching for non-empty span start")
 		} else if ok {
-			reply.FollowingLikelyNonEmptySpanStart = existingIter.Key().Key
+			reply.FollowingLikelyNonEmptySpanStart = existingIter.UnsafeKey().Key.Clone()
 		}
 	}
 

pkg/kv/kvserver/client_split_test.go

@@ -393,9 +393,9 @@ func TestStoreRangeSplitIntents(t *testing.T) {
 			break
 		}
 
-		if bytes.HasPrefix([]byte(iter.Key().Key), txnPrefix(roachpb.KeyMin)) ||
-			bytes.HasPrefix([]byte(iter.Key().Key), txnPrefix(splitKey)) {
-			t.Errorf("unexpected system key: %s; txn record should have been cleaned up", iter.Key())
+		if bytes.HasPrefix([]byte(iter.UnsafeKey().Key), txnPrefix(roachpb.KeyMin)) ||
+			bytes.HasPrefix([]byte(iter.UnsafeKey().Key), txnPrefix(splitKey)) {
+			t.Errorf("unexpected system key: %s; txn record should have been cleaned up", iter.UnsafeKey())
 		}
 	}
 }

pkg/kv/kvserver/gc/gc_old_test.go

@@ -187,13 +187,13 @@ func runGCOld(
 			// Stop iterating if our context has expired.
 			return Info{}, err
 		}
-		iterKey := iter.Key()
+		iterKey := iter.UnsafeKey().Clone()
 		if !iterKey.IsValue() || !iterKey.Key.Equal(expBaseKey) {
 			// Moving to the next key (& values).
 			processKeysAndValues()
 			expBaseKey = iterKey.Key
 			if !iterKey.IsValue() {
-				keys = []storage.MVCCKey{iter.Key()}
+				keys = []storage.MVCCKey{iter.UnsafeKey().Clone()}
 				v, err := iter.Value()
 				if err != nil {
 					return Info{}, err
@@ -212,7 +212,7 @@ func runGCOld(
 		if err != nil {
 			return Info{}, err
 		}
-		keys = append(keys, iter.Key())
+		keys = append(keys, iter.UnsafeKey().Clone())
 		vals = append(vals, v)
 	}
 	// Handle last collected set of keys/vals.

pkg/kv/kvserver/gc/gc_random_test.go

@@ -495,7 +495,7 @@ func getExpectationsGenerator(
 				}
 				p, r := it.HasPointAndRange()
 				if p {
-					k := it.Key()
+					k := it.UnsafeKey().Clone()
 					v, err := it.Value()
 					require.NoError(t, err)
 					if len(baseKey) == 0 {

pkg/kv/kvserver/gc/gc_test.go

@@ -1534,7 +1534,7 @@ func engineData(t *testing.T, r storage.Reader, desc roachpb.RangeDescriptor) []
 				v = prefix + string(b)
 			}
 			result = append(result, tableCell{
-				key:   it.Key(),
+				key:   it.UnsafeKey().Clone(),
 				value: v,
 			})
 			prefix = ""

pkg/kv/kvserver/loqrecovery/record.go

@@ -97,7 +97,7 @@ func RegisterOfflineRecoveryEvents(
 		record := loqrecoverypb.ReplicaRecoveryRecord{}
 		if err := iter.ValueProto(&record); err != nil {
 			processingErrors = errors.CombineErrors(processingErrors, errors.Wrapf(err,
-				"failed to deserialize replica recovery event at key %s", iter.Key()))
+				"failed to deserialize replica recovery event at key %s", iter.UnsafeKey()))
 			continue
 		}
 		removeEvent, err := registerEvent(ctx, record)
@@ -109,7 +109,7 @@ func RegisterOfflineRecoveryEvents(
 		if removeEvent {
 			if err := readWriter.ClearUnversioned(iter.UnsafeKey().Key); err != nil {
 				processingErrors = errors.CombineErrors(processingErrors, errors.Wrapf(
-					err, "failed to delete replica recovery record at key %s", iter.Key()))
+					err, "failed to delete replica recovery record at key %s", iter.UnsafeKey()))
 				continue
 			}
 		}

pkg/kv/kvserver/raft_log_truncator_test.go

@@ -208,7 +208,7 @@ func (r *replicaTruncatorTest) printEngine(t *testing.T, eng storage.Engine) {
 	fmt.Fprintf(r.buf, "log entries:")
 	printPrefixStr := ""
 	for valid {
-		key := iter.Key()
+		key := iter.UnsafeKey()
 		_, index, err := encoding.DecodeUint64Ascending(key.Key[len(prefix):])
 		require.NoError(t, err)
 		fmt.Fprintf(r.buf, "%s %d", printPrefixStr, index)

pkg/kv/kvserver/rditer/replica_data_iter.go

@@ -256,11 +256,6 @@ func (ri *ReplicaMVCCDataIterator) Valid() (bool, error) {
 	return true, nil
 }
 
-// Key returns the current key. Only called in tests.
-func (ri *ReplicaMVCCDataIterator) Key() storage.MVCCKey {
-	return ri.it.Key()
-}
-
 // Value returns the current value. Only called in tests.
 func (ri *ReplicaMVCCDataIterator) Value() ([]byte, error) {
 	return ri.it.Value()

pkg/kv/kvserver/rditer/replica_data_iter_test.go

@@ -349,9 +349,9 @@ func TestIterateMVCCReplicaKeySpansSpansSet(t *testing.T) {
 				p, r := iter.HasPointAndRange()
 				if p {
 					if !reverse {
-						actualKeys = append(actualKeys, iter.Key())
+						actualKeys = append(actualKeys, iter.UnsafeKey().Clone())
 					} else {
-						actualKeys = append([]storage.MVCCKey{iter.Key()}, actualKeys...)
+						actualKeys = append([]storage.MVCCKey{iter.UnsafeKey().Clone()}, actualKeys...)
 					}
 				}
 				if r {

pkg/kv/kvserver/replica_evaluate.go

@@ -115,8 +115,8 @@ func optimizePuts(
 		// running without the optimization?
 		log.Errorf(context.TODO(), "Seek returned error; disabling blind-put optimization: %+v", err)
 		return origReqs
-	} else if ok && bytes.Compare(iter.Key().Key, maxKey) <= 0 {
-		iterKey = iter.Key().Key
+	} else if ok && bytes.Compare(iter.UnsafeKey().Key, maxKey) <= 0 {
+		iterKey = iter.UnsafeKey().Key.Clone()
 	}
 	// Set the prefix of the run which is being written to virgin
 	// keyspace to "blindly" put values.

pkg/kv/kvserver/spanset/batch.go

@@ -159,11 +159,6 @@ func (i *MVCCIterator) checkAllowedValidPos(span roachpb.Span, errIfDisallowed b
 	}
 }
 
-// Key is part of the storage.MVCCIterator interface.
-func (i *MVCCIterator) Key() storage.MVCCKey {
-	return i.i.Key()
-}
-
 // Value is part of the storage.MVCCIterator interface.
 func (i *MVCCIterator) Value() ([]byte, error) {
 	return i.i.Value()

pkg/sql/catalog/lease/kv_writer_test.go

@@ -157,7 +157,7 @@ func getRawHistoryKVs(
 				} else if !ok {
 					return nil
 				}
-				k := it.Key()
+				k := it.UnsafeKey().Clone()
 				suffix, _, err := codec.DecodeTablePrefix(k.Key)
 				require.NoError(t, err)
 				v, err := it.Value()

pkg/sql/row/fetcher_mvcc_test.go

@@ -63,7 +63,7 @@ func slurpUserDataKVs(t testing.TB, e storage.Engine) []roachpb.KeyValue {
 			}
 			value := mvccValue.Value
 			value.Timestamp = it.UnsafeKey().Timestamp
-			kv := roachpb.KeyValue{Key: it.Key().Key, Value: value}
+			kv := roachpb.KeyValue{Key: it.UnsafeKey().Key.Clone(), Value: value}
 			kvs = append(kvs, kv)
 		}
 		return nil