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 : 4723847 : static uint64_t PackSequenceAndType(uint64_t seq, ValueType t) {
17 [ - + ]: 4723847 : assert(seq <= kMaxSequenceNumber);
18 [ - + ]: 4723847 : assert(t <= kValueTypeForSeek);
19 : 4723847 : return (seq << 8) | t;
20 : : }
21 : :
22 : 1007 : void AppendInternalKey(std::string* result, const ParsedInternalKey& key) {
23 : 1007 : result->append(key.user_key.data(), key.user_key.size());
24 : 1007 : PutFixed64(result, PackSequenceAndType(key.sequence, key.type));
25 : 1007 : }
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 : : }
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 : : }
47 : :
48 : 127653563 : 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 : 127653563 : int r = user_comparator_->Compare(ExtractUserKey(akey), ExtractUserKey(bkey));
54 [ + + ]: 127653563 : if (r == 0) {
55 [ + + ]: 486824 : const uint64_t anum = DecodeFixed64(akey.data() + akey.size() - 8);
56 : 486824 : const uint64_t bnum = DecodeFixed64(bkey.data() + bkey.size() - 8);
57 [ + + ]: 486824 : if (anum > bnum) {
58 : : r = -1;
59 [ + + ]: 459886 : } else if (anum < bnum) {
60 : 459382 : r = +1;
61 : : }
62 : : }
63 : 127653563 : return r;
64 : : }
65 : :
66 : 345 : void InternalKeyComparator::FindShortestSeparator(std::string* start,
67 : : const Slice& limit) const {
68 : : // Attempt to shorten the user portion of the key
69 [ - + ]: 345 : Slice user_start = ExtractUserKey(*start);
70 : 345 : Slice user_limit = ExtractUserKey(limit);
71 : 345 : std::string tmp(user_start.data(), user_start.size());
72 [ + - ]: 345 : user_comparator_->FindShortestSeparator(&tmp, user_limit);
73 [ - + + + : 454 : if (tmp.size() < user_start.size() &&
+ - ]
74 [ + - ]: 109 : 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 [ + - ]: 109 : PutFixed64(&tmp,
78 : : PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
79 [ - + - + : 109 : assert(this->Compare(*start, tmp) < 0);
+ - - + ]
80 [ - + + - : 109 : assert(this->Compare(tmp, limit) < 0);
- + ]
81 : 109 : start->swap(tmp);
82 : : }
83 : 345 : }
84 : :
85 : 73 : void InternalKeyComparator::FindShortSuccessor(std::string* key) const {
86 [ - + ]: 73 : Slice user_key = ExtractUserKey(*key);
87 : 73 : std::string tmp(user_key.data(), user_key.size());
88 [ + - ]: 73 : user_comparator_->FindShortSuccessor(&tmp);
89 [ - + + + : 86 : if (tmp.size() < user_key.size() &&
+ - ]
90 [ + - ]: 13 : 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 [ + - ]: 13 : PutFixed64(&tmp,
94 : : PackSequenceAndType(kMaxSequenceNumber, kValueTypeForSeek));
95 [ - + - + : 13 : assert(this->Compare(*key, tmp) < 0);
+ - - + ]
96 : 13 : key->swap(tmp);
97 : : }
98 : 73 : }
99 : :
100 : 228 : const char* InternalFilterPolicy::Name() const { return user_policy_->Name(); }
101 : :
102 : 418 : void InternalFilterPolicy::CreateFilter(const Slice* keys, int n,
103 : : std::string* dst) const {
104 : : // We rely on the fact that the code in table.cc does not mind us
105 : : // adjusting keys[].
106 : 418 : Slice* mkey = const_cast<Slice*>(keys);
107 [ + + ]: 28783 : for (int i = 0; i < n; i++) {
108 : 28365 : mkey[i] = ExtractUserKey(keys[i]);
109 : : // TODO(sanjay): Suppress dups?
110 : : }
111 : 418 : user_policy_->CreateFilter(keys, n, dst);
112 : 418 : }
113 : :
114 : 1292221 : bool InternalFilterPolicy::KeyMayMatch(const Slice& key, const Slice& f) const {
115 : 1292221 : return user_policy_->KeyMayMatch(ExtractUserKey(key), f);
116 : : }
117 : :
118 : 4722718 : LookupKey::LookupKey(const Slice& user_key, SequenceNumber s) {
119 [ + - ]: 4722718 : size_t usize = user_key.size();
120 : 4722718 : size_t needed = usize + 13; // A conservative estimate
121 : 4722718 : char* dst;
122 [ + - ]: 4722718 : if (needed <= sizeof(space_)) {
123 : 4722718 : dst = space_;
124 : : } else {
125 : 0 : dst = new char[needed];
126 : : }
127 : 4722718 : start_ = dst;
128 : 4722718 : dst = EncodeVarint32(dst, usize + 8);
129 : 4722718 : kstart_ = dst;
130 : 4722718 : memcpy(dst, user_key.data(), usize);
131 : 4722718 : dst += usize;
132 : 4722718 : EncodeFixed64(dst, PackSequenceAndType(s, kValueTypeForSeek));
133 : 4722718 : dst += 8;
134 : 4722718 : end_ = dst;
135 : 4722718 : }
136 : :
137 : : } // namespace leveldb
|
