From ee391b7545109ab7ca5362947b23a976d2dea416 Mon Sep 17 00:00:00 2001 From: Steven Danna Date: Thu, 30 Jan 2025 16:58:47 +0000 Subject: [PATCH] storage: pass TxnMeta to MVCCAcquireLock This passes the TxnMeta and IgnoredSeqNums as separate arguments. This is in advance of a potential new user of the API and helps ensure we don't add more dependencies on data not in the TxnMeta. Informs #139141 Release note: None --- .../cmd_query_resolved_timestamp_test.go | 2 +- pkg/kv/kvserver/batcheval/lock.go | 2 +- pkg/kv/kvserver/batcheval/lock_test.go | 4 +-- pkg/kv/kvserver/gc/gc_test.go | 8 ++--- pkg/kv/kvserver/rangefeed/task_test.go | 2 +- pkg/kv/kvserver/replica_consistency_test.go | 2 +- pkg/storage/bench_test.go | 6 ++-- pkg/storage/engine_test.go | 36 +++++++++---------- pkg/storage/metamorphic/operations.go | 2 +- pkg/storage/mvcc.go | 9 ++--- pkg/storage/mvcc_history_test.go | 8 ++++- pkg/storage/mvcc_stats_test.go | 8 ++++- pkg/storage/mvcc_test.go | 2 +- pkg/storage/sst_test.go | 2 +- 14 files changed, 53 insertions(+), 40 deletions(-) diff --git a/pkg/kv/kvserver/batcheval/cmd_query_resolved_timestamp_test.go b/pkg/kv/kvserver/batcheval/cmd_query_resolved_timestamp_test.go index a3b45971d0ff..7876e46ae52a 100644 --- a/pkg/kv/kvserver/batcheval/cmd_query_resolved_timestamp_test.go +++ b/pkg/kv/kvserver/batcheval/cmd_query_resolved_timestamp_test.go @@ -53,7 +53,7 @@ func TestQueryResolvedTimestamp(t *testing.T) { } writeLock := func(k string, str lock.Strength) { txn := roachpb.MakeTransaction("test", roachpb.Key(k), 0, 0, makeTS(1), 0, 1, 0, false /* omitInRangefeeds */) - err := storage.MVCCAcquireLock(ctx, db, &txn, str, roachpb.Key(k), nil, 0, 0) + err := storage.MVCCAcquireLock(ctx, db, &txn.TxnMeta, txn.IgnoredSeqNums, str, roachpb.Key(k), nil, 0, 0) require.NoError(t, err) } diff --git a/pkg/kv/kvserver/batcheval/lock.go b/pkg/kv/kvserver/batcheval/lock.go index e4271f53aada..3f1196064d1a 100644 --- a/pkg/kv/kvserver/batcheval/lock.go +++ b/pkg/kv/kvserver/batcheval/lock.go @@ -233,7 +233,7 @@ func acquireLockOnKey( // conflicts with un-contended replicated locks -- we need to do so before // we can acquire our own replicated lock; do that now, and also acquire // the replicated lock if no conflicts are found. - if err := storage.MVCCAcquireLock(ctx, readWriter, txn, str, key, ms, maxLockConflicts, targetLockConflictBytes); err != nil { + if err := storage.MVCCAcquireLock(ctx, readWriter, &txn.TxnMeta, txn.IgnoredSeqNums, str, key, ms, maxLockConflicts, targetLockConflictBytes); err != nil { return roachpb.LockAcquisition{}, err } default: diff --git a/pkg/kv/kvserver/batcheval/lock_test.go b/pkg/kv/kvserver/batcheval/lock_test.go index 59653d330729..6128cdc9872e 100644 --- a/pkg/kv/kvserver/batcheval/lock_test.go +++ b/pkg/kv/kvserver/batcheval/lock_test.go @@ -195,9 +195,9 @@ func TestTxnBoundReplicatedLockTableView(t *testing.T) { txn2 := roachpb.MakeTransaction("txn2", keyA, isolation.Serializable, roachpb.NormalUserPriority, makeTS(100, 0), 0, 0, 0, false) // Have txn1 acquire 2 locks with different strengths. - err = storage.MVCCAcquireLock(ctx, engine, &txn1, lock.Exclusive, keyA, nil, 0, 0) + err = storage.MVCCAcquireLock(ctx, engine, &txn1.TxnMeta, txn1.IgnoredSeqNums, lock.Exclusive, keyA, nil, 0, 0) require.NoError(t, err) - err = storage.MVCCAcquireLock(ctx, engine, &txn1, lock.Shared, keyB, nil, 0, 0) + err = storage.MVCCAcquireLock(ctx, engine, &txn1.TxnMeta, txn1.IgnoredSeqNums, lock.Shared, keyB, nil, 0, 0) require.NoError(t, err) reader := engine.NewReader(storage.StandardDurability) diff --git a/pkg/kv/kvserver/gc/gc_test.go b/pkg/kv/kvserver/gc/gc_test.go index 31b4e10eec54..12691978cdac 100644 --- a/pkg/kv/kvserver/gc/gc_test.go +++ b/pkg/kv/kvserver/gc/gc_test.go @@ -148,9 +148,9 @@ func TestLockAgeThresholdSetting(t *testing.T) { require.NoError(t, err) // Acquire some shared and exclusive locks as well. for _, txn := range []*roachpb.Transaction{&txn1, &txn2} { - require.NoError(t, storage.MVCCAcquireLock(ctx, eng, txn, lock.Shared, makeKey(local, lock.Shared), nil, 0, 0)) + require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn.TxnMeta, txn.IgnoredSeqNums, lock.Shared, makeKey(local, lock.Shared), nil, 0, 0)) } - require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn1, lock.Exclusive, makeKey(local, lock.Exclusive), nil, 0, 0)) + require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn1.TxnMeta, txn1.IgnoredSeqNums, lock.Exclusive, makeKey(local, lock.Exclusive), nil, 0, 0)) } require.NoError(t, eng.Flush()) @@ -217,9 +217,9 @@ func TestIntentCleanupBatching(t *testing.T) { idx := i*len(objectKeys) + j switch idx % 3 { case 0: - require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn, lock.Shared, key, nil, 0, 0)) + require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn.TxnMeta, txn.IgnoredSeqNums, lock.Shared, key, nil, 0, 0)) case 1: - require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn, lock.Exclusive, key, nil, 0, 0)) + require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn.TxnMeta, txn.IgnoredSeqNums, lock.Exclusive, key, nil, 0, 0)) case 2: _, err := storage.MVCCPut(ctx, eng, key, intentHlc, value, storage.MVCCWriteOptions{Txn: &txn}) require.NoError(t, err) diff --git a/pkg/kv/kvserver/rangefeed/task_test.go b/pkg/kv/kvserver/rangefeed/task_test.go index 80fa3759fe99..2d60aa75b1f8 100644 --- a/pkg/kv/kvserver/rangefeed/task_test.go +++ b/pkg/kv/kvserver/rangefeed/task_test.go @@ -311,7 +311,7 @@ func TestInitResolvedTSScan(t *testing.T) { roachpb.MakeLock(&txn1.TxnMeta, roachpb.Key("p"), lock.Exclusive), } for _, l := range testLocks { - err := storage.MVCCAcquireLock(ctx, engine, &txn1, l.Strength, l.Key, nil, 0, 0) + err := storage.MVCCAcquireLock(ctx, engine, &txn1.TxnMeta, txn1.IgnoredSeqNums, l.Strength, l.Key, nil, 0, 0) require.NoError(t, err) } return engine diff --git a/pkg/kv/kvserver/replica_consistency_test.go b/pkg/kv/kvserver/replica_consistency_test.go index c03ef7529082..5ef881561a2b 100644 --- a/pkg/kv/kvserver/replica_consistency_test.go +++ b/pkg/kv/kvserver/replica_consistency_test.go @@ -328,7 +328,7 @@ func TestReplicaChecksumSHA512(t *testing.T) { for i, l := range locks { txnID := uuid.FromUint128(uint128.FromInts(0, uint64(l.txnID))) txn := &roachpb.Transaction{TxnMeta: enginepb.TxnMeta{ID: txnID}} - require.NoError(t, storage.MVCCAcquireLock(ctx, eng, txn, l.str, roachpb.Key(l.key), nil, 0, 0)) + require.NoError(t, storage.MVCCAcquireLock(ctx, eng, &txn.TxnMeta, txn.IgnoredSeqNums, l.str, roachpb.Key(l.key), nil, 0, 0)) rd, err = CalcReplicaDigest(ctx, desc, eng, kvpb.ChecksumMode_CHECK_FULL, unlim, nil /* settings */) require.NoError(t, err) diff --git a/pkg/storage/bench_test.go b/pkg/storage/bench_test.go index e85e0191d914..f2a233073c6f 100644 --- a/pkg/storage/bench_test.go +++ b/pkg/storage/bench_test.go @@ -2004,11 +2004,11 @@ func runMVCCAcquireLockCommon( txn = &txn2 } // Acquire a shared and an exclusive lock on the key. - err := MVCCAcquireLock(ctx, eng, txn, lock.Shared, key, nil, 0, 0) + err := MVCCAcquireLock(ctx, eng, &txn.TxnMeta, txn.IgnoredSeqNums, lock.Shared, key, nil, 0, 0) if err != nil { b.Fatal(err) } - err = MVCCAcquireLock(ctx, eng, txn, lock.Exclusive, key, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn.TxnMeta, txn.IgnoredSeqNums, lock.Exclusive, key, nil, 0, 0) if err != nil { b.Fatal(err) } @@ -2032,7 +2032,7 @@ func runMVCCAcquireLockCommon( if checkFor { err = MVCCCheckForAcquireLock(ctx, rw, txn, strength, key, 0, 0) } else { - err = MVCCAcquireLock(ctx, rw, txn, strength, key, ms, 0, 0) + err = MVCCAcquireLock(ctx, rw, &txn.TxnMeta, txn.IgnoredSeqNums, strength, key, ms, 0, 0) } if heldOtherTxn { if err == nil { diff --git a/pkg/storage/engine_test.go b/pkg/storage/engine_test.go index 7d68b707acc2..591dfb7cab62 100644 --- a/pkg/storage/engine_test.go +++ b/pkg/storage/engine_test.go @@ -1533,9 +1533,9 @@ func TestGetIntent(t *testing.T) { // Key "b" has an intent, an exclusive lock, and a shared lock from txn1. // NOTE: acquire in increasing strength order so that acquisition is never // skipped. - err = MVCCAcquireLock(ctx, eng, txn1, lock.Shared, keyB, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn1.TxnMeta, txn1.IgnoredSeqNums, lock.Shared, keyB, nil, 0, 0) require.NoError(t, err) - err = MVCCAcquireLock(ctx, eng, txn1, lock.Exclusive, keyB, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn1.TxnMeta, txn1.IgnoredSeqNums, lock.Exclusive, keyB, nil, 0, 0) require.NoError(t, err) _, err = MVCCPut(ctx, eng, keyB, txn1.ReadTimestamp, val, MVCCWriteOptions{Txn: txn1}) require.NoError(t, err) @@ -1545,15 +1545,15 @@ func TestGetIntent(t *testing.T) { require.NoError(t, err) // Key "d" has an exclusive lock and a shared lock from txn2. - err = MVCCAcquireLock(ctx, eng, txn2, lock.Shared, keyD, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn2.TxnMeta, txn2.IgnoredSeqNums, lock.Shared, keyD, nil, 0, 0) require.NoError(t, err) - err = MVCCAcquireLock(ctx, eng, txn2, lock.Exclusive, keyD, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn2.TxnMeta, txn2.IgnoredSeqNums, lock.Exclusive, keyD, nil, 0, 0) require.NoError(t, err) // Key "e" has a shared lock from each txn. - err = MVCCAcquireLock(ctx, eng, txn1, lock.Shared, keyE, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn1.TxnMeta, txn1.IgnoredSeqNums, lock.Shared, keyE, nil, 0, 0) require.NoError(t, err) - err = MVCCAcquireLock(ctx, eng, txn2, lock.Shared, keyE, nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn2.TxnMeta, txn2.IgnoredSeqNums, lock.Shared, keyE, nil, 0, 0) require.NoError(t, err) // Key "f" has no intent/locks. @@ -1641,7 +1641,7 @@ func TestScanLocks(t *testing.T) { if str == lock.Intent { _, err = MVCCPut(ctx, eng, roachpb.Key(k), txn1.ReadTimestamp, roachpb.Value{RawBytes: roachpb.Key(k)}, MVCCWriteOptions{Txn: txn1}) } else { - err = MVCCAcquireLock(ctx, eng, txn1, str, roachpb.Key(k), nil, 0, 0) + err = MVCCAcquireLock(ctx, eng, &txn1.TxnMeta, txn1.IgnoredSeqNums, str, roachpb.Key(k), nil, 0, 0) } require.NoError(t, err) } @@ -2234,11 +2234,11 @@ func TestScanConflictingIntentsForDroppingLatchesEarly(t *testing.T) { setup: func(t *testing.T, rw ReadWriter, _ *roachpb.Transaction) { txnA := newTxn(belowTxnTS) txnB := newTxn(belowTxnTS) - err := MVCCAcquireLock(ctx, rw, txnA, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err := MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnB, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnB.TxnMeta, txnB.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnA, lock.Exclusive, keyB, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Exclusive, keyB, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) }, start: keyA, @@ -2252,9 +2252,9 @@ func TestScanConflictingIntentsForDroppingLatchesEarly(t *testing.T) { name: "shared and exclusive locks should be ignored no end key", setup: func(t *testing.T, rw ReadWriter, _ *roachpb.Transaction) { txnA := newTxn(belowTxnTS) - err := MVCCAcquireLock(ctx, rw, txnA, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err := MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnA, lock.Exclusive, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Exclusive, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) }, start: keyA, @@ -2267,11 +2267,11 @@ func TestScanConflictingIntentsForDroppingLatchesEarly(t *testing.T) { setup: func(t *testing.T, rw ReadWriter, _ *roachpb.Transaction) { txnA := newTxn(belowTxnTS) txnB := newTxn(belowTxnTS) - err := MVCCAcquireLock(ctx, rw, txnA, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err := MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnB, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnB.TxnMeta, txnB.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnA, lock.Exclusive, keyB, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Exclusive, keyB, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) require.NoError(t, err) _, err = MVCCPut(ctx, rw, keyC, txnA.WriteTimestamp, val, MVCCWriteOptions{Txn: txnA}) @@ -2287,11 +2287,11 @@ func TestScanConflictingIntentsForDroppingLatchesEarly(t *testing.T) { setup: func(t *testing.T, rw ReadWriter, txn *roachpb.Transaction) { txnA := newTxn(belowTxnTS) txnB := newTxn(belowTxnTS) - err := MVCCAcquireLock(ctx, rw, txnA, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err := MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnB, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnB.TxnMeta, txnB.IgnoredSeqNums, lock.Shared, keyA, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) - err = MVCCAcquireLock(ctx, rw, txnA, lock.Exclusive, keyB, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) + err = MVCCAcquireLock(ctx, rw, &txnA.TxnMeta, txnA.IgnoredSeqNums, lock.Exclusive, keyB, nil /*ms*/, 0 /*maxConflicts*/, 0 /*targetLockConflictBytes*/) require.NoError(t, err) _, err = MVCCPut(ctx, rw, keyC, txn.WriteTimestamp, val, MVCCWriteOptions{Txn: txn}) require.NoError(t, err) diff --git a/pkg/storage/metamorphic/operations.go b/pkg/storage/metamorphic/operations.go index c898ce308a5c..bbf44a367207 100644 --- a/pkg/storage/metamorphic/operations.go +++ b/pkg/storage/metamorphic/operations.go @@ -316,7 +316,7 @@ func (m mvccAcquireLockOp) run(ctx context.Context) string { txn := m.m.getTxn(m.txn) writer := m.m.getReadWriter(m.writer) - err := storage.MVCCAcquireLock(ctx, writer, txn, m.strength, m.key, nil, int64(m.maxLockConflicts), m.targetLockConflictBytes) + err := storage.MVCCAcquireLock(ctx, writer, &txn.TxnMeta, txn.IgnoredSeqNums, m.strength, m.key, nil, int64(m.maxLockConflicts), m.targetLockConflictBytes) if err != nil { return fmt.Sprintf("error: %s", err) } diff --git a/pkg/storage/mvcc.go b/pkg/storage/mvcc.go index 0edcee77dc25..5889d8b48127 100644 --- a/pkg/storage/mvcc.go +++ b/pkg/storage/mvcc.go @@ -6063,7 +6063,8 @@ func MVCCCheckForAcquireLock( func MVCCAcquireLock( ctx context.Context, rw ReadWriter, - txn *roachpb.Transaction, + txn *enginepb.TxnMeta, + ignoredSeqNums []enginepb.IgnoredSeqNumRange, str lock.Strength, key roachpb.Key, ms *enginepb.MVCCStats, @@ -6135,7 +6136,7 @@ func MVCCAcquireLock( "cannot acquire lock with strength %s at seq number %d, "+ "already held at higher seq number %d", str.String(), txn.Sequence, foundLock.Txn.Sequence) - } else if enginepb.TxnSeqIsIgnored(foundLock.Txn.Sequence, txn.IgnoredSeqNums) { + } else if enginepb.TxnSeqIsIgnored(foundLock.Txn.Sequence, ignoredSeqNums) { // Acquiring at same epoch and new sequence number after // previous sequence number was rolled back. // @@ -6161,7 +6162,7 @@ func MVCCAcquireLock( // can still avoid reacquisition. inHistoryNotRolledBack := false for _, e := range foundLock.IntentHistory { - if !enginepb.TxnSeqIsIgnored(e.Sequence, txn.IgnoredSeqNums) { + if !enginepb.TxnSeqIsIgnored(e.Sequence, ignoredSeqNums) { inHistoryNotRolledBack = true break } @@ -6194,7 +6195,7 @@ func MVCCAcquireLock( defer buf.release() newMeta := &buf.newMeta - newMeta.Txn = &txn.TxnMeta + newMeta.Txn = txn newMeta.Timestamp = txn.WriteTimestamp.ToLegacyTimestamp() keyBytes, valBytes, err := buf.putLockMeta(rw, key, str, newMeta, rolledBack) if err != nil { diff --git a/pkg/storage/mvcc_history_test.go b/pkg/storage/mvcc_history_test.go index f5b2f0cff978..c33010988d6e 100644 --- a/pkg/storage/mvcc_history_test.go +++ b/pkg/storage/mvcc_history_test.go @@ -1183,7 +1183,13 @@ func cmdAcquireLock(e *evalCtx) error { str := e.getStrength() maxLockConflicts := e.getMaxLockConflicts() targetLockConflictBytes := e.getTargetLockConflictBytes() - return storage.MVCCAcquireLock(e.ctx, rw, txn, str, key, e.ms, maxLockConflicts, targetLockConflictBytes) + var txnMeta *enginepb.TxnMeta + var ignoredSeq []enginepb.IgnoredSeqNumRange + if txn != nil { + txnMeta = &txn.TxnMeta + ignoredSeq = txn.IgnoredSeqNums + } + return storage.MVCCAcquireLock(e.ctx, rw, txnMeta, ignoredSeq, str, key, e.ms, maxLockConflicts, targetLockConflictBytes) }) } diff --git a/pkg/storage/mvcc_stats_test.go b/pkg/storage/mvcc_stats_test.go index 5650c68257a6..ff99cbee5cf3 100644 --- a/pkg/storage/mvcc_stats_test.go +++ b/pkg/storage/mvcc_stats_test.go @@ -2055,7 +2055,13 @@ func TestMVCCStatsRandomized(t *testing.T) { if s.rng.Intn(2) != 0 { str = lock.Exclusive } - if err := MVCCAcquireLock(ctx, s.batch, s.Txn, str, s.key, s.MSDelta, 0, 0); err != nil { + var txnMeta *enginepb.TxnMeta + var ignoredSeq []enginepb.IgnoredSeqNumRange + if s.Txn != nil { + txnMeta = &s.Txn.TxnMeta + ignoredSeq = s.Txn.IgnoredSeqNums + } + if err := MVCCAcquireLock(ctx, s.batch, txnMeta, ignoredSeq, str, s.key, s.MSDelta, 0, 0); err != nil { return false, err.Error() } return true, "" diff --git a/pkg/storage/mvcc_test.go b/pkg/storage/mvcc_test.go index 15e8f52c71ba..992b4dd7ca5c 100644 --- a/pkg/storage/mvcc_test.go +++ b/pkg/storage/mvcc_test.go @@ -2206,7 +2206,7 @@ func TestMVCCClearTimeRange(t *testing.T) { // Add a shared lock at k1 with a txn at ts3. addLock := func(t *testing.T, rw ReadWriter) { - err := MVCCAcquireLock(ctx, rw, &txn, lock.Shared, testKey1, nil, 0, 0) + err := MVCCAcquireLock(ctx, rw, &txn.TxnMeta, txn.IgnoredSeqNums, lock.Shared, testKey1, nil, 0, 0) require.NoError(t, err) } t.Run("clear everything hitting lock fails", func(t *testing.T) { diff --git a/pkg/storage/sst_test.go b/pkg/storage/sst_test.go index e45f6763a97f..cc1db725b10b 100644 --- a/pkg/storage/sst_test.go +++ b/pkg/storage/sst_test.go @@ -90,7 +90,7 @@ func TestCheckSSTConflictsMaxLockConflicts(t *testing.T) { if i%2 != 0 { str = lock.Exclusive } - require.NoError(t, MVCCAcquireLock(ctx, batch, txn1, str, roachpb.Key(key), nil, 0, 0)) + require.NoError(t, MVCCAcquireLock(ctx, batch, &txn1.TxnMeta, txn1.IgnoredSeqNums, str, roachpb.Key(key), nil, 0, 0)) } require.NoError(t, batch.Commit(true)) batch.Close()