func TestGet(t *testing.T) { defer leaktest.AfterTest(t)() emptyKeys := []roachpb.KeyValue{} someKeys := []roachpb.KeyValue{ plainKV("a", "vala"), plainKV("c", "valc"), plainKV("d", "vald"), } aVal := roachpb.MakeValueFromString("vala") bVal := roachpb.MakeValueFromString("valc") cVal := roachpb.MakeValueFromString("vald") testCases := []struct { values []roachpb.KeyValue key string value *roachpb.Value }{ {emptyKeys, "a", nil}, {emptyKeys, "b", nil}, {emptyKeys, "c", nil}, {emptyKeys, "d", nil}, {emptyKeys, "e", nil}, {someKeys, "", nil}, {someKeys, "b", nil}, {someKeys, "e", nil}, {someKeys, "a0", nil}, {someKeys, "a", &aVal}, {someKeys, "c", &bVal}, {someKeys, "d", &cVal}, } cfg := config.SystemConfig{} for tcNum, tc := range testCases { cfg.Values = tc.values if val := cfg.GetValue([]byte(tc.key)); !proto.Equal(val, tc.value) { t.Errorf("#%d: expected=%s, found=%s", tcNum, tc.value, val) } } }
func TestBatchProto(t *testing.T) { defer leaktest.AfterTest(t)() stopper := stop.NewStopper() defer stopper.Stop() e := NewInMem(roachpb.Attributes{}, 1<<20) stopper.AddCloser(e) b := e.NewBatch() defer b.Close() val := roachpb.MakeValueFromString("value") if _, _, err := PutProto(b, mvccKey("proto"), &val); err != nil { t.Fatal(err) } getVal := &roachpb.Value{} ok, keySize, valSize, err := b.GetProto(mvccKey("proto"), getVal) if !ok || err != nil { t.Fatalf("expected GetProto to success ok=%t: %s", ok, err) } if keySize != 6 { t.Errorf("expected key size 6; got %d", keySize) } data, err := protoutil.Marshal(&val) if err != nil { t.Fatal(err) } if valSize != int64(len(data)) { t.Errorf("expected value size %d; got %d", len(data), valSize) } if !proto.Equal(getVal, &val) { t.Errorf("expected %v; got %v", &val, getVal) } // Before commit, proto will not be available via engine. if ok, _, _, err := e.GetProto(mvccKey("proto"), getVal); ok || err != nil { t.Fatalf("expected GetProto to fail ok=%t: %s", ok, err) } // Commit and verify the proto can be read directly from the engine. if err := b.Commit(); err != nil { t.Fatal(err) } if ok, _, _, err := e.GetProto(mvccKey("proto"), getVal); !ok || err != nil { t.Fatalf("expected GetProto to success ok=%t: %s", ok, err) } if !proto.Equal(getVal, &val) { t.Errorf("expected %v; got %v", &val, getVal) } }
// createRangeData creates sample range data in all possible areas of // the key space. Returns a slice of the encoded keys of all created // data. func createRangeData(t *testing.T, r *Replica) []engine.MVCCKey { ts0 := hlc.ZeroTimestamp ts := hlc.Timestamp{WallTime: 1} desc := r.Desc() keyTSs := []struct { key roachpb.Key ts hlc.Timestamp }{ {keys.AbortCacheKey(r.RangeID, testTxnID), ts0}, {keys.AbortCacheKey(r.RangeID, testTxnID2), ts0}, {keys.RangeFrozenStatusKey(r.RangeID), ts0}, {keys.RangeLastGCKey(r.RangeID), ts0}, {keys.RaftAppliedIndexKey(r.RangeID), ts0}, {keys.RaftTruncatedStateKey(r.RangeID), ts0}, {keys.RangeLeaseKey(r.RangeID), ts0}, {keys.LeaseAppliedIndexKey(r.RangeID), ts0}, {keys.RangeStatsKey(r.RangeID), ts0}, {keys.RangeTxnSpanGCThresholdKey(r.RangeID), ts0}, {keys.RaftHardStateKey(r.RangeID), ts0}, {keys.RaftLastIndexKey(r.RangeID), ts0}, {keys.RaftLogKey(r.RangeID, 1), ts0}, {keys.RaftLogKey(r.RangeID, 2), ts0}, {keys.RangeLastReplicaGCTimestampKey(r.RangeID), ts0}, {keys.RangeLastVerificationTimestampKeyDeprecated(r.RangeID), ts0}, {keys.RangeDescriptorKey(desc.StartKey), ts}, {keys.TransactionKey(roachpb.Key(desc.StartKey), uuid.MakeV4()), ts0}, {keys.TransactionKey(roachpb.Key(desc.StartKey.Next()), uuid.MakeV4()), ts0}, {keys.TransactionKey(fakePrevKey(desc.EndKey), uuid.MakeV4()), ts0}, // TODO(bdarnell): KeyMin.Next() results in a key in the reserved system-local space. // Once we have resolved https://github.com/cockroachdb/cockroach/issues/437, // replace this with something that reliably generates the first valid key in the range. //{r.Desc().StartKey.Next(), ts}, // The following line is similar to StartKey.Next() but adds more to the key to // avoid falling into the system-local space. {append(append([]byte{}, desc.StartKey...), '\x02'), ts}, {fakePrevKey(r.Desc().EndKey), ts}, } keys := []engine.MVCCKey{} for _, keyTS := range keyTSs { if err := engine.MVCCPut(context.Background(), r.store.Engine(), nil, keyTS.key, keyTS.ts, roachpb.MakeValueFromString("value"), nil); err != nil { t.Fatal(err) } keys = append(keys, engine.MVCCKey{Key: keyTS.key, Timestamp: keyTS.ts}) } return keys }
func TestEngineBatchStaleCachedIterator(t *testing.T) { defer leaktest.AfterTest(t)() // Prevent regression of a bug which caused spurious MVCC errors due to an // invalid optimization which let an iterator return key-value pairs which // had since been deleted from the underlying engine. // Discovered in #6878. runWithAllEngines(func(eng Engine, t *testing.T) { // Focused failure mode: highlights the actual bug. { batch := eng.NewBatch() defer batch.Close() iter := batch.NewIterator(false) key := MVCCKey{Key: roachpb.Key("b")} if err := batch.Put(key, []byte("foo")); err != nil { t.Fatal(err) } iter.Seek(key) if err := batch.Clear(key); err != nil { t.Fatal(err) } // Iterator should not reuse its cached result. iter.Seek(key) if iter.Valid() { t.Fatalf("iterator unexpectedly valid: %v -> %v", iter.unsafeKey(), iter.unsafeValue()) } } // Higher-level failure mode. Mostly for documentation. { batch := eng.NewBatch().(*rocksDBBatch) defer batch.Close() key := roachpb.Key("z") // Put a value so that the deletion below finds a value to seek // to. if err := MVCCPut(context.Background(), batch, nil, key, hlc.ZeroTimestamp, roachpb.MakeValueFromString("x"), nil); err != nil { t.Fatal(err) } // Seek the iterator to `key` and clear the value (but without // telling the iterator about that). if err := MVCCDelete(context.Background(), batch, nil, key, hlc.ZeroTimestamp, nil); err != nil { t.Fatal(err) } // Trigger a seek on the cached iterator by seeking to the (now // absent) key. // The underlying iterator will already be in the right position // due to a seek in MVCCDelete (followed by a Clear, which does not // invalidate the iterator's cache), and if it reports its cached // result back, we'll see the (newly deleted) value (due to the // failure mode above). if v, _, err := MVCCGet(context.Background(), batch, key, hlc.ZeroTimestamp, true, nil); err != nil { t.Fatal(err) } else if v != nil { t.Fatalf("expected no value, got %+v", v) } } }, t) }
func appender(s string) []byte { val := roachpb.MakeValueFromString(s) v := &enginepb.MVCCMetadata{RawBytes: val.RawBytes} return mustMarshal(v) }