dolysis
/
rocksdb
mirror of https://github.com/facebook/rocksdb.git
3
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix lint errors and coding style of ldb related codes. 

Summary: Fix lint errors and coding style of ldb related codes.

Test Plan: ./ldb

Reviewers: ljin, sdong, igor

Reviewed By: igor

Subscribers: dhruba, leveldb

Differential Revision: https://reviews.facebook.net/D28125
This commit is contained in:
Yueh-Hsuan Chiang 2014-10-31 15:01:39 -07:00
parent c645250ee0
commit bc9f36fd5e
5 changed files with 741 additions and 674 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tools/sst_dump.cc
View File

@ -275,8 +275,8 @@ static void print_help() {
}
namespace {
string HexToString(const string& str) {
string parsed;
std::string HexToString(const std::string& str) {
std::string parsed;
if (str[0] != '0' || str[1] != 'x') {
fprintf(stderr, "Invalid hex input %s. Must start with 0x\n",
str.c_str());

904
util/ldb_cmd.cc
View File

File diff suppressed because it is too large Load Diff

465
util/ldb_cmd.h
View File

@ -4,12 +4,15 @@
// of patent rights can be found in the PATENTS file in the same directory.
//
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <algorithm>
#include <stdio.h>
#include <map>
#include <vector>
#include <utility>
#include "db/version_set.h"
#include "rocksdb/env.h"
@ -23,39 +26,34 @@
#include "util/string_util.h"
#include "utilities/ttl/db_ttl_impl.h"
using std::string;
using std::map;
using std::vector;
using std::ostringstream;
namespace rocksdb {
class LDBCommand {
public:
public:
// Command-line arguments
static const string ARG_DB;
static const string ARG_HEX;
static const string ARG_KEY_HEX;
static const string ARG_VALUE_HEX;
static const string ARG_TTL;
static const string ARG_TTL_START;
static const string ARG_TTL_END;
static const string ARG_TIMESTAMP;
static const string ARG_FROM;
static const string ARG_TO;
static const string ARG_MAX_KEYS;
static const string ARG_BLOOM_BITS;
static const string ARG_FIX_PREFIX_LEN;
static const string ARG_COMPRESSION_TYPE;
static const string ARG_BLOCK_SIZE;
static const string ARG_AUTO_COMPACTION;
static const string ARG_WRITE_BUFFER_SIZE;
static const string ARG_FILE_SIZE;
static const string ARG_CREATE_IF_MISSING;
static const std::string ARG_DB;
static const std::string ARG_HEX;
static const std::string ARG_KEY_HEX;
static const std::string ARG_VALUE_HEX;
static const std::string ARG_TTL;
static const std::string ARG_TTL_START;
static const std::string ARG_TTL_END;
static const std::string ARG_TIMESTAMP;
static const std::string ARG_FROM;
static const std::string ARG_TO;
static const std::string ARG_MAX_KEYS;
static const std::string ARG_BLOOM_BITS;
static const std::string ARG_FIX_PREFIX_LEN;
static const std::string ARG_COMPRESSION_TYPE;
static const std::string ARG_BLOCK_SIZE;
static const std::string ARG_AUTO_COMPACTION;
static const std::string ARG_WRITE_BUFFER_SIZE;
static const std::string ARG_FILE_SIZE;
static const std::string ARG_CREATE_IF_MISSING;
static LDBCommand* InitFromCmdLineArgs(
const vector<string>& args,
const std::vector<std::string>& args,
const Options& options,
const LDBOptions& ldb_options
);
@ -123,8 +121,8 @@ public:
exec_state_.Reset();
}
static string HexToString(const string& str) {
string parsed;
static std::string HexToString(const std::string& str) {
std::string parsed;
if (str[0] != '0' || str[1] != 'x') {
fprintf(stderr, "Invalid hex input %s. Must start with 0x\n",
str.c_str());
@ -140,8 +138,8 @@ public:
return parsed;
}
static string StringToHex(const string& str) {
string result = "0x";
static std::string StringToHex(const std::string& str) {
std::string result = "0x";
char buf[10];
for (size_t i = 0; i < str.length(); i++) {
snprintf(buf, 10, "%02X", (unsigned char)str[i]);
@ -155,7 +153,7 @@ public:
protected:
LDBCommandExecuteResult exec_state_;
string db_path_;
std::string db_path_;
DB* db_;
DBWithTTL* db_ttl_;
@ -180,21 +178,24 @@ protected:
/**
* Map of options passed on the command-line.
*/
const map<string, string> option_map_;
const std::map<std::string, std::string> option_map_;
/**
* Flags passed on the command-line.
*/
const vector<string> flags_;
const std::vector<std::string> flags_;
/** List of command-line options valid for this command */
const vector<string> valid_cmd_line_options_;
const std::vector<std::string> valid_cmd_line_options_;
bool ParseKeyValue(const string& line, string* key, string* value,
bool is_key_hex, bool is_value_hex);
bool ParseKeyValue(const std::string& line,
std::string* key, std::string* value,
bool is_key_hex, bool is_value_hex);
LDBCommand(const map<string, string>& options, const vector<string>& flags,
bool is_read_only, const vector<string>& valid_cmd_line_options) :
LDBCommand(const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags,
bool is_read_only,
const std::vector<std::string>& valid_cmd_line_options) :
db_(nullptr),
is_read_only_(is_read_only),
is_key_hex_(false),
@ -205,7 +206,7 @@ protected:
flags_(flags),
valid_cmd_line_options_(valid_cmd_line_options) {
map<string, string>::const_iterator itr = options.find(ARG_DB);
auto itr = options.find(ARG_DB);
if (itr != options.end()) {
db_path_ = itr->second;
}
@ -236,7 +237,7 @@ protected:
st = DB::Open(opt, db_path_, &db_);
}
if (!st.ok()) {
string msg = st.ToString();
std::string msg = st.ToString();
exec_state_ = LDBCommandExecuteResult::FAILED(msg);
}
@ -250,29 +251,33 @@ protected:
}
}
static string PrintKeyValue(const string& key, const string& value,
bool is_key_hex, bool is_value_hex) {
string result;
static std::string PrintKeyValue(
const std::string& key, const std::string& value,
bool is_key_hex, bool is_value_hex) {
std::string result;
result.append(is_key_hex ? StringToHex(key) : key);
result.append(DELIM);
result.append(is_value_hex ? StringToHex(value) : value);
return result;
}
static string PrintKeyValue(const string& key, const string& value,
bool is_hex) {
static std::string PrintKeyValue(
const std::string& key, const std::string& value,
bool is_hex) {
return PrintKeyValue(key, value, is_hex, is_hex);
}
/**
* Return true if the specified flag is present in the specified flags vector
* Return true if the specified flag is present in the specified
* flags vector
*/
static bool IsFlagPresent(const vector<string>& flags, const string& flag) {
static bool IsFlagPresent(
const std::vector<std::string>& flags, const std::string& flag) {
return (std::find(flags.begin(), flags.end(), flag) != flags.end());
}
static string HelpRangeCmdArgs() {
ostringstream str_stream;
static std::string HelpRangeCmdArgs() {
std::ostringstream str_stream;
str_stream << " ";
str_stream << "[--" << ARG_FROM << "] ";
str_stream << "[--" << ARG_TO << "] ";
@ -284,32 +289,35 @@ protected:
* used by this command. It includes the common options and the ones
* passed in.
*/
vector<string> BuildCmdLineOptions(vector<string> options) {
vector<string> ret = {ARG_DB, ARG_BLOOM_BITS,
ARG_BLOCK_SIZE, ARG_AUTO_COMPACTION,
ARG_COMPRESSION_TYPE, ARG_WRITE_BUFFER_SIZE,
ARG_FILE_SIZE, ARG_FIX_PREFIX_LEN};
std::vector<std::string> BuildCmdLineOptions(
std::vector<std::string> options) {
std::vector<std::string> ret = {
ARG_DB, ARG_BLOOM_BITS,
ARG_BLOCK_SIZE, ARG_AUTO_COMPACTION,
ARG_COMPRESSION_TYPE, ARG_WRITE_BUFFER_SIZE,
ARG_FILE_SIZE, ARG_FIX_PREFIX_LEN};
ret.insert(ret.end(), options.begin(), options.end());
return ret;
}
bool ParseIntOption(const map<string, string>& options, const string& option,
int& value, LDBCommandExecuteResult& exec_state);
bool ParseIntOption(const std::map<std::string, std::string>& options,
const std::string& option,
int* value, LDBCommandExecuteResult* exec_state);
bool ParseStringOption(const map<string, string>& options,
const string& option, string* value);
bool ParseStringOption(const std::map<std::string, std::string>& options,
const std::string& option, std::string* value);
Options options_;
LDBOptions ldb_options_;
private:
private:
/**
* Interpret command line options and flags to determine if the key
* should be input/output in hex.
*/
bool IsKeyHex(const map<string, string>& options,
const vector<string>& flags) {
bool IsKeyHex(const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags) {
return (IsFlagPresent(flags, ARG_HEX) ||
IsFlagPresent(flags, ARG_KEY_HEX) ||
ParseBooleanOption(options, ARG_HEX, false) ||
@ -320,8 +328,8 @@ private:
* Interpret command line options and flags to determine if the value
* should be input/output in hex.
*/
bool IsValueHex(const map<string, string>& options,
const vector<string>& flags) {
bool IsValueHex(const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags) {
return (IsFlagPresent(flags, ARG_HEX) ||
IsFlagPresent(flags, ARG_VALUE_HEX) ||
ParseBooleanOption(options, ARG_HEX, false) ||
@ -334,12 +342,13 @@ private:
* Throws an exception if the value of the option is not
* "true" or "false" (case insensitive).
*/
bool ParseBooleanOption(const map<string, string>& options,
const string& option, bool default_val) {
bool ParseBooleanOption(
const std::map<std::string, std::string>& options,
const std::string& option, bool default_val) {
map<string, string>::const_iterator itr = options.find(option);
auto itr = options.find(option);
if (itr != options.end()) {
string option_val = itr->second;
std::string option_val = itr->second;
return StringToBool(itr->second);
}
return default_val;
@ -350,7 +359,7 @@ private:
* val must be either true or false (case insensitive).
* Otherwise an exception is thrown.
*/
bool StringToBool(string val) {
bool StringToBool(std::string val) {
std::transform(val.begin(), val.end(), val.begin(), ::tolower);
if (val == "true") {
return true;
@ -362,161 +371,165 @@ private:
}
static LDBCommand* SelectCommand(
const string& cmd,
const vector<string>& cmdParams,
const map<string, string>& option_map,
const vector<string>& flags
const std::string& cmd,
const std::vector<std::string>& cmdParams,
const std::map<std::string, std::string>& option_map,
const std::vector<std::string>& flags
);
};
class CompactorCommand: public LDBCommand {
public:
static string Name() { return "compact"; }
public:
static std::string Name() { return "compact"; }
CompactorCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
CompactorCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
private:
private:
bool null_from_;
string from_;
std::string from_;
bool null_to_;
string to_;
std::string to_;
};
class DBDumperCommand: public LDBCommand {
public:
static string Name() { return "dump"; }
public:
static std::string Name() { return "dump"; }
DBDumperCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
DBDumperCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
private:
private:
bool null_from_;
string from_;
std::string from_;
bool null_to_;
string to_;
int max_keys_;
string delim_;
std::string to_;
uint64_t max_keys_;
std::string delim_;
bool count_only_;
bool count_delim_;
bool print_stats_;
static const string ARG_COUNT_ONLY;
static const string ARG_COUNT_DELIM;
static const string ARG_STATS;
static const string ARG_TTL_BUCKET;
static const std::string ARG_COUNT_ONLY;
static const std::string ARG_COUNT_DELIM;
static const std::string ARG_STATS;
static const std::string ARG_TTL_BUCKET;
};
class InternalDumpCommand: public LDBCommand {
public:
static string Name() { return "idump"; }
public:
static std::string Name() { return "idump"; }
InternalDumpCommand(const vector<string>& params,
const map<string, string>& options,
const vector<string>& flags);
InternalDumpCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
private:
private:
bool has_from_;
string from_;
std::string from_;
bool has_to_;
string to_;
std::string to_;
int max_keys_;
string delim_;
std::string delim_;
bool count_only_;
bool count_delim_;
bool print_stats_;
bool is_input_key_hex_;
static const string ARG_DELIM;
static const string ARG_COUNT_ONLY;
static const string ARG_COUNT_DELIM;
static const string ARG_STATS;
static const string ARG_INPUT_KEY_HEX;
static const std::string ARG_DELIM;
static const std::string ARG_COUNT_ONLY;
static const std::string ARG_COUNT_DELIM;
static const std::string ARG_STATS;
static const std::string ARG_INPUT_KEY_HEX;
};
class DBLoaderCommand: public LDBCommand {
public:
static string Name() { return "load"; }
public:
static std::string Name() { return "load"; }
DBLoaderCommand(string& db_name, vector<string>& args);
DBLoaderCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
DBLoaderCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
virtual Options PrepareOptionsForOpenDB();
private:
private:
bool create_if_missing_;
bool disable_wal_;
bool bulk_load_;
bool compact_;
static const string ARG_DISABLE_WAL;
static const string ARG_BULK_LOAD;
static const string ARG_COMPACT;
static const std::string ARG_DISABLE_WAL;
static const std::string ARG_BULK_LOAD;
static const std::string ARG_COMPACT;
};
class ManifestDumpCommand: public LDBCommand {
public:
static string Name() { return "manifest_dump"; }
public:
static std::string Name() { return "manifest_dump"; }
ManifestDumpCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
ManifestDumpCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
virtual bool NoDBOpen() {
return true;
}
private:
private:
bool verbose_;
string path_;
std::string path_;
static const string ARG_VERBOSE;
static const string ARG_PATH;
static const std::string ARG_VERBOSE;
static const std::string ARG_PATH;
};
class ListColumnFamiliesCommand : public LDBCommand {
public:
static string Name() { return "list_column_families"; }
static std::string Name() { return "list_column_families"; }
ListColumnFamiliesCommand(const vector<string>& params,
const map<string, string>& options,
const vector<string>& flags);
ListColumnFamiliesCommand(
const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
virtual bool NoDBOpen() { return true; }
private:
string dbname_;
std::string dbname_;
};
class ReduceDBLevelsCommand : public LDBCommand {
public:
static string Name() { return "reduce_levels"; }
public:
static std::string Name() { return "reduce_levels"; }
ReduceDBLevelsCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
ReduceDBLevelsCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual Options PrepareOptionsForOpenDB();
@ -526,169 +539,179 @@ public:
return true;
}
static void Help(string& msg);
static void Help(std::string* msg);
static vector<string> PrepareArgs(const string& db_path, int new_levels,
static std::vector<std::string> PrepareArgs(
const std::string& db_path,
int new_levels,
bool print_old_level = false);
private:
private:
int old_levels_;
int new_levels_;
bool print_old_levels_;
static const string ARG_NEW_LEVELS;
static const string ARG_PRINT_OLD_LEVELS;
static const std::string ARG_NEW_LEVELS;
static const std::string ARG_PRINT_OLD_LEVELS;
Status GetOldNumOfLevels(Options& opt, int* levels);
};
class ChangeCompactionStyleCommand : public LDBCommand {
public:
static string Name() { return "change_compaction_style"; }
public:
static std::string Name() { return "change_compaction_style"; }
ChangeCompactionStyleCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
ChangeCompactionStyleCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual Options PrepareOptionsForOpenDB();
virtual void DoCommand();
static void Help(string& msg);
static void Help(std::string* msg);
private:
private:
int old_compaction_style_;
int new_compaction_style_;
static const string ARG_OLD_COMPACTION_STYLE;
static const string ARG_NEW_COMPACTION_STYLE;
static const std::string ARG_OLD_COMPACTION_STYLE;
static const std::string ARG_NEW_COMPACTION_STYLE;
};
class WALDumperCommand : public LDBCommand {
public:
static string Name() { return "dump_wal"; }
public:
static std::string Name() { return "dump_wal"; }
WALDumperCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
WALDumperCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual bool NoDBOpen() {
return true;
}
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
private:
private:
bool print_header_;
string wal_file_;
std::string wal_file_;
bool print_values_;
static const string ARG_WAL_FILE;
static const string ARG_PRINT_HEADER;
static const string ARG_PRINT_VALUE;
static const std::string ARG_WAL_FILE;
static const std::string ARG_PRINT_HEADER;
static const std::string ARG_PRINT_VALUE;
};
class GetCommand : public LDBCommand {
public:
static string Name() { return "get"; }
public:
static std::string Name() { return "get"; }
GetCommand(const vector<string>& params, const map<string, string>& options,
const vector<string>& flags);
GetCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
static void Help(string& ret);
static void Help(std::string* ret);
private:
string key_;
private:
std::string key_;
};
class ApproxSizeCommand : public LDBCommand {
public:
static string Name() { return "approxsize"; }
public:
static std::string Name() { return "approxsize"; }
ApproxSizeCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
ApproxSizeCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
static void Help(string& ret);
static void Help(std::string* ret);
private:
string start_key_;
string end_key_;
private:
std::string start_key_;
std::string end_key_;
};
class BatchPutCommand : public LDBCommand {
public:
static string Name() { return "batchput"; }
public:
static std::string Name() { return "batchput"; }
BatchPutCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
BatchPutCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
static void Help(string& ret);
static void Help(std::string* ret);
virtual Options PrepareOptionsForOpenDB();
private:
private:
/**
* The key-values to be inserted.
*/
vector<std::pair<string, string>> key_values_;
std::vector<std::pair<std::string, std::string>> key_values_;
};
class ScanCommand : public LDBCommand {
public:
static string Name() { return "scan"; }
public:
static std::string Name() { return "scan"; }
ScanCommand(const vector<string>& params, const map<string, string>& options,
const vector<string>& flags);
ScanCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
static void Help(string& ret);
static void Help(std::string* ret);
private:
string start_key_;
string end_key_;
private:
std::string start_key_;
std::string end_key_;
bool start_key_specified_;
bool end_key_specified_;
int max_keys_scanned_;
};
class DeleteCommand : public LDBCommand {
public:
static string Name() { return "delete"; }
public:
static std::string Name() { return "delete"; }
DeleteCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
DeleteCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
static void Help(string& ret);
static void Help(std::string* ret);
private:
string key_;
private:
std::string key_;
};
class PutCommand : public LDBCommand {
public:
static string Name() { return "put"; }
public:
static std::string Name() { return "put"; }
PutCommand(const vector<string>& params, const map<string, string>& options,
const vector<string>& flags);
PutCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
static void Help(string& ret);
static void Help(std::string* ret);
virtual Options PrepareOptionsForOpenDB();
private:
string key_;
string value_;
private:
std::string key_;
std::string value_;
};
/**
@ -696,17 +719,18 @@ private:
* get/put/delete.
*/
class DBQuerierCommand: public LDBCommand {
public:
static string Name() { return "query"; }
public:
static std::string Name() { return "query"; }
DBQuerierCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
DBQuerierCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
static void Help(string& ret);
static void Help(std::string* ret);
virtual void DoCommand();
private:
private:
static const char* HELP_CMD;
static const char* GET_CMD;
static const char* PUT_CMD;
@ -714,11 +738,12 @@ private:
};
class CheckConsistencyCommand : public LDBCommand {
public:
static string Name() { return "checkconsistency"; }
public:
static std::string Name() { return "checkconsistency"; }
CheckConsistencyCommand(const vector<string>& params,
const map<string, string>& options, const vector<string>& flags);
CheckConsistencyCommand(const std::vector<std::string>& params,
const std::map<std::string, std::string>& options,
const std::vector<std::string>& flags);
virtual void DoCommand();
@ -726,7 +751,7 @@ public:
return true;
}
static void Help(string& ret);
static void Help(std::string* ret);
};
} // namespace rocksdb

6
util/ldb_cmd_execute_result.h
View File

@ -15,7 +15,7 @@ public:
LDBCommandExecuteResult() : state_(EXEC_NOT_STARTED), message_("") {}
LDBCommandExecuteResult(State state, std::string& msg) :
LDBCommandExecuteResult(State state, const std::string& msg) :
state_(state), message_(msg) {}
std::string ToString() {
@ -52,11 +52,11 @@ public:
return state_ == EXEC_FAILED;
}
static LDBCommandExecuteResult SUCCEED(std::string msg) {
static LDBCommandExecuteResult SUCCEED(const std::string& msg) {
return LDBCommandExecuteResult(EXEC_SUCCEED, msg);
}
static LDBCommandExecuteResult FAILED(std::string msg) {
static LDBCommandExecuteResult FAILED(const std::string& msg) {
return LDBCommandExecuteResult(EXEC_FAILED, msg);
}

36
util/ldb_tool.cc
View File

@ -24,7 +24,7 @@ class LDBCommandRunner {
public:
static void PrintHelp(const char* exec_name) {
string ret;
std::string ret;
ret.append("ldb - LevelDB Tool");
ret.append("\n\n");
@ -59,26 +59,26 @@ public:
ret.append("\n\n");
ret.append("Data Access Commands:\n");
PutCommand::Help(ret);
GetCommand::Help(ret);
BatchPutCommand::Help(ret);
ScanCommand::Help(ret);
DeleteCommand::Help(ret);
DBQuerierCommand::Help(ret);
ApproxSizeCommand::Help(ret);
CheckConsistencyCommand::Help(ret);
PutCommand::Help(&ret);
GetCommand::Help(&ret);
BatchPutCommand::Help(&ret);
ScanCommand::Help(&ret);
DeleteCommand::Help(&ret);
DBQuerierCommand::Help(&ret);
ApproxSizeCommand::Help(&ret);
CheckConsistencyCommand::Help(&ret);
ret.append("\n\n");
ret.append("Admin Commands:\n");
WALDumperCommand::Help(ret);
CompactorCommand::Help(ret);
ReduceDBLevelsCommand::Help(ret);
ChangeCompactionStyleCommand::Help(ret);
DBDumperCommand::Help(ret);
DBLoaderCommand::Help(ret);
ManifestDumpCommand::Help(ret);
ListColumnFamiliesCommand::Help(ret);
InternalDumpCommand::Help(ret);
WALDumperCommand::Help(&ret);
CompactorCommand::Help(&ret);
ReduceDBLevelsCommand::Help(&ret);
ChangeCompactionStyleCommand::Help(&ret);
DBDumperCommand::Help(&ret);
DBLoaderCommand::Help(&ret);
ManifestDumpCommand::Help(&ret);
ListColumnFamiliesCommand::Help(&ret);
InternalDumpCommand::Help(&ret);
fprintf(stderr, "%s\n", ret.c_str());
}