|
|
|
// 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).
|
|
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
//
|
|
|
|
// A Status encapsulates the result of an operation. It may indicate success,
|
|
|
|
// or it may indicate an error with an associated error message.
|
|
|
|
//
|
|
|
|
// Multiple threads can invoke const methods on a Status without
|
|
|
|
// external synchronization, but if any of the threads may call a
|
|
|
|
// non-const method, all threads accessing the same Status must use
|
|
|
|
// external synchronization.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
#include "port/stack_trace.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "rocksdb/slice.h"
|
|
|
|
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
|
|
|
|
class Status {
|
|
|
|
public:
|
|
|
|
// Create a success status.
|
|
|
|
Status() : code_(kOk), subcode_(kNone), sev_(kNoError), state_(nullptr) {}
|
|
|
|
~Status() {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
if (!checked_) {
|
|
|
|
fprintf(stderr, "Failed to check Status\n");
|
|
|
|
port::PrintStack();
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
delete[] state_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Copy the specified status.
|
|
|
|
Status(const Status& s);
|
|
|
|
Status& operator=(const Status& s);
|
|
|
|
Status(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
Status& operator=(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
bool operator==(const Status& rhs) const;
|
|
|
|
bool operator!=(const Status& rhs) const;
|
|
|
|
|
|
|
|
// In case of intentionally swallowing an error, user must explicitly call
|
|
|
|
// this function. That way we are easily able to search the code to find where
|
|
|
|
// error swallowing occurs.
|
|
|
|
void PermitUncheckedError() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
}
|
|
|
|
|
|
|
|
enum Code : unsigned char {
|
|
|
|
kOk = 0,
|
|
|
|
kNotFound = 1,
|
|
|
|
kCorruption = 2,
|
|
|
|
kNotSupported = 3,
|
|
|
|
kInvalidArgument = 4,
|
|
|
|
kIOError = 5,
|
|
|
|
kMergeInProgress = 6,
|
|
|
|
kIncomplete = 7,
|
|
|
|
kShutdownInProgress = 8,
|
|
|
|
kTimedOut = 9,
|
|
|
|
kAborted = 10,
|
|
|
|
kBusy = 11,
|
|
|
|
kExpired = 12,
|
|
|
|
kTryAgain = 13,
|
|
|
|
kCompactionTooLarge = 14,
|
|
|
|
kColumnFamilyDropped = 15,
|
|
|
|
kMaxCode
|
|
|
|
};
|
|
|
|
|
|
|
|
Code code() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code_;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum SubCode : unsigned char {
|
|
|
|
kNone = 0,
|
|
|
|
kMutexTimeout = 1,
|
|
|
|
kLockTimeout = 2,
|
|
|
|
kLockLimit = 3,
|
|
|
|
kNoSpace = 4,
|
|
|
|
kDeadlock = 5,
|
|
|
|
kStaleFile = 6,
|
|
|
|
kMemoryLimit = 7,
|
|
|
|
kSpaceLimit = 8,
|
|
|
|
kPathNotFound = 9,
|
New API to get all merge operands for a Key (#5604)
Summary:
This is a new API added to db.h to allow for fetching all merge operands associated with a Key. The main motivation for this API is to support use cases where doing a full online merge is not necessary as it is performance sensitive. Example use-cases:
1. Update subset of columns and read subset of columns -
Imagine a SQL Table, a row is encoded as a K/V pair (as it is done in MyRocks). If there are many columns and users only updated one of them, we can use merge operator to reduce write amplification. While users only read one or two columns in the read query, this feature can avoid a full merging of the whole row, and save some CPU.
2. Updating very few attributes in a value which is a JSON-like document -
Updating one attribute can be done efficiently using merge operator, while reading back one attribute can be done more efficiently if we don't need to do a full merge.
----------------------------------------------------------------------------------------------------
API :
Status GetMergeOperands(
const ReadOptions& options, ColumnFamilyHandle* column_family,
const Slice& key, PinnableSlice* merge_operands,
GetMergeOperandsOptions* get_merge_operands_options,
int* number_of_operands)
Example usage :
int size = 100;
int number_of_operands = 0;
std::vector<PinnableSlice> values(size);
GetMergeOperandsOptions merge_operands_info;
db_->GetMergeOperands(ReadOptions(), db_->DefaultColumnFamily(), "k1", values.data(), merge_operands_info, &number_of_operands);
Description :
Returns all the merge operands corresponding to the key. If the number of merge operands in DB is greater than merge_operands_options.expected_max_number_of_operands no merge operands are returned and status is Incomplete. Merge operands returned are in the order of insertion.
merge_operands-> Points to an array of at-least merge_operands_options.expected_max_number_of_operands and the caller is responsible for allocating it. If the status returned is Incomplete then number_of_operands will contain the total number of merge operands found in DB for key.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5604
Test Plan:
Added unit test and perf test in db_bench that can be run using the command:
./db_bench -benchmarks=getmergeoperands --merge_operator=sortlist
Differential Revision: D16657366
Pulled By: vjnadimpalli
fbshipit-source-id: 0faadd752351745224ee12d4ae9ef3cb529951bf
5 years ago
|
|
|
KMergeOperandsInsufficientCapacity = 10,
|
|
|
|
kManualCompactionPaused = 11,
|
|
|
|
kOverwritten = 12,
|
|
|
|
kTxnNotPrepared = 13,
|
|
|
|
kIOFenced = 14,
|
|
|
|
kMaxSubCode
|
|
|
|
};
|
|
|
|
|
|
|
|
SubCode subcode() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return subcode_;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum Severity : unsigned char {
|
|
|
|
kNoError = 0,
|
|
|
|
kSoftError = 1,
|
|
|
|
kHardError = 2,
|
|
|
|
kFatalError = 3,
|
|
|
|
kUnrecoverableError = 4,
|
|
|
|
kMaxSeverity
|
|
|
|
};
|
|
|
|
|
|
|
|
Status(const Status& s, Severity sev);
|
|
|
|
Severity severity() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return sev_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a C style string indicating the message of the Status
|
|
|
|
const char* getState() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return state_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return a success status.
|
|
|
|
static Status OK() { return Status(); }
|
|
|
|
|
|
|
|
// Successful, though an existing something was overwritten
|
|
|
|
// Note: using variants of OK status for program logic is discouraged,
|
|
|
|
// but it can be useful for communicating statistical information without
|
|
|
|
// changing public APIs.
|
|
|
|
static Status OkOverwritten() { return Status(kOk, kOverwritten); }
|
|
|
|
|
|
|
|
// Return error status of an appropriate type.
|
|
|
|
static Status NotFound(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kNotFound, msg, msg2);
|
|
|
|
}
|
|
|
|
// Fast path for not found without malloc;
|
|
|
|
static Status NotFound(SubCode msg = kNone) { return Status(kNotFound, msg); }
|
|
|
|
|
|
|
|
static Status Corruption(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kCorruption, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status Corruption(SubCode msg = kNone) {
|
|
|
|
return Status(kCorruption, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status NotSupported(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kNotSupported, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status NotSupported(SubCode msg = kNone) {
|
|
|
|
return Status(kNotSupported, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status InvalidArgument(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kInvalidArgument, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status InvalidArgument(SubCode msg = kNone) {
|
|
|
|
return Status(kInvalidArgument, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status IOError(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status IOError(SubCode msg = kNone) { return Status(kIOError, msg); }
|
|
|
|
|
|
|
|
static Status MergeInProgress(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kMergeInProgress, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status MergeInProgress(SubCode msg = kNone) {
|
|
|
|
return Status(kMergeInProgress, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Incomplete(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIncomplete, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status Incomplete(SubCode msg = kNone) {
|
|
|
|
return Status(kIncomplete, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status ShutdownInProgress(SubCode msg = kNone) {
|
|
|
|
return Status(kShutdownInProgress, msg);
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
}
|
|
|
|
static Status ShutdownInProgress(const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kShutdownInProgress, msg, msg2);
|
|
|
|
}
|
|
|
|
static Status Aborted(SubCode msg = kNone) { return Status(kAborted, msg); }
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
static Status Aborted(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kAborted, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Busy(SubCode msg = kNone) { return Status(kBusy, msg); }
|
|
|
|
static Status Busy(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kBusy, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status TimedOut(SubCode msg = kNone) { return Status(kTimedOut, msg); }
|
Pessimistic Transactions
Summary:
Initial implementation of Pessimistic Transactions. This diff contains the api changes discussed in D38913. This diff is pretty large, so let me know if people would prefer to meet up to discuss it.
MyRocks folks: please take a look at the API in include/rocksdb/utilities/transaction[_db].h and let me know if you have any issues.
Also, you'll notice a couple of TODOs in the implementation of RollbackToSavePoint(). After chatting with Siying, I'm going to send out a separate diff for an alternate implementation of this feature that implements the rollback inside of WriteBatch/WriteBatchWithIndex. We can then decide which route is preferable.
Next, I'm planning on doing some perf testing and then integrating this diff into MongoRocks for further testing.
Test Plan: Unit tests, db_bench parallel testing.
Reviewers: igor, rven, sdong, yhchiang, yoshinorim
Reviewed By: sdong
Subscribers: hermanlee4, maykov, spetrunia, leveldb, dhruba
Differential Revision: https://reviews.facebook.net/D40869
9 years ago
|
|
|
static Status TimedOut(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kTimedOut, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status Expired(SubCode msg = kNone) { return Status(kExpired, msg); }
|
|
|
|
static Status Expired(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kExpired, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status TryAgain(SubCode msg = kNone) { return Status(kTryAgain, msg); }
|
|
|
|
static Status TryAgain(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kTryAgain, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status CompactionTooLarge(SubCode msg = kNone) {
|
|
|
|
return Status(kCompactionTooLarge, msg);
|
|
|
|
}
|
|
|
|
static Status CompactionTooLarge(const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kCompactionTooLarge, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status ColumnFamilyDropped(SubCode msg = kNone) {
|
|
|
|
return Status(kColumnFamilyDropped, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status ColumnFamilyDropped(const Slice& msg,
|
|
|
|
const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kColumnFamilyDropped, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status NoSpace() { return Status(kIOError, kNoSpace); }
|
|
|
|
static Status NoSpace(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, kNoSpace, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status MemoryLimit() { return Status(kAborted, kMemoryLimit); }
|
|
|
|
static Status MemoryLimit(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kAborted, kMemoryLimit, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status SpaceLimit() { return Status(kIOError, kSpaceLimit); }
|
|
|
|
static Status SpaceLimit(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, kSpaceLimit, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status PathNotFound() { return Status(kIOError, kPathNotFound); }
|
|
|
|
static Status PathNotFound(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kIOError, kPathNotFound, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status TxnNotPrepared() {
|
|
|
|
return Status(kInvalidArgument, kTxnNotPrepared);
|
|
|
|
}
|
|
|
|
static Status TxnNotPrepared(const Slice& msg, const Slice& msg2 = Slice()) {
|
|
|
|
return Status(kInvalidArgument, kTxnNotPrepared, msg, msg2);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates success.
|
|
|
|
bool ok() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kOk;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates success *with* something
|
|
|
|
// overwritten
|
|
|
|
bool IsOkOverwritten() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kOk && subcode() == kOverwritten;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a NotFound error.
|
|
|
|
bool IsNotFound() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kNotFound;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a Corruption error.
|
|
|
|
bool IsCorruption() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kCorruption;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a NotSupported error.
|
|
|
|
bool IsNotSupported() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kNotSupported;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates an InvalidArgument error.
|
|
|
|
bool IsInvalidArgument() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kInvalidArgument;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates an IOError.
|
|
|
|
bool IsIOError() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kIOError;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates an MergeInProgress.
|
|
|
|
bool IsMergeInProgress() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kMergeInProgress;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates Incomplete
|
|
|
|
bool IsIncomplete() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kIncomplete;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates Shutdown In progress
|
|
|
|
bool IsShutdownInProgress() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kShutdownInProgress;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsTimedOut() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kTimedOut;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsAborted() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kAborted;
|
|
|
|
}
|
CompactFiles, EventListener and GetDatabaseMetaData
Summary:
This diff adds three sets of APIs to RocksDB.
= GetColumnFamilyMetaData =
* This APIs allow users to obtain the current state of a RocksDB instance on one column family.
* See GetColumnFamilyMetaData in include/rocksdb/db.h
= EventListener =
* A virtual class that allows users to implement a set of
call-back functions which will be called when specific
events of a RocksDB instance happens.
* To register EventListener, simply insert an EventListener to ColumnFamilyOptions::listeners
= CompactFiles =
* CompactFiles API inputs a set of file numbers and an output level, and RocksDB
will try to compact those files into the specified level.
= Example =
* Example code can be found in example/compact_files_example.cc, which implements
a simple external compactor using EventListener, GetColumnFamilyMetaData, and
CompactFiles API.
Test Plan:
listener_test
compactor_test
example/compact_files_example
export ROCKSDB_TESTS=CompactFiles
db_test
export ROCKSDB_TESTS=MetaData
db_test
Reviewers: ljin, igor, rven, sdong
Reviewed By: sdong
Subscribers: MarkCallaghan, dhruba, leveldb
Differential Revision: https://reviews.facebook.net/D24705
10 years ago
|
|
|
|
|
|
|
bool IsLockLimit() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kAborted && subcode() == kLockLimit;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates that a resource is Busy and
|
|
|
|
// temporarily could not be acquired.
|
|
|
|
bool IsBusy() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kBusy;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsDeadlock() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kBusy && subcode() == kDeadlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicated that the operation has Expired.
|
|
|
|
bool IsExpired() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kExpired;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a TryAgain error.
|
|
|
|
// This usually means that the operation failed, but may succeed if
|
|
|
|
// re-attempted.
|
|
|
|
bool IsTryAgain() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kTryAgain;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates the proposed compaction is too large
|
|
|
|
bool IsCompactionTooLarge() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kCompactionTooLarge;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates Column Family Dropped
|
|
|
|
bool IsColumnFamilyDropped() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return code() == kColumnFamilyDropped;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a NoSpace error
|
|
|
|
// This is caused by an I/O error returning the specific "out of space"
|
|
|
|
// error condition. Stricto sensu, an NoSpace error is an I/O error
|
|
|
|
// with a specific subcode, enabling users to take the appropriate action
|
|
|
|
// if needed
|
|
|
|
bool IsNoSpace() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code() == kIOError) && (subcode() == kNoSpace);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a memory limit error. There may be
|
|
|
|
// cases where we limit the memory used in certain operations (eg. the size
|
|
|
|
// of a write batch) in order to avoid out of memory exceptions.
|
|
|
|
bool IsMemoryLimit() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code() == kAborted) && (subcode() == kMemoryLimit);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a PathNotFound error
|
|
|
|
// This is caused by an I/O error returning the specific "no such file or
|
|
|
|
// directory" error condition. A PathNotFound error is an I/O error with
|
|
|
|
// a specific subcode, enabling users to take appropriate action if necessary
|
|
|
|
bool IsPathNotFound() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code() == kIOError) && (subcode() == kPathNotFound);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates manual compaction paused. This
|
|
|
|
// is caused by a call to PauseManualCompaction
|
|
|
|
bool IsManualCompactionPaused() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code() == kIncomplete) && (subcode() == kManualCompactionPaused);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a TxnNotPrepared error.
|
|
|
|
bool IsTxnNotPrepared() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code() == kInvalidArgument) && (subcode() == kTxnNotPrepared);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true iff the status indicates a IOFenced error.
|
|
|
|
bool IsIOFenced() const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code() == kIOError) && (subcode() == kIOFenced);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return a string representation of this status suitable for printing.
|
|
|
|
// Returns the string "OK" for success.
|
|
|
|
std::string ToString() const;
|
|
|
|
|
Introduce a new storage specific Env API (#5761)
Summary:
The current Env API encompasses both storage/file operations, as well as OS related operations. Most of the APIs return a Status, which does not have enough metadata about an error, such as whether its retry-able or not, scope (i.e fault domain) of the error etc., that may be required in order to properly handle a storage error. The file APIs also do not provide enough control over the IO SLA, such as timeout, prioritization, hinting about placement and redundancy etc.
This PR separates out the file/storage APIs from Env into a new FileSystem class. The APIs are updated to return an IOStatus with metadata about the error, as well as to take an IOOptions structure as input in order to allow more control over the IO.
The user can set both ```options.env``` and ```options.file_system``` to specify that RocksDB should use the former for OS related operations and the latter for storage operations. Internally, a ```CompositeEnvWrapper``` has been introduced that inherits from ```Env``` and redirects individual methods to either an ```Env``` implementation or the ```FileSystem``` as appropriate. When options are sanitized during ```DB::Open```, ```options.env``` is replaced with a newly allocated ```CompositeEnvWrapper``` instance if both env and file_system have been specified. This way, the rest of the RocksDB code can continue to function as before.
This PR also ports PosixEnv to the new API by splitting it into two - PosixEnv and PosixFileSystem. PosixEnv is defined as a sub-class of CompositeEnvWrapper, and threading/time functions are overridden with Posix specific implementations in order to avoid an extra level of indirection.
The ```CompositeEnvWrapper``` translates ```IOStatus``` return code to ```Status```, and sets the severity to ```kSoftError``` if the io_status is retryable. The error handling code in RocksDB can then recover the DB automatically.
Pull Request resolved: https://github.com/facebook/rocksdb/pull/5761
Differential Revision: D18868376
Pulled By: anand1976
fbshipit-source-id: 39efe18a162ea746fabac6360ff529baba48486f
5 years ago
|
|
|
protected:
|
|
|
|
// A nullptr state_ (which is always the case for OK) means the message
|
|
|
|
// is empty.
|
|
|
|
// of the following form:
|
|
|
|
// state_[0..3] == length of message
|
|
|
|
// state_[4..] == message
|
|
|
|
Code code_;
|
|
|
|
SubCode subcode_;
|
|
|
|
Severity sev_;
|
|
|
|
const char* state_;
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
mutable bool checked_ = false;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
|
|
|
|
explicit Status(Code _code, SubCode _subcode = kNone)
|
|
|
|
: code_(_code), subcode_(_subcode), sev_(kNoError), state_(nullptr) {}
|
|
|
|
|
|
|
|
Status(Code _code, SubCode _subcode, const Slice& msg, const Slice& msg2);
|
|
|
|
Status(Code _code, const Slice& msg, const Slice& msg2)
|
|
|
|
: Status(_code, kNone, msg, msg2) {}
|
|
|
|
|
|
|
|
static const char* CopyState(const char* s);
|
|
|
|
};
|
|
|
|
|
|
|
|
inline Status::Status(const Status& s)
|
|
|
|
: code_(s.code_), subcode_(s.subcode_), sev_(s.sev_) {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
s.checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_);
|
|
|
|
}
|
|
|
|
inline Status::Status(const Status& s, Severity sev)
|
|
|
|
: code_(s.code_), subcode_(s.subcode_), sev_(sev) {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
s.checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_);
|
|
|
|
}
|
|
|
|
inline Status& Status::operator=(const Status& s) {
|
|
|
|
if (this != &s) {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
s.checked_ = true;
|
|
|
|
checked_ = false;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
code_ = s.code_;
|
|
|
|
subcode_ = s.subcode_;
|
|
|
|
sev_ = s.sev_;
|
|
|
|
delete[] state_;
|
|
|
|
state_ = (s.state_ == nullptr) ? nullptr : CopyState(s.state_);
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Status::Status(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
: Status() {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
s.checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
*this = std::move(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Status& Status::operator=(Status&& s)
|
|
|
|
#if !(defined _MSC_VER) || ((defined _MSC_VER) && (_MSC_VER >= 1900))
|
|
|
|
noexcept
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
if (this != &s) {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
s.checked_ = true;
|
|
|
|
checked_ = false;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
code_ = std::move(s.code_);
|
|
|
|
s.code_ = kOk;
|
|
|
|
subcode_ = std::move(s.subcode_);
|
|
|
|
s.subcode_ = kNone;
|
|
|
|
sev_ = std::move(s.sev_);
|
|
|
|
s.sev_ = kNoError;
|
|
|
|
delete[] state_;
|
|
|
|
state_ = nullptr;
|
|
|
|
std::swap(state_, s.state_);
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool Status::operator==(const Status& rhs) const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
rhs.checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return (code_ == rhs.code_);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool Status::operator!=(const Status& rhs) const {
|
|
|
|
#ifdef ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
checked_ = true;
|
|
|
|
rhs.checked_ = true;
|
|
|
|
#endif // ROCKSDB_ASSERT_STATUS_CHECKED
|
|
|
|
return !(*this == rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|