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),
}
}
