ad5325a736
Summary: * New public header unique_id.h and function GetUniqueIdFromTableProperties which computes a universally unique identifier based on table properties of table files from recent RocksDB versions. * Generation of DB session IDs is refactored so that they are guaranteed unique in the lifetime of a process running RocksDB. (SemiStructuredUniqueIdGen, new test included.) Along with file numbers, this enables SST unique IDs to be guaranteed unique among SSTs generated in a single process, and "better than random" between processes. See https://github.com/pdillinger/unique_id * In addition to public API producing 'external' unique IDs, there is a function for producing 'internal' unique IDs, with functions for converting between the two. In short, the external ID is "safe" for things people might do with it, and the internal ID enables more "power user" features for the future. Specifically, the external ID goes through a hashing layer so that any subset of bits in the external ID can be used as a hash of the full ID, while also preserving uniqueness guarantees in the first 128 bits (bijective both on first 128 bits and on full 192 bits). Intended follow-up: * Use the internal unique IDs in cache keys. (Avoid conflicts with https://github.com/facebook/rocksdb/issues/8912) (The file offset can be XORed into the third 64-bit value of the unique ID.) * Publish the external unique IDs in FileStorageInfo (https://github.com/facebook/rocksdb/issues/8968) Pull Request resolved: https://github.com/facebook/rocksdb/pull/8990 Test Plan: Unit tests added, and checking of unique ids in stress test. NOTE in stress test we do not generate nearly enough files to thoroughly stress uniqueness, but the test trims off pieces of the ID to check for uniqueness so that we can infer (with some assumptions) stronger properties in the aggregate. Reviewed By: zhichao-cao, mrambacher Differential Revision: D31582865 Pulled By: pdillinger fbshipit-source-id: 1f620c4c86af9abe2a8d177b9ccf2ad2b9f48243
60 lines
2.6 KiB
C++
60 lines
2.6 KiB
C++
// Copyright (c) Facebook, Inc. and its affiliates. 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 <array>
|
|
|
|
#include "rocksdb/unique_id.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
using UniqueId64x3 = std::array<uint64_t, 3>;
|
|
|
|
// Helper for GetUniqueIdFromTableProperties. This function can also be used
|
|
// for temporary ids for files without sufficient information in table
|
|
// properties. The internal unique id is more structured than the public
|
|
// unique id, so can be manipulated in more ways but very carefully.
|
|
// These must be long term stable to ensure GetUniqueIdFromTableProperties
|
|
// is long term stable.
|
|
Status GetSstInternalUniqueId(const std::string &db_id,
|
|
const std::string &db_session_id,
|
|
uint64_t file_number, UniqueId64x3 *out);
|
|
|
|
// Helper for GetUniqueIdFromTableProperties. External unique ids go through
|
|
// this extra hashing layer so that prefixes of the unique id have predictable
|
|
// "full" entropy. This hashing layer is 1-to-1 on the first 128 bits and on
|
|
// the full 192 bits.
|
|
// This transformation must be long term stable to ensure
|
|
// GetUniqueIdFromTableProperties is long term stable.
|
|
void InternalUniqueIdToExternal(UniqueId64x3 *in_out);
|
|
|
|
// Reverse of InternalUniqueIdToExternal mostly for testing purposes
|
|
// (demonstrably 1-to-1 on the first 128 bits and on the full 192 bits).
|
|
void ExternalUniqueIdToInternal(UniqueId64x3 *in_out);
|
|
|
|
// Convert numerical format to byte format for public API
|
|
std::string EncodeUniqueIdBytes(const UniqueId64x3 &in);
|
|
|
|
// Reformat a random value down to our "DB session id" format,
|
|
// which is intended to be compact and friendly for use in file names.
|
|
// `lower` is fully preserved and data is lost from `upper`.
|
|
//
|
|
// Detail: Encoded into 20 chars in base-36 ([0-9A-Z]), which is ~103 bits of
|
|
// entropy, which is enough to expect no collisions across a billion servers
|
|
// each opening DBs a million times (~2^50). Benefits vs. RFC-4122 unique id:
|
|
// * Save ~ dozen bytes per SST file
|
|
// * Shorter shared backup file names (some platforms have low limits)
|
|
// * Visually distinct from DB id format (usually RFC-4122)
|
|
std::string EncodeSessionId(uint64_t upper, uint64_t lower);
|
|
|
|
// Reverse of EncodeSessionId. Returns NotSupported on error rather than
|
|
// Corruption because non-standard session IDs should be allowed with degraded
|
|
// functionality.
|
|
Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
|
|
uint64_t *lower);
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|