func runMVCCConditionalPut(emk engineMaker, valueSize int, createFirst bool, b *testing.B) { rng, _ := randutil.NewPseudoRand() value := roachpb.MakeValueFromBytes(randutil.RandBytes(rng, valueSize)) keyBuf := append(make([]byte, 0, 64), []byte("key-")...) eng := emk(b, fmt.Sprintf("cput_%d", valueSize)) defer eng.Close() b.SetBytes(int64(valueSize)) var expected *roachpb.Value if createFirst { for i := 0; i < b.N; i++ { key := roachpb.Key(encoding.EncodeUvarintAscending(keyBuf[:4], uint64(i))) ts := makeTS(timeutil.Now().UnixNano(), 0) if err := MVCCPut(context.Background(), eng, nil, key, ts, value, nil); err != nil { b.Fatalf("failed put: %s", err) } } expected = &value } b.ResetTimer() for i := 0; i < b.N; i++ { key := roachpb.Key(encoding.EncodeUvarintAscending(keyBuf[:4], uint64(i))) ts := makeTS(timeutil.Now().UnixNano(), 0) if err := MVCCConditionalPut(context.Background(), eng, nil, key, ts, value, expected, nil); err != nil { b.Fatalf("failed put: %s", err) } } b.StopTimer() }
func runBatchApplyBatchRepr( emk engineMaker, writeOnly bool, valueSize, batchSize int, b *testing.B, ) { rng, _ := randutil.NewPseudoRand() value := roachpb.MakeValueFromBytes(randutil.RandBytes(rng, valueSize)) keyBuf := append(make([]byte, 0, 64), []byte("key-")...) eng := emk(b, fmt.Sprintf("batch_apply_batch_repr_%d_%d", valueSize, batchSize)) defer eng.Close() var repr []byte { batch := eng.NewBatch() for i := 0; i < batchSize; i++ { key := roachpb.Key(encoding.EncodeUvarintAscending(keyBuf[:4], uint64(i))) ts := makeTS(timeutil.Now().UnixNano(), 0) if err := MVCCPut(context.Background(), batch, nil, key, ts, value, nil); err != nil { b.Fatal(err) } } repr = batch.Repr() batch.Close() } b.SetBytes(int64(len(repr))) b.ResetTimer() for i := 0; i < b.N; i++ { var batch Batch if writeOnly { batch = eng.NewWriteOnlyBatch() } else { batch = eng.NewBatch() } if err := batch.ApplyBatchRepr(repr); err != nil { b.Fatal(err) } batch.Close() } b.StopTimer() }
func BenchmarkMVCCPutDelete_RocksDB(b *testing.B) { rocksdb := setupMVCCInMemRocksDB(b, "put_delete") defer rocksdb.Close() r := rand.New(rand.NewSource(int64(timeutil.Now().UnixNano()))) value := roachpb.MakeValueFromBytes(randutil.RandBytes(r, 10)) zeroTS := hlc.ZeroTimestamp var blockNum int64 for i := 0; i < b.N; i++ { blockID := r.Int63() blockNum++ key := encoding.EncodeVarintAscending(nil, blockID) key = encoding.EncodeVarintAscending(key, blockNum) if err := MVCCPut(context.Background(), rocksdb, nil, key, zeroTS, value, nil /* txn */); err != nil { b.Fatal(err) } if err := MVCCDelete(context.Background(), rocksdb, nil, key, zeroTS, nil /* txn */); err != nil { b.Fatal(err) } } }
func runMVCCBatchPut(emk engineMaker, valueSize, batchSize int, b *testing.B) { rng, _ := randutil.NewPseudoRand() value := roachpb.MakeValueFromBytes(randutil.RandBytes(rng, valueSize)) keyBuf := append(make([]byte, 0, 64), []byte("key-")...) eng := emk(b, fmt.Sprintf("batch_put_%d_%d", valueSize, batchSize)) defer eng.Close() b.SetBytes(int64(valueSize)) b.ResetTimer() for i := 0; i < b.N; i += batchSize { end := i + batchSize if end > b.N { end = b.N } batch := eng.NewBatch() for j := i; j < end; j++ { key := roachpb.Key(encoding.EncodeUvarintAscending(keyBuf[:4], uint64(j))) ts := makeTS(timeutil.Now().UnixNano(), 0) if err := MVCCPut(context.Background(), batch, nil, key, ts, value, nil); err != nil { b.Fatalf("failed put: %s", err) } } if err := batch.Commit(); err != nil { b.Fatal(err) } batch.Close() } b.StopTimer() }
// setupMVCCData writes up to numVersions values at each of numKeys // keys. The number of versions written for each key is chosen // randomly according to a uniform distribution. Each successive // version is written starting at 5ns and then in 5ns increments. This // allows scans at various times, starting at t=5ns, and continuing to // t=5ns*(numVersions+1). A version for each key will be read on every // such scan, but the dynamics of the scan will change depending on // the historical timestamp. Earlier timestamps mean scans which must // skip more historical versions; later timestamps mean scans which // skip fewer. // // The creation of the database is time consuming, especially for larger // numbers of versions. The database is persisted between runs and stored in // the current directory as "mvcc_scan_<versions>_<keys>_<valueBytes>" (which // is also returned). func setupMVCCData( emk engineMaker, numVersions, numKeys, valueBytes int, b *testing.B, ) (Engine, string) { loc := fmt.Sprintf("mvcc_data_%d_%d_%d", numVersions, numKeys, valueBytes) exists := true if _, err := os.Stat(loc); os.IsNotExist(err) { exists = false } eng := emk(b, loc) if exists { readAllFiles(filepath.Join(loc, "*")) return eng, loc } log.Infof(context.Background(), "creating mvcc data: %s", loc) // Generate the same data every time. rng := rand.New(rand.NewSource(1449168817)) keys := make([]roachpb.Key, numKeys) var order []int for i := 0; i < numKeys; i++ { keys[i] = roachpb.Key(encoding.EncodeUvarintAscending([]byte("key-"), uint64(i))) keyVersions := rng.Intn(numVersions) + 1 for j := 0; j < keyVersions; j++ { order = append(order, i) } } // Randomize the order in which the keys are written. for i, n := 0, len(order); i < n-1; i++ { j := i + rng.Intn(n-i) order[i], order[j] = order[j], order[i] } counts := make([]int, numKeys) batch := eng.NewBatch() for i, idx := range order { // Output the keys in ~20 batches. If we used a single batch to output all // of the keys rocksdb would create a single sstable. We want multiple // sstables in order to exercise filtering of which sstables are examined // during iterator seeking. We fix the number of batches we output so that // optimizations which change the data size result in the same number of // sstables. if scaled := len(order) / 20; i > 0 && (i%scaled) == 0 { log.Infof(context.Background(), "committing (%d/~%d)", i/scaled, 20) if err := batch.Commit(); err != nil { b.Fatal(err) } batch.Close() batch = eng.NewBatch() if err := eng.Flush(); err != nil { b.Fatal(err) } } key := keys[idx] ts := makeTS(int64(counts[idx]+1)*5, 0) counts[idx]++ value := roachpb.MakeValueFromBytes(randutil.RandBytes(rng, valueBytes)) value.InitChecksum(key) if err := MVCCPut(context.Background(), batch, nil, key, ts, value, nil); err != nil { b.Fatal(err) } } if err := batch.Commit(); err != nil { b.Fatal(err) } batch.Close() if err := eng.Flush(); err != nil { b.Fatal(err) } return eng, loc }
// TestMultiRangeScanWithMaxResults tests that commands which access multiple // ranges with MaxResults parameter are carried out properly. func TestMultiRangeScanWithMaxResults(t *testing.T) { defer leaktest.AfterTest(t)() testCases := []struct { splitKeys []roachpb.Key keys []roachpb.Key }{ {[]roachpb.Key{roachpb.Key("m")}, []roachpb.Key{roachpb.Key("a"), roachpb.Key("z")}}, {[]roachpb.Key{roachpb.Key("h"), roachpb.Key("q")}, []roachpb.Key{roachpb.Key("b"), roachpb.Key("f"), roachpb.Key("k"), roachpb.Key("r"), roachpb.Key("w"), roachpb.Key("y")}}, } for i, tc := range testCases { s, _, _ := serverutils.StartServer(t, base.TestServerArgs{}) defer s.Stopper().Stop() ts := s.(*TestServer) retryOpts := base.DefaultRetryOptions() retryOpts.Closer = ts.stopper.ShouldQuiesce() ds := kv.NewDistSender(kv.DistSenderConfig{ Clock: s.Clock(), RPCContext: s.RPCContext(), RPCRetryOptions: &retryOpts, }, ts.Gossip()) ambient := log.AmbientContext{Tracer: tracing.NewTracer()} tds := kv.NewTxnCoordSender( ambient, ds, ts.Clock(), ts.Cfg.Linearizable, ts.stopper, kv.MakeTxnMetrics(metric.TestSampleInterval), ) for _, sk := range tc.splitKeys { if err := ts.node.storeCfg.DB.AdminSplit(context.TODO(), sk); err != nil { t.Fatal(err) } } for _, k := range tc.keys { put := roachpb.NewPut(k, roachpb.MakeValueFromBytes(k)) if _, err := client.SendWrapped(context.Background(), tds, put); err != nil { t.Fatal(err) } } // Try every possible ScanRequest startKey. for start := 0; start < len(tc.keys); start++ { // Try every possible maxResults, from 1 to beyond the size of key array. for maxResults := 1; maxResults <= len(tc.keys)-start+1; maxResults++ { scan := roachpb.NewScan(tc.keys[start], tc.keys[len(tc.keys)-1].Next()) reply, err := client.SendWrappedWith( context.Background(), tds, roachpb.Header{MaxSpanRequestKeys: int64(maxResults)}, scan, ) if err != nil { t.Fatal(err) } rows := reply.(*roachpb.ScanResponse).Rows if start+maxResults <= len(tc.keys) && len(rows) != maxResults { t.Errorf("%d: start=%s: expected %d rows, but got %d", i, tc.keys[start], maxResults, len(rows)) } else if start+maxResults == len(tc.keys)+1 && len(rows) != maxResults-1 { t.Errorf("%d: expected %d rows, but got %d", i, maxResults-1, len(rows)) } } } } }
// TestMultiRangeScanDeleteRange tests that commands which access multiple // ranges are carried out properly. func TestMultiRangeScanDeleteRange(t *testing.T) { defer leaktest.AfterTest(t)() s, _, _ := serverutils.StartServer(t, base.TestServerArgs{}) defer s.Stopper().Stop() ts := s.(*TestServer) retryOpts := base.DefaultRetryOptions() retryOpts.Closer = ts.stopper.ShouldQuiesce() ds := kv.NewDistSender(kv.DistSenderConfig{ Clock: s.Clock(), RPCContext: s.RPCContext(), RPCRetryOptions: &retryOpts, }, ts.Gossip()) ambient := log.AmbientContext{Tracer: tracing.NewTracer()} tds := kv.NewTxnCoordSender( ambient, ds, s.Clock(), ts.Cfg.Linearizable, ts.stopper, kv.MakeTxnMetrics(metric.TestSampleInterval), ) if err := ts.node.storeCfg.DB.AdminSplit(context.TODO(), "m"); err != nil { t.Fatal(err) } writes := []roachpb.Key{roachpb.Key("a"), roachpb.Key("z")} get := &roachpb.GetRequest{ Span: roachpb.Span{Key: writes[0]}, } get.EndKey = writes[len(writes)-1] if _, err := client.SendWrapped(context.Background(), tds, get); err == nil { t.Errorf("able to call Get with a key range: %v", get) } var delTS hlc.Timestamp for i, k := range writes { put := roachpb.NewPut(k, roachpb.MakeValueFromBytes(k)) if _, err := client.SendWrapped(context.Background(), tds, put); err != nil { t.Fatal(err) } scan := roachpb.NewScan(writes[0], writes[len(writes)-1].Next()) reply, err := client.SendWrapped(context.Background(), tds, scan) if err != nil { t.Fatal(err) } sr := reply.(*roachpb.ScanResponse) if sr.Txn != nil { // This was the other way around at some point in the past. // Same below for Delete, etc. t.Errorf("expected no transaction in response header") } if rows := sr.Rows; len(rows) != i+1 { t.Fatalf("expected %d rows, but got %d", i+1, len(rows)) } } del := &roachpb.DeleteRangeRequest{ Span: roachpb.Span{ Key: writes[0], EndKey: roachpb.Key(writes[len(writes)-1]).Next(), }, ReturnKeys: true, } reply, err := client.SendWrappedWith(context.Background(), tds, roachpb.Header{Timestamp: delTS}, del) if err != nil { t.Fatal(err) } dr := reply.(*roachpb.DeleteRangeResponse) if dr.Txn != nil { t.Errorf("expected no transaction in response header") } if !reflect.DeepEqual(dr.Keys, writes) { t.Errorf("expected %d keys to be deleted, but got %d instead", writes, dr.Keys) } scan := roachpb.NewScan(writes[0], writes[len(writes)-1].Next()) txn := &roachpb.Transaction{Name: "MyTxn"} reply, err = client.SendWrappedWith(context.Background(), tds, roachpb.Header{Txn: txn}, scan) if err != nil { t.Fatal(err) } sr := reply.(*roachpb.ScanResponse) if txn := sr.Txn; txn == nil || txn.Name != "MyTxn" { t.Errorf("wanted Txn to persist, but it changed to %v", txn) } if rows := sr.Rows; len(rows) > 0 { t.Fatalf("scan after delete returned rows: %v", rows) } }
// TestKVDBCoverage verifies that all methods may be invoked on the // key value database. func TestKVDBCoverage(t *testing.T) { defer leaktest.AfterTest(t)() s, _, _ := serverutils.StartServer(t, base.TestServerArgs{}) defer s.Stopper().Stop() ctx := context.TODO() db := createTestClient(t, s) key := roachpb.Key("a") value1 := []byte("value1") value2 := []byte("value2") value3 := []byte("value3") // Put first value at key. if pErr := db.Put(context.TODO(), key, value1); pErr != nil { t.Fatal(pErr) } // Verify put. if gr, pErr := db.Get(ctx, key); pErr != nil { t.Fatal(pErr) } else if !gr.Exists() { t.Error("expected key to exist") } // Conditional put should succeed, changing value1 to value2. if pErr := db.CPut(context.TODO(), key, value2, value1); pErr != nil { t.Fatal(pErr) } // Verify get by looking up conditional put value. if gr, pErr := db.Get(ctx, key); pErr != nil { t.Fatal(pErr) } else if !bytes.Equal(gr.ValueBytes(), value2) { t.Errorf("expected get to return %q; got %q", value2, gr.ValueBytes()) } // Increment. if ir, pErr := db.Inc(ctx, "i", 10); pErr != nil { t.Fatal(pErr) } else if ir.ValueInt() != 10 { t.Errorf("expected increment new value of %d; got %d", 10, ir.ValueInt()) } // Delete conditional put value. if pErr := db.Del(ctx, key); pErr != nil { t.Fatal(pErr) } if gr, pErr := db.Get(ctx, key); pErr != nil { t.Fatal(pErr) } else if gr.Exists() { t.Error("expected key to not exist after delete") } // Put values in anticipation of scan & delete range. keyValues := []roachpb.KeyValue{ {Key: roachpb.Key("a"), Value: roachpb.MakeValueFromBytes(value1)}, {Key: roachpb.Key("b"), Value: roachpb.MakeValueFromBytes(value2)}, {Key: roachpb.Key("c"), Value: roachpb.MakeValueFromBytes(value3)}, } for _, kv := range keyValues { valueBytes, pErr := kv.Value.GetBytes() if pErr != nil { t.Fatal(pErr) } if pErr := db.Put(context.TODO(), kv.Key, valueBytes); pErr != nil { t.Fatal(pErr) } } if rows, pErr := db.Scan(context.TODO(), "a", "d", 0); pErr != nil { t.Fatal(pErr) } else if len(rows) != len(keyValues) { t.Fatalf("expected %d rows in scan; got %d", len(keyValues), len(rows)) } else { for i, kv := range keyValues { valueBytes, pErr := kv.Value.GetBytes() if pErr != nil { t.Fatal(pErr) } if !bytes.Equal(rows[i].ValueBytes(), valueBytes) { t.Errorf("%d: key %q, values %q != %q", i, kv.Key, rows[i].ValueBytes(), valueBytes) } } } // Test reverse scan. if rows, pErr := db.ReverseScan(context.TODO(), "a", "d", 0); pErr != nil { t.Fatal(pErr) } else if len(rows) != len(keyValues) { t.Fatalf("expected %d rows in scan; got %d", len(keyValues), len(rows)) } else { for i, kv := range keyValues { valueBytes, pErr := kv.Value.GetBytes() if pErr != nil { t.Fatal(pErr) } if !bytes.Equal(rows[len(keyValues)-1-i].ValueBytes(), valueBytes) { t.Errorf("%d: key %q, values %q != %q", i, kv.Key, rows[len(keyValues)-i].ValueBytes(), valueBytes) } } } if pErr := db.DelRange(context.TODO(), "a", "c"); pErr != nil { t.Fatal(pErr) } }
func TestIndexKey(t *testing.T) { rng, _ := randutil.NewPseudoRand() var a DatumAlloc tests := []indexKeyTest{ {nil, nil, []parser.Datum{parser.NewDInt(10)}, []parser.Datum{parser.NewDInt(20)}, }, {[]ID{100}, nil, []parser.Datum{parser.NewDInt(10), parser.NewDInt(11)}, []parser.Datum{parser.NewDInt(20)}, }, {[]ID{100, 200}, nil, []parser.Datum{parser.NewDInt(10), parser.NewDInt(11), parser.NewDInt(12)}, []parser.Datum{parser.NewDInt(20)}, }, {nil, []ID{100}, []parser.Datum{parser.NewDInt(10)}, []parser.Datum{parser.NewDInt(20), parser.NewDInt(21)}, }, {[]ID{100}, []ID{100}, []parser.Datum{parser.NewDInt(10), parser.NewDInt(11)}, []parser.Datum{parser.NewDInt(20), parser.NewDInt(21)}, }, {[]ID{100}, []ID{200}, []parser.Datum{parser.NewDInt(10), parser.NewDInt(11)}, []parser.Datum{parser.NewDInt(20), parser.NewDInt(21)}, }, {[]ID{100, 200}, []ID{100, 300}, []parser.Datum{parser.NewDInt(10), parser.NewDInt(11), parser.NewDInt(12)}, []parser.Datum{parser.NewDInt(20), parser.NewDInt(21), parser.NewDInt(22)}, }, } for i := 0; i < 1000; i++ { var t indexKeyTest t.primaryInterleaves = make([]ID, rng.Intn(10)) for j := range t.primaryInterleaves { t.primaryInterleaves[j] = ID(1 + rng.Intn(10)) } valuesLen := randutil.RandIntInRange(rng, len(t.primaryInterleaves)+1, len(t.primaryInterleaves)+10) t.primaryValues = make([]parser.Datum, valuesLen) for j := range t.primaryValues { t.primaryValues[j] = RandDatum(rng, ColumnType{Kind: ColumnType_INT}, true) } t.secondaryInterleaves = make([]ID, rng.Intn(10)) for j := range t.secondaryInterleaves { t.secondaryInterleaves[j] = ID(1 + rng.Intn(10)) } valuesLen = randutil.RandIntInRange(rng, len(t.secondaryInterleaves)+1, len(t.secondaryInterleaves)+10) t.secondaryValues = make([]parser.Datum, valuesLen) for j := range t.secondaryValues { t.secondaryValues[j] = RandDatum(rng, ColumnType{Kind: ColumnType_INT}, true) } tests = append(tests, t) } for i, test := range tests { tableDesc, colMap := makeTableDescForTest(test) testValues := append(test.primaryValues, test.secondaryValues...) primaryKeyPrefix := MakeIndexKeyPrefix(&tableDesc, tableDesc.PrimaryIndex.ID) primaryKey, _, err := EncodeIndexKey( &tableDesc, &tableDesc.PrimaryIndex, colMap, testValues, primaryKeyPrefix) if err != nil { t.Fatal(err) } primaryValue := roachpb.MakeValueFromBytes(nil) primaryIndexKV := client.KeyValue{Key: primaryKey, Value: &primaryValue} secondaryIndexEntry, err := EncodeSecondaryIndex( &tableDesc, &tableDesc.Indexes[0], colMap, testValues) if err != nil { t.Fatal(err) } secondaryIndexKV := client.KeyValue{ Key: secondaryIndexEntry.Key, Value: &secondaryIndexEntry.Value, } checkEntry := func(index *IndexDescriptor, entry client.KeyValue) { values, err := decodeIndex(&a, &tableDesc, index, entry.Key) if err != nil { t.Fatal(err) } for j, value := range values { testValue := testValues[colMap[index.ColumnIDs[j]]] if value.Compare(testValue) != 0 { t.Fatalf("%d: value %d got %q but expected %q", i, j, value, testValue) } } indexID, _, err := DecodeIndexKeyPrefix(&a, &tableDesc, entry.Key) if err != nil { t.Fatal(err) } if indexID != index.ID { t.Errorf("%d", i) } extracted, err := ExtractIndexKey(&a, &tableDesc, entry) if err != nil { t.Fatal(err) } if !bytes.Equal(extracted, primaryKey) { t.Errorf("%d got %s <%x>, but expected %s <%x>", i, extracted, []byte(extracted), roachpb.Key(primaryKey), primaryKey) } } checkEntry(&tableDesc.PrimaryIndex, primaryIndexKV) checkEntry(&tableDesc.Indexes[0], secondaryIndexKV) } }
// This test checks backward compatibility with old data that contains // sentinel k:v pairs at the start of each table row. Cockroachdb used // to write table rows with sentinel values in the past. When a new column // is added to such a table with the new column included in the same // column family as the primary key columns, the sentinel k:v pairs // start representing this new column. This test checks that the sentinel // values represent NULL column values, and that an UPDATE to such // a column works correctly. func TestParseSentinelValueWithNewColumnInSentinelFamily(t *testing.T) { defer leaktest.AfterTest(t)() params, _ := createTestServerParams() server, sqlDB, kvDB := serverutils.StartServer(t, params) defer server.Stopper().Stop() if _, err := sqlDB.Exec(` CREATE DATABASE t; CREATE TABLE t.test ( k INT PRIMARY KEY, FAMILY F1 (k) ); `); err != nil { t.Fatal(err) } tableDesc := sqlbase.GetTableDescriptor(kvDB, "t", "test") if tableDesc.Families[0].DefaultColumnID != 0 { t.Fatalf("default column id not set properly: %s", tableDesc) } // Add some data. const maxValue = 10 inserts := make([]string, maxValue+1) for i := range inserts { inserts[i] = fmt.Sprintf(`(%d)`, i) } if _, err := sqlDB.Exec(`INSERT INTO t.test VALUES ` + strings.Join(inserts, ",")); err != nil { t.Fatal(err) } // Convert table data created by the above INSERT into sentinel // values. This is done to make the table appear like it were // written in the past when cockroachdb used to write sentinel // values for each table row. startKey := roachpb.Key(keys.MakeTablePrefix(uint32(tableDesc.ID))) kvs, err := kvDB.Scan( context.TODO(), startKey, startKey.PrefixEnd(), maxValue+1) if err != nil { t.Fatal(err) } for _, kv := range kvs { value := roachpb.MakeValueFromBytes(nil) if err := kvDB.Put(context.TODO(), kv.Key, &value); err != nil { t.Fatal(err) } } // Add a new column that gets added to column family 0, // updating DefaultColumnID. if _, err := sqlDB.Exec(`ALTER TABLE t.test ADD COLUMN v INT FAMILY F1`); err != nil { t.Fatal(err) } tableDesc = sqlbase.GetTableDescriptor(kvDB, "t", "test") if tableDesc.Families[0].DefaultColumnID != 2 { t.Fatalf("default column id not set properly: %s", tableDesc) } // Update one of the rows. const setKey = 5 const setVal = maxValue - setKey if _, err := sqlDB.Exec(`UPDATE t.test SET v = $1 WHERE k = $2`, setVal, setKey); err != nil { t.Fatal(err) } // The table contains the one updated value and remaining NULL values. rows, err := sqlDB.Query(`SELECT v from t.test`) if err != nil { t.Fatal(err) } const eCount = maxValue + 1 count := 0 for ; rows.Next(); count++ { var val *int if err := rows.Scan(&val); err != nil { t.Errorf("row %d scan failed: %s", count, err) continue } if count == setKey { if val != nil { if setVal != *val { t.Errorf("value = %d, expected %d", *val, setVal) } } else { t.Error("received nil value for column 'v'") } } else if val != nil { t.Error("received non NULL value for column 'v'") } } if err := rows.Err(); err != nil { t.Fatal(err) } if eCount != count { t.Fatalf("read the wrong number of rows: e = %d, v = %d", eCount, count) } }
// TestUncertaintyObservedTimestampForwarding checks that when receiving an // uncertainty restart on a node, the next attempt to read (at the increased // timestamp) is free from uncertainty. See roachpb.Transaction for details. func TestUncertaintyMaxTimestampForwarding(t *testing.T) { defer leaktest.AfterTest(t)() dbCtx := client.DefaultDBContext() s := &localtestcluster.LocalTestCluster{ // Large offset so that any value in the future is an uncertain read. Also // makes sure that the values we write in the future below don't actually // wind up in the past. Clock: hlc.NewClock(hlc.UnixNano, 50*time.Second), DBContext: &dbCtx, } s.Start(t, testutils.NewNodeTestBaseContext(), InitSenderForLocalTestCluster) defer s.Stop() disableOwnNodeCertain(t, s) offsetNS := int64(100) keySlow := roachpb.Key("slow") keyFast := roachpb.Key("fast") valSlow := []byte("wols") valFast := []byte("tsaf") // Write keySlow at now+offset, keyFast at now+2*offset futureTS := s.Clock.Now() futureTS.WallTime += offsetNS val := roachpb.MakeValueFromBytes(valSlow) if err := engine.MVCCPut(context.Background(), s.Eng, nil, keySlow, futureTS, val, nil); err != nil { t.Fatal(err) } futureTS.WallTime += offsetNS val.SetBytes(valFast) if err := engine.MVCCPut(context.Background(), s.Eng, nil, keyFast, futureTS, val, nil); err != nil { t.Fatal(err) } i := 0 if tErr := s.DB.Txn(context.TODO(), func(txn *client.Txn) error { i++ // The first command serves to start a Txn, fixing the timestamps. // There will be a restart, but this is idempotent. if _, err := txn.Scan("t", roachpb.Key("t").Next(), 0); err != nil { t.Fatal(err) } // This is a bit of a hack for the sake of this test: By visiting the // node above, we've made a note of its clock, which allows us to // prevent the restart. But we want to catch the restart, so reset the // observed timestamps. txn.Proto.ResetObservedTimestamps() // The server's clock suddenly jumps ahead of keyFast's timestamp. s.Manual.Increment(2*offsetNS + 1) // Now read slowKey first. It should read at 0, catch an uncertainty error, // and get keySlow's timestamp in that error, but upgrade it to the larger // node clock (which is ahead of keyFast as well). If the last part does // not happen, the read of keyFast should fail (i.e. read nothing). // There will be exactly one restart here. if gr, err := txn.Get(keySlow); err != nil { if i != 1 { t.Fatalf("unexpected transaction error: %s", err) } return err } else if !gr.Exists() || !bytes.Equal(gr.ValueBytes(), valSlow) { t.Fatalf("read of %q returned %v, wanted value %q", keySlow, gr.Value, valSlow) } // The node should already be certain, so we expect no restart here // and to read the correct key. if gr, err := txn.Get(keyFast); err != nil { t.Fatalf("second Get failed with %s", err) } else if !gr.Exists() || !bytes.Equal(gr.ValueBytes(), valFast) { t.Fatalf("read of %q returned %v, wanted value %q", keyFast, gr.Value, valFast) } return nil }); tErr != nil { t.Fatal(tErr) } }
func kv(k, v []byte) roachpb.KeyValue { return roachpb.KeyValue{ Key: k, Value: roachpb.MakeValueFromBytes(v), } }