Branch data Line data Source code
# 1 : : // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
# 2 : : // Use of this source code is governed by a BSD-style license that can be
# 3 : : // found in the LICENSE file. See the AUTHORS file for names of contributors.
# 4 : :
# 5 : : #include "db/dbformat.h"
# 6 : :
# 7 : : #include <stdio.h>
# 8 : :
# 9 : : #include <sstream>
# 10 : :
# 11 : : #include "port/port.h"
# 12 : : #include "util/coding.h"
# 13 : :
# 14 : : namespace leveldb {
# 15 : :
# 16 : 7884043 : static uint64_t PackSequenceAndType(uint64_t seq, ValueType t) {
# 17 : 7884043 : assert(seq <= kMaxSequenceNumber);
# 18 : 7884043 : assert(t <= kValueTypeForSeek);
# 19 : 7884043 : return (seq << 8) | t;
# 20 : 7884043 : }
# 21 : :
# 22 : 2561 : void AppendInternalKey(std::string* result, const ParsedInternalKey& key) {
# 23 : 2561 : result->append(key.user_key.data(), key.user_key.size());
# 24 : 2561 : PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
# 25 : 2561 : }
# 26 : :
# 27 : 0 : std::string ParsedInternalKey::DebugString() const {
# 28 : 0 : std::ostringstream ss;
# 29 : 0 : ss << '\'' << EscapeString(user_key.ToString()) << "' @ " << sequence << " : "
# 30 : 0 : << static_cast<int>(type);
# 31 : 0 : return ss.str();
# 32 : 0 : }
# 33 : :
# 34 : 0 : std::string InternalKey::DebugString() const {
# 35 : 0 : ParsedInternalKey parsed;
# 36 [ # # ]: 0 : if (ParseInternalKey(rep_, &parsed)) {
# 37 : 0 : return parsed.DebugString();
# 38 : 0 : }
# 39 : 0 : std::ostringstream ss;
# 40 : 0 : ss << "(bad)" << EscapeString(rep_);
# 41 : 0 : return ss.str();
# 42 : 0 : }
# 43 : :
# 44 : 0 : const char* InternalKeyComparator::Name() const {
# 45 : 0 : return "leveldb.InternalKeyComparator";
# 46 : 0 : }
# 47 : :
# 48 : 193568816 : int InternalKeyComparator::Compare(const Slice& akey, const Slice& bkey) const {
# 49 : : // Order by:
# 50 : : // increasing user key (according to user-supplied comparator)
# 51 : : // decreasing sequence number
# 52 : : // decreasing type (though sequence# should be enough to disambiguate)
# 53 : 193568816 : int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
# 54 [ + + ]: 193568816 : if (r == 0) {
# 55 : 967016 : const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
# 56 : 967016 : const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
# 57 [ + + ]: 967016 : if (anum > bnum) {
# 58 : 64525 : r = -1;
# 59 [ + + ]: 902491 : } else if (anum < bnum) {
# 60 : 891636 : r = +1;
# 61 : 891636 : }
# 62 : 967016 : }
# 63 : 193568816 : return r;
# 64 : 193568816 : }
# 65 : :
# 66 : : void InternalKeyComparator::FindShortestSeparator(std::string* start,
# 67 : 2841 : const Slice& limit) const {
# 68 : : // Attempt to shorten the user portion of the key
# 69 : 2841 : Slice user_start = ExtractUserKey(*start);
# 70 : 2841 : Slice user_limit = ExtractUserKey(limit);
# 71 : 2841 : std::string tmp(user_start.data(), user_start.size());
# 72 : 2841 : user_comparator_->FindShortestSeparator(&tmp, user_limit);
# 73 [ + + ][ + + ]: 2841 : if (tmp.size() < user_start.size() &&
# 74 [ + - ]: 2841 : user_comparator_->Compare(user_start, tmp) < 0) {
# 75 : : // User key has become shorter physically, but larger logically.
# 76 : : // Tack on the earliest possible number to the shortened user key.
# 77 : 1598 : PutFixed64(&tmp,
# 78 : 1598 : PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
# 79 : 1598 : assert(this->Compare(*start, tmp) < 0);
# 80 : 1598 : assert(this->Compare(tmp, limit) < 0);
# 81 : 1598 : start->swap(tmp);
# 82 : 1598 : }
# 83 : 2841 : }
# 84 : :
# 85 : 842 : void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
# 86 : 842 : Slice user_key = ExtractUserKey(*key);
# 87 : 842 : std::string tmp(user_key.data(), user_key.size());
# 88 : 842 : user_comparator_->FindShortSuccessor(&tmp);
# 89 [ + + ][ + + ]: 842 : if (tmp.size() < user_key.size() &&
# 90 [ + - ]: 842 : user_comparator_->Compare(user_key, tmp) < 0) {
# 91 : : // User key has become shorter physically, but larger logically.
# 92 : : // Tack on the earliest possible number to the shortened user key.
# 93 : 43 : PutFixed64(&tmp,
# 94 : 43 : PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
# 95 : 43 : assert(this->Compare(*key, tmp) < 0);
# 96 : 43 : key->swap(tmp);
# 97 : 43 : }
# 98 : 842 : }
# 99 : :
# 100 : 2281 : const char* InternalFilterPolicy::Name() const { return user_policy_->Name(); }
# 101 : :
# 102 : : void InternalFilterPolicy::CreateFilter(const Slice* keys, int n,
# 103 : 3683 : std::string* dst) const {
# 104 : : // We rely on the fact that the code in table.cc does not mind us
# 105 : : // adjusting keys[].
# 106 : 3683 : Slice* mkey = const_cast<Slice*>(keys);
# 107 [ + + ]: 160656 : for (int i = 0; i < n; i++) {
# 108 : 156973 : mkey[i] = ExtractUserKey(keys[i]);
# 109 : : // TODO(sanjay): Suppress dups?
# 110 : 156973 : }
# 111 : 3683 : user_policy_->CreateFilter(keys, n, dst);
# 112 : 3683 : }
# 113 : :
# 114 : 2449157 : bool InternalFilterPolicy::KeyMayMatch(const Slice& key, const Slice& f) const {
# 115 : 2449157 : return user_policy_->KeyMayMatch(ExtractUserKey(key), f);
# 116 : 2449157 : }
# 117 : :
# 118 : 7879843 : LookupKey::LookupKey(const Slice& user_key, SequenceNumber s) {
# 119 : 7879843 : size_t usize = user_key.size();
# 120 : 7879843 : size_t needed = usize + 13; // A conservative estimate
# 121 : 7879843 : char* dst;
# 122 [ + - ]: 7879843 : if (needed <= sizeof(space_)) {
# 123 : 7879843 : dst = space_;
# 124 : 7879843 : } else {
# 125 : 0 : dst = new char[needed];
# 126 : 0 : }
# 127 : 7879843 : start_ = dst;
# 128 : 7879843 : dst = EncodeVarint32(dst, usize + 8);
# 129 : 7879843 : kstart_ = dst;
# 130 : 7879843 : memcpy(dst, user_key.data(), usize);
# 131 : 7879843 : dst += usize;
# 132 : 7879843 : EncodeFixed64(dst, PackSequenceAndType(s, kValueTypeForSeek));
# 133 : 7879843 : dst += 8;
# 134 : 7879843 : end_ = dst;
# 135 : 7879843 : }
# 136 : :
# 137 : : } // namespace leveldb
|
