in src/shell/commands/data_operations.cpp [1338:1578]
bool full_scan(command_executor *e, shell_context *sc, arguments args)
{
static struct option long_options[] = {{"detailed", no_argument, 0, 'd'},
{"max_count", required_argument, 0, 'n'},
{"partition", required_argument, 0, 'p'},
{"timeout_ms", required_argument, 0, 't'},
{"output", required_argument, 0, 'o'},
{"hash_key_filter_type", required_argument, 0, 'h'},
{"hash_key_filter_pattern", required_argument, 0, 'x'},
{"sort_key_filter_type", required_argument, 0, 's'},
{"sort_key_filter_pattern", required_argument, 0, 'y'},
{"value_filter_type", required_argument, 0, 'v'},
{"value_filter_pattern", required_argument, 0, 'z'},
{"no_value", no_argument, 0, 'i'},
{0, 0, 0, 0}};
int32_t max_count = -1;
bool detailed = false;
FILE *file = stderr;
int32_t timeout_ms = sc->timeout_ms;
int32_t partition = -1;
std::string hash_key_filter_type_name("no_filter");
std::string sort_key_filter_type_name("no_filter");
pegasus::pegasus_client::filter_type sort_key_filter_type =
pegasus::pegasus_client::FT_NO_FILTER;
std::string sort_key_filter_pattern;
std::string value_filter_type_name("no_filter");
pegasus::pegasus_client::filter_type value_filter_type = pegasus::pegasus_client::FT_NO_FILTER;
std::string value_filter_pattern;
pegasus::pegasus_client::scan_options options;
escape_sds_argv(args.argc, args.argv);
optind = 0;
while (true) {
int option_index = 0;
int c;
c = getopt_long(
args.argc, args.argv, "dn:p:t:o:h:x:s:y:v:z:i", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'd':
detailed = true;
break;
case 'n':
if (!dsn::buf2int32(optarg, max_count)) {
fprintf(stderr, "ERROR: parse %s as max_count failed\n", optarg);
return false;
}
break;
case 'p':
if (!dsn::buf2int32(optarg, partition)) {
fprintf(stderr, "ERROR: parse %s as partition id failed\n", optarg);
return false;
}
if (partition < 0) {
fprintf(stderr, "ERROR: invalid partition param, should > 0\n");
return false;
}
break;
case 't':
if (!dsn::buf2int32(optarg, timeout_ms)) {
fprintf(stderr, "ERROR: parse %s as timeout_ms failed\n", optarg);
return false;
}
break;
case 'o':
file = fopen(optarg, "w");
if (!file) {
fprintf(stderr, "ERROR: open filename %s failed\n", optarg);
return false;
}
break;
case 'h':
options.hash_key_filter_type = parse_filter_type(optarg, false);
if (options.hash_key_filter_type == pegasus::pegasus_client::FT_NO_FILTER) {
fprintf(stderr, "ERROR: invalid hash_key_filter_type param\n");
return false;
}
hash_key_filter_type_name = optarg;
break;
case 'x':
options.hash_key_filter_pattern = unescape_str(optarg);
break;
case 's':
sort_key_filter_type = parse_filter_type(optarg, true);
if (sort_key_filter_type == pegasus::pegasus_client::FT_NO_FILTER) {
fprintf(stderr, "ERROR: invalid sort_key_filter_type param\n");
return false;
}
sort_key_filter_type_name = optarg;
break;
case 'y':
sort_key_filter_pattern = unescape_str(optarg);
break;
case 'v':
value_filter_type = parse_filter_type(optarg, true);
if (value_filter_type == pegasus::pegasus_client::FT_NO_FILTER) {
fprintf(stderr, "ERROR: invalid value_filter_type param\n");
return false;
}
value_filter_type_name = optarg;
break;
case 'z':
value_filter_pattern = unescape_str(optarg);
break;
case 'i':
options.no_value = true;
break;
default:
return false;
}
}
if (value_filter_type != pegasus::pegasus_client::FT_NO_FILTER && options.no_value) {
fprintf(stderr, "ERROR: no_value should not be set when value_filter_type is set\n");
return false;
}
fprintf(stderr,
"partition: %s\n",
partition >= 0 ? boost::lexical_cast<std::string>(partition).c_str() : "all");
fprintf(stderr, "hash_key_filter_type: %s\n", hash_key_filter_type_name.c_str());
if (options.hash_key_filter_type != pegasus::pegasus_client::FT_NO_FILTER) {
fprintf(stderr,
"hash_key_filter_pattern: \"%s\"\n",
pegasus::utils::c_escape_string(options.hash_key_filter_pattern).c_str());
}
fprintf(stderr, "sort_key_filter_type: %s\n", sort_key_filter_type_name.c_str());
if (sort_key_filter_type != pegasus::pegasus_client::FT_NO_FILTER) {
fprintf(stderr,
"sort_key_filter_pattern: \"%s\"\n",
pegasus::utils::c_escape_string(sort_key_filter_pattern).c_str());
}
fprintf(stderr, "value_filter_type: %s\n", value_filter_type_name.c_str());
if (value_filter_type != pegasus::pegasus_client::FT_NO_FILTER) {
fprintf(stderr,
"value_filter_pattern: \"%s\"\n",
pegasus::utils::c_escape_string(value_filter_pattern).c_str());
}
fprintf(stderr, "max_count: %d\n", max_count);
fprintf(stderr, "timout_ms: %d\n", timeout_ms);
fprintf(stderr, "detailed: %s\n", detailed ? "true" : "false");
fprintf(stderr, "no_value: %s\n", options.no_value ? "true" : "false");
fprintf(stderr, "\n");
int count = 0;
std::vector<pegasus::pegasus_client::pegasus_scanner *> scanners;
options.timeout_ms = timeout_ms;
if (sort_key_filter_type != pegasus::pegasus_client::FT_NO_FILTER) {
if (sort_key_filter_type == pegasus::pegasus_client::FT_MATCH_EXACT)
options.sort_key_filter_type = pegasus::pegasus_client::FT_MATCH_PREFIX;
else
options.sort_key_filter_type = sort_key_filter_type;
options.sort_key_filter_pattern = sort_key_filter_pattern;
}
int ret = sc->pg_client->get_unordered_scanners(10000, options, scanners);
if (ret != pegasus::PERR_OK) {
fprintf(file, "ERROR: %s\n", sc->pg_client->get_error_string(ret));
if (file != stderr) {
fprintf(stderr, "ERROR: %s\n", sc->pg_client->get_error_string(ret));
}
} else if (partition >= 0 && partition >= (int)scanners.size()) {
fprintf(file,
"ERROR: partition %d out of range, should be in range of [0,%d]\n",
partition,
(int)scanners.size() - 1);
if (file != stderr) {
fprintf(stderr,
"ERROR: partition %d out of range, should be in range of [0,%d]\n",
partition,
(int)scanners.size() - 1);
}
} else {
for (int i = 0; i < scanners.size(); i++) {
if (partition >= 0 && partition != i)
continue;
std::string got_hash_key;
std::string sort_key;
std::string value;
pegasus::pegasus_client::internal_info info;
pegasus::pegasus_client::pegasus_scanner *scanner = scanners[i];
while ((max_count <= 0 || count < max_count) &&
!(ret = scanner->next(got_hash_key, sort_key, value, &info))) {
if (sort_key_filter_type == pegasus::pegasus_client::FT_MATCH_EXACT &&
sort_key.length() > sort_key_filter_pattern.length())
continue;
if (!validate_filter(value_filter_type, value_filter_pattern, value))
continue;
fprintf(file,
"\"%s\" : \"%s\"",
pegasus::utils::c_escape_string(got_hash_key, sc->escape_all).c_str(),
pegasus::utils::c_escape_string(sort_key, sc->escape_all).c_str());
if (!options.no_value) {
fprintf(file,
" => \"%s\"",
pegasus::utils::c_escape_string(value, sc->escape_all).c_str());
}
if (detailed) {
fprintf(file,
" {app_id=%d, partition_index=%d, server=%s}",
info.app_id,
info.partition_index,
info.server.c_str());
}
fprintf(file, "\n");
count++;
}
if (ret != pegasus::PERR_SCAN_COMPLETE && ret != pegasus::PERR_OK) {
fprintf(file,
"ERROR: %s {app_id=%d, partition_index=%d, server=%s}\n",
sc->pg_client->get_error_string(ret),
info.app_id,
info.partition_index,
info.server.c_str());
if (file != stderr) {
fprintf(stderr,
"ERROR: %s {app_id=%d, partition_index=%d, server=%s}\n",
sc->pg_client->get_error_string(ret),
info.app_id,
info.partition_index,
info.server.c_str());
}
}
}
}
for (auto scanner : scanners) {
delete scanner;
}
if (file != stderr) {
fclose(file);
}
if (file == stderr && count > 0) {
fprintf(stderr, "\n");
}
fprintf(stderr, "%d key-value pairs got.\n", count);
return true;
}