mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-28 05:43:50 +00:00
1d5bddbc58
Summary: This change has two primary goals (follow-up to https://github.com/facebook/rocksdb/issues/11917, https://github.com/facebook/rocksdb/issues/11920): * Ensure the DB seqno_to_time_mapping has entries that allow us to put a good time lower bound on any writes that happen after setting up preserve/preclude options (either in a new DB, new CF, SetOptions, etc.) and haven't yet aged out of that time window. This allows us to remove a bunch of work-arounds in tests. * For new DBs using preserve/preclude options, automatically reserve some sequence numbers and pre-map them to cover the time span back to the preserve/preclude cut-off time. In the future, this will allow us to import data from another DB by key, value, and write time by assigning an appropriate seqno in this DB for that write time. Note that the pre-population (historical mappings) does not happen if the original options at DB Open time do not have preserve/preclude, so it is recommended to create initial column families at that time with create_missing_column_families, to take advantage of this (future) feature. (Adding these historical mappings after DB Open would risk non-monotonic seqno_to_time_mapping, which is dubious if not dangerous.) Recommended follow-up: * Solve existing race conditions (not memory safety) where parallel operations like CreateColumnFamily or SetDBOptions could leave the wrong setting in effect. * Make SeqnoToTimeMapping more gracefully handle a possible case in which too many mappings are added for the time range of concern. It seems like there could be cases where data is massively excluded from the cold tier because of entries falling off the front of the mapping list (causing GetProximalSeqnoBeforeTime() to return 0). (More investigation needed.) No release note for the minor bug fix because this is still an experimental feature with limited usage. Pull Request resolved: https://github.com/facebook/rocksdb/pull/11922 Test Plan: tests added / updated Reviewed By: jowlyzhang Differential Revision: D49956563 Pulled By: pdillinger fbshipit-source-id: 92beb918c3a298fae9ca8e509717b1067caa1519
67 lines
2.4 KiB
C++
67 lines
2.4 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
#pragma once
|
|
|
|
#include <initializer_list>
|
|
#include <memory>
|
|
#include <type_traits>
|
|
|
|
#include "rocksdb/rocksdb_namespace.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
// The helper function to assert the move from dynamic_cast<> to
|
|
// static_cast<> is correct. This function is to deal with legacy code.
|
|
// It is not recommended to add new code to issue class casting. The preferred
|
|
// solution is to implement the functionality without a need of casting.
|
|
template <class DestClass, class SrcClass>
|
|
inline DestClass* static_cast_with_check(SrcClass* x) {
|
|
DestClass* ret = static_cast<DestClass*>(x);
|
|
#ifdef ROCKSDB_USE_RTTI
|
|
assert(ret == dynamic_cast<DestClass*>(x));
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
template <class DestClass, class SrcClass>
|
|
inline std::shared_ptr<DestClass> static_cast_with_check(
|
|
std::shared_ptr<SrcClass>&& x) {
|
|
#if defined(ROCKSDB_USE_RTTI) && !defined(NDEBUG)
|
|
auto orig_raw = x.get();
|
|
#endif
|
|
auto ret = std::static_pointer_cast<DestClass>(std::move(x));
|
|
#if defined(ROCKSDB_USE_RTTI) && !defined(NDEBUG)
|
|
assert(ret.get() == dynamic_cast<DestClass*>(orig_raw));
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
// A wrapper around static_cast for lossless conversion between integral
|
|
// types, including enum types. For example, this can be used for converting
|
|
// between signed/unsigned or enum type and underlying type without fear of
|
|
// stripping away data, now or in the future.
|
|
template <typename To, typename From>
|
|
inline To lossless_cast(From x) {
|
|
using FromValue = typename std::remove_reference<From>::type;
|
|
static_assert(
|
|
std::is_integral<FromValue>::value || std::is_enum<FromValue>::value,
|
|
"Only works on integral types");
|
|
static_assert(std::is_integral<To>::value || std::is_enum<To>::value,
|
|
"Only works on integral types");
|
|
static_assert(sizeof(To) >= sizeof(FromValue), "Must be lossless");
|
|
return static_cast<To>(x);
|
|
}
|
|
|
|
// For disambiguating a potentially heterogeneous aggregate as a homogeneous
|
|
// initializer list. E.g. might be able to write List({x, y}) in some cases
|
|
// instead of std::vector<const Widget&>({x, y}).
|
|
template <typename T>
|
|
inline const std::initializer_list<T>& List(
|
|
const std::initializer_list<T>& list) {
|
|
return list;
|
|
}
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|