252 lines
7.4 KiB
C++
252 lines
7.4 KiB
C++
/*
|
|
* FDBTypes.cpp
|
|
*
|
|
* This source file is part of the FoundationDB open source project
|
|
*
|
|
* Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "fdbclient/FDBTypes.h"
|
|
#include "fdbclient/Knobs.h"
|
|
#include "fdbclient/NativeAPI.actor.h"
|
|
|
|
KeyRangeRef toPrefixRelativeRange(KeyRangeRef range, Optional<KeyRef> prefix) {
|
|
if (!prefix.present() || prefix.get().empty()) {
|
|
return range;
|
|
} else {
|
|
KeyRef begin = range.begin.startsWith(prefix.get()) ? range.begin.removePrefix(prefix.get()) : allKeys.begin;
|
|
KeyRef end = range.end.startsWith(prefix.get()) ? range.end.removePrefix(prefix.get()) : allKeys.end;
|
|
return KeyRangeRef(begin, end);
|
|
}
|
|
}
|
|
|
|
KeyRef keyBetween(const KeyRangeRef& keys) {
|
|
int pos = 0; // will be the position of the first difference between keys.begin and keys.end
|
|
int minSize = std::min(keys.begin.size(), keys.end.size());
|
|
for (; pos < minSize && pos < CLIENT_KNOBS->SPLIT_KEY_SIZE_LIMIT; pos++) {
|
|
if (keys.begin[pos] != keys.end[pos]) {
|
|
return keys.end.substr(0, pos + 1);
|
|
}
|
|
}
|
|
|
|
// If one more character keeps us in the limit, and the latter key is simply
|
|
// longer, then we only need one more byte of the end string.
|
|
if (pos < CLIENT_KNOBS->SPLIT_KEY_SIZE_LIMIT && keys.begin.size() < keys.end.size()) {
|
|
return keys.end.substr(0, pos + 1);
|
|
}
|
|
|
|
return keys.end;
|
|
}
|
|
|
|
Key randomKeyBetween(const KeyRangeRef& keys) {
|
|
if (keys.empty() || keys.singleKeyRange()) {
|
|
return keys.end;
|
|
}
|
|
|
|
KeyRef begin = keys.begin;
|
|
KeyRef end = keys.end;
|
|
ASSERT(begin < end);
|
|
if (begin.size() < end.size()) {
|
|
// randomly append a char
|
|
uint8_t maxChar = end[begin.size()] > 0 ? end[begin.size()] : end[begin.size()] + 1;
|
|
uint8_t newChar = deterministicRandom()->randomInt(0, maxChar);
|
|
return begin.withSuffix(StringRef(&newChar, 1));
|
|
}
|
|
|
|
int pos = 0; // will be the position of the first difference between keys.begin and keys.end
|
|
for (; pos < end.size() && pos < CLIENT_KNOBS->KEY_SIZE_LIMIT; pos++) {
|
|
if (keys.begin[pos] != keys.end[pos]) {
|
|
break;
|
|
}
|
|
}
|
|
ASSERT_LT(pos, end.size()); // otherwise, begin >= end
|
|
|
|
// find the lowest char in range begin[pos+1, begin.size()) that is not \xff (255)
|
|
int lowest = begin.size() - 1;
|
|
for (; lowest > pos; lowest--) {
|
|
if (begin[lowest] < 255) {
|
|
Key res = begin;
|
|
uint8_t* ptr = mutateString(res);
|
|
*(ptr + lowest) = (uint8_t)deterministicRandom()->randomInt(begin[lowest] + 1, 256);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
if (begin[pos] + 1 < end[pos]) {
|
|
Key res = begin;
|
|
uint8_t* ptr = mutateString(res);
|
|
*(ptr + pos) = (uint8_t)deterministicRandom()->randomInt(begin[pos] + 1, end[pos]);
|
|
return res;
|
|
}
|
|
|
|
if (begin.size() + 1 < CLIENT_KNOBS->KEY_SIZE_LIMIT) {
|
|
// randomly append a char
|
|
uint8_t newChar = deterministicRandom()->randomInt(1, 255);
|
|
return begin.withSuffix(StringRef(&newChar, 1));
|
|
}
|
|
|
|
// no possible result
|
|
return end;
|
|
}
|
|
|
|
TEST_CASE("/KeyRangeUtil/randomKeyBetween") {
|
|
Key begin = "qwert"_sr;
|
|
Key end = "qwertyu"_sr;
|
|
Key res;
|
|
for (int i = 0; i < 10; ++i) {
|
|
res = randomKeyBetween(KeyRangeRef(begin, end));
|
|
ASSERT(res > begin);
|
|
ASSERT(res < end);
|
|
}
|
|
|
|
begin = "q"_sr;
|
|
end = "q\x00"_sr;
|
|
res = randomKeyBetween(KeyRangeRef(begin, end));
|
|
ASSERT(res == end);
|
|
|
|
begin = "aaaaaaa"_sr;
|
|
end = "b"_sr;
|
|
for (int i = 0; i < 10; ++i) {
|
|
res = randomKeyBetween(KeyRangeRef(begin, end));
|
|
ASSERT(res > begin);
|
|
ASSERT(res < end);
|
|
}
|
|
return Void();
|
|
}
|
|
|
|
void KeySelectorRef::setKey(KeyRef const& key) {
|
|
// There are no keys in the database with size greater than the max key size, so if this key selector has a key
|
|
// which is large, then we can translate it to an equivalent key selector with a smaller key
|
|
int64_t maxKeySize = getMaxKeySize(key);
|
|
if (key.size() > maxKeySize) {
|
|
this->key = key.substr(0, maxKeySize + 1);
|
|
} else {
|
|
this->key = key;
|
|
}
|
|
}
|
|
|
|
void KeySelectorRef::setKeyUnlimited(KeyRef const& key) {
|
|
this->key = key;
|
|
}
|
|
|
|
std::string KeySelectorRef::toString() const {
|
|
if (offset > 0) {
|
|
if (orEqual)
|
|
return format("%d+firstGreaterThan(%s)", offset - 1, printable(key).c_str());
|
|
else
|
|
return format("%d+firstGreaterOrEqual(%s)", offset - 1, printable(key).c_str());
|
|
} else {
|
|
if (orEqual)
|
|
return format("%d+lastLessOrEqual(%s)", offset, printable(key).c_str());
|
|
else
|
|
return format("%d+lastLessThan(%s)", offset, printable(key).c_str());
|
|
}
|
|
}
|
|
|
|
std::string describe(const std::string& s) {
|
|
return s;
|
|
}
|
|
|
|
std::string describe(UID const& item) {
|
|
return item.shortString();
|
|
}
|
|
|
|
TEST_CASE("/KeyRangeUtil/KeyRangeComplement") {
|
|
Key begin = "b"_sr;
|
|
Key end = "y"_sr;
|
|
KeyRangeRef range(begin, end);
|
|
|
|
{
|
|
Key b = "c"_sr;
|
|
Key e = "f"_sr;
|
|
std::vector<KeyRangeRef> result = range - KeyRangeRef(b, e);
|
|
ASSERT(result.size() == 2);
|
|
ASSERT(result[0] == KeyRangeRef("b"_sr, "c"_sr));
|
|
ASSERT(result[1] == KeyRangeRef("f"_sr, "y"_sr));
|
|
}
|
|
|
|
{
|
|
Key b = "1"_sr;
|
|
Key e = "9"_sr;
|
|
std::vector<KeyRangeRef> result = range - KeyRangeRef(b, e);
|
|
ASSERT(result.size() == 1);
|
|
ASSERT(result[0] == KeyRangeRef("b"_sr, "y"_sr));
|
|
}
|
|
|
|
{
|
|
Key b = "a"_sr;
|
|
Key e = "f"_sr;
|
|
std::vector<KeyRangeRef> result = range - KeyRangeRef(b, e);
|
|
ASSERT(result.size() == 1);
|
|
ASSERT(result[0] == KeyRangeRef("f"_sr, "y"_sr));
|
|
}
|
|
|
|
{
|
|
Key b = "f"_sr;
|
|
Key e = "z"_sr;
|
|
std::vector<KeyRangeRef> result = range - KeyRangeRef(b, e);
|
|
ASSERT(result.size() == 1);
|
|
ASSERT(result[0] == KeyRangeRef("b"_sr, "f"_sr));
|
|
}
|
|
|
|
{
|
|
Key b = "a"_sr;
|
|
Key e = "z"_sr;
|
|
std::vector<KeyRangeRef> result = range - KeyRangeRef(b, e);
|
|
ASSERT(result.size() == 0);
|
|
}
|
|
|
|
return Void();
|
|
}
|
|
|
|
std::string KeyValueStoreType::getStoreTypeStr(const StoreType& storeType) {
|
|
switch (storeType) {
|
|
case SSD_BTREE_V1:
|
|
return "ssd-1";
|
|
case SSD_BTREE_V2:
|
|
return "ssd-2";
|
|
case SSD_REDWOOD_V1:
|
|
return "ssd-redwood-1";
|
|
case SSD_ROCKSDB_V1:
|
|
return "ssd-rocksdb-v1";
|
|
case SSD_SHARDED_ROCKSDB:
|
|
return "ssd-sharded-rocksdb";
|
|
case MEMORY:
|
|
return "memory";
|
|
case MEMORY_RADIXTREE:
|
|
return "memory-radixtree-beta";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
KeyValueStoreType KeyValueStoreType::fromString(const std::string& str) {
|
|
static std::map<std::string, StoreType> names = { { "ssd-1", SSD_BTREE_V1 },
|
|
{ "ssd-2", SSD_BTREE_V2 },
|
|
{ "ssd", SSD_BTREE_V2 },
|
|
{ "redwood", SSD_REDWOOD_V1 },
|
|
{ "ssd-redwood-1", SSD_REDWOOD_V1 },
|
|
{ "ssd-redwood-1-experimental", SSD_REDWOOD_V1 },
|
|
{ "ssd-rocksdb-v1", SSD_ROCKSDB_V1 },
|
|
{ "ssd-sharded-rocksdb", SSD_SHARDED_ROCKSDB },
|
|
{ "memory", MEMORY },
|
|
{ "memory-radixtree-beta", MEMORY_RADIXTREE } };
|
|
auto it = names.find(str);
|
|
if (it == names.end()) {
|
|
throw unknown_storage_engine();
|
|
}
|
|
return it->second;
|
|
}
|