int main(int argc, char *argv[]) {
fsp_link *link;
fs_query_state *qs;
fs_query *qr;
raptor_uri *bu;
int i;
#ifdef LINUX
mtrace();
#endif
link = fsp_open_link("ukgov_finances_cra", NULL, FS_OPEN_HINT_RW);
raptor_init();
fs_hash_init(fsp_hash_type(link));
bu = raptor_new_uri((unsigned char *)"local:");
fsp_no_op(link, 0);
qs = fs_query_init(link);
for (i=0;i<atoi(argv[1]);i++) {
//printf("--------- %d ----------\n", i);
qr = fs_query_execute(qs, link, bu, QUERY, 0, 3, 0);
fs_query_free(qr);
fs_query_cache_flush(qs, 0);
}
fs_query_fini(qs);
raptor_free_uri(bu);
raptor_finish();
fsp_close_link(link);
#ifdef LINUX
muntrace();
#endif
}
int main(int argc, char *argv[])
{
char *password = fsp_argv_password(&argc, argv);
if (argc != 2) {
fprintf(stderr, "%s revision %s\n", argv[0], FS_FRONTEND_VER);
fprintf(stderr, "Usage: %s <kbname>\n", argv[0]);
return 1;
}
fsp_syslog_enable();
fsp_link *link = fsp_open_link(argv[1], password, FS_OPEN_HINT_RO);
if (!link) {
fs_error(LOG_ERR, "couldn't connect to “%s”", argv[1]);
return 2;
}
if (fsp_no_op(link, 0)) {
fs_error(LOG_ERR, "NO-OP failed\n");
return 3;
}
fs_data_size total = {0, 0, 0, 0, 0, 0};
fs_data_size sz;
if (fsp_get_data_size(link, 0, &sz)) {
fs_error(LOG_ERR, "cannot get size information");
exit(2);
}
printf("%5s%12s%12s%12s%12s\n", "seg","quads (s)","quads (sr)",
"models", "resources");
const int segments = fsp_link_segments(link);
for (fs_segment seg = 0; seg < segments; ++seg) {
fs_data_size sz;
int ret = fsp_get_data_size(link, seg, &sz);
if (ret) {
printf("%5d -- problem obtaining size information --\n", seg);
} else {
printf("%5d%12lld%+12lld%12lld%12lld\n", seg,
sz.quads_s, sz.quads_sr - sz.quads_s,
sz.models_s, sz.resources);
total.quads_s += sz.quads_s;
total.quads_sr += sz.quads_sr;
if (sz.models_s > total.models_s) total.models_s = sz.models_s;
total.resources += sz.resources;
}
}
printf("\n");
printf("%5s%12lld%+12lld%12lld%12lld\n",
"TOTAL", total.quads_s, (total.quads_sr - total.quads_s),
total.models_s, total.resources);
printf("\ncollision probability ≅ %.2Lf%%\n", 100.0 * (1.0 - expl(-(total.resources * (total.resources-1.0) / (2.0 * CONST_2to63)))));
fsp_close_link(link);
}
int main(int argc, char *argv[])
{
char *password = fsp_argv_password(&argc, argv);
if (argc != 3 || !strcmp(argv[2], "-h")) {
fprintf(stderr, "Usage: %s kbname <begin|rollback|commit>\n", basename(argv[0]));
return 1;
}
fsp_syslog_enable();
fsp_link *link = fsp_open_link(argv[1], password, FS_OPEN_HINT_RW);
if (!link) {
fprintf(stderr, "couldn't connect to “%s”\n", argv[1]);
return 2;
}
if (fsp_no_op(link, 0)) {
fprintf(stderr, "NO-OP failed\n");
return 1;
}
int ret = 0;
if (!strcmp(argv[2], "begin")) {
fsp_transaction_begin_all(link);
} else if (!strcmp(argv[2], "rollback")) {
fsp_transaction_rollback_all(link);
} else if (!strcmp(argv[2], "precommit")) {
/* this is an undocumented "feature", don't use it unless you know
* what it means, it's only really for benchmark timing */
ret = fsp_lock(link);
if (ret) {
fs_error(LOG_CRIT, "failed to get commit lock for '%s'", argv[1]);
}
if (!ret) ret = fsp_transaction_pre_commit_all(link);
} else if (!strcmp(argv[2], "commit")) {
ret = fsp_lock(link);
if (ret) {
fs_error(LOG_CRIT, "failed to get commit lock for '%s'", argv[1]);
}
if (!ret) ret = fsp_transaction_pre_commit_all(link);
if (!ret) ret = fsp_transaction_commit_all(link);
} else {
fprintf(stderr, "bad argument, expected “begin”, “rollback” or “commit”\n");
return 3;
}
fsp_close_link(link);
return ret;
}
int main(int argc, char *argv[])
{
fs_gnu_options(argc, argv, "<kbname> <noop|freq>\n");
char *password = fsp_argv_password(&argc, argv);
if (argc != 3) {
fprintf(stderr, "Usage: %s <kbname> <noop|freq>\n", basename(argv[0]));
return 1;
}
fsp_syslog_enable();
fsp_link *link = fsp_open_link(argv[1], password, FS_OPEN_HINT_RO);
if (!link) {
fs_error(LOG_ERR, "couldn't connect to “%s”", argv[1]);
return 2;
}
double then = fs_time();
if (fsp_no_op(link, 0)) {
fs_error(LOG_ERR, "NO-OP failed\n");
return 3;
}
double now = fs_time();
if (!strcmp(argv[2], "noop")) {
printf("NO-OP took %fs\n", now-then);
return 0;
} else if (!strcmp(argv[2], "freq")) {
fs_query_state *qs = fs_query_init(link, NULL, NULL);
fs_optimiser_freq_print(qs);
}
fsp_close_link(link);
}
int main(int argc, char *argv[])
{
char *password = fsp_argv_password(&argc, argv);
static char *optstring = "hevf:PO:Ib:rs:d";
char *format = getenv("FORMAT");
char *kb_name = NULL, *query = NULL;
int programatic = 0, help = 0;
int c, opt_index = 0;
int verbosity = 0;
int opt_level = 3;
int insert_mode = 0;
int restricted = 0;
int soft_limit = 0;
int explain = 0;
int default_graph = 0;
char *base_uri = "local:";
raptor_world *rw = NULL;
static struct option long_options[] = {
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'V' },
{ "verbose", 0, 0, 'v' },
{ "explain", 0, 0, 'e' },
{ "format", 1, 0, 'f' },
{ "programatic", 0, 0, 'P' },
{ "opt-level", 1, 0, 'O' },
{ "insert", 0, 0, 'I' },
{ "restricted", 0, 0, 'r' },
{ "soft-limit", 1, 0, 's' },
{ "default-graph", 0, 0, 'd' },
{ "base", 1, 0, 'b' },
{ 0, 0, 0, 0 }
};
int help_return = 1;
while ((c = getopt_long (argc, argv, optstring, long_options, &opt_index)) != -1) {
if (c == 'f') {
format = optarg;
} else if (c == 'P') {
programatic = TRUE;
} else if (c == 'v') {
verbosity++;
} else if (c == 'O') {
opt_level = atoi(optarg);
} else if (c == 'I') {
insert_mode = 1;
} else if (c == 'r') {
restricted = 1;
} else if (c == 's') {
soft_limit = atoi(optarg);
} else if (c == 'd') {
default_graph = 1;
} else if (c == 'b') {
base_uri = optarg;
} else if (c == 'h') {
help = 1;
help_return = 0;
} else if (c == 'e') {
explain = 1;
} else if (c == 'V') {
printf("%s, built for 4store %s\n", argv[0], GIT_REV);
exit(0);
} else {
help = 1;
}
}
for (int k = optind; k < argc; ++k) {
if (!kb_name) {
kb_name = argv[k];
} else if (!query && !programatic) {
query = argv[k];
} else {
help = 1;
}
}
if (help || !kb_name) {
char *langs = "";
if (fs_query_have_laqrs()) {
langs = "/LAQRS";
}
fprintf(stdout, "%s revision %s\n", basename(argv[0]), GIT_REV);
fprintf(stdout, "Usage: %s <kbname> [-f format] [-O opt-level] [-I] [-b uri] [query]\n", argv[0]);
fprintf(stdout, " or: %s <kbname> -P\n", basename(argv[0]));
fprintf(stdout, " query is a SPARQL%s query, remember to use"
" shell quoting if necessary\n", langs);
fprintf(stdout, " -f Output format one of, sparql, text, json, or testcase\n");
fprintf(stdout, " -O, --opt-level Set optimisation level, range 0-3\n");
fprintf(stdout, " -I, --insert Interpret CONSTRUCT statements as inserts\n");
fprintf(stdout, " -r, --restricted Enable query complexity restriction\n");
fprintf(stdout, " -s, --soft-limit Override default soft limit on search breadth\n");
fprintf(stdout, " -d, --default-graph Enable SPARQL default graph support\n");
fprintf(stdout, " -b, --base Set base URI for query\n");
fprintf(stdout, " -e, --explain Show explain results for execution plan\n");
exit(help_return);
}
if (programatic || query) {
/* don't syslog interactive errors */
fsp_syslog_enable();
}
double then = ftime();
/* if query does UPDATE or DELETE operations this needs a re-think */
fsp_link *link = fsp_open_link(kb_name, password, FS_OPEN_HINT_RO);
double now = ftime();
show_timing = (getenv("SHOW_TIMING") != NULL) | (verbosity > 1);
if (show_timing) {
printf("Link open time: %f\n", now-then);
}
if (!link) {
fs_error(LOG_ERR, "couldn't connect to “%s”", kb_name);
return 2;
}
const int segments = fsp_link_segments(link);
fs_query_timing timing[segments];
memset(timing, 0, sizeof(fs_query_timing) * segments);
if (show_timing) {
for (int seg = 0; seg < segments; seg++) {
fsp_get_query_times(link, seg, timing+seg);
}
}
if (fsp_no_op(link, 0)) {
fs_error(LOG_ERR, "NO-OP failed for “%s”", kb_name);
return 2;
}
rw = raptor_new_world();
fs_hash_init(fsp_hash_type(link));
raptor_uri *bu = raptor_new_uri(rw, (unsigned char *)base_uri);
unsigned int flags = FS_QUERY_CONSOLE_OUTPUT; /* signal that we're using the */
/* console, allows better explain functionality */
flags |= insert_mode ? FS_RESULT_FLAG_CONSTRUCT_AS_INSERT : 0;
flags |= restricted ? FS_QUERY_RESTRICTED : 0;
flags |= default_graph ? FS_QUERY_DEFAULT_GRAPH : 0;
if (programatic) {
programatic_io(link, bu, "sparql", format, timing, verbosity, opt_level,
FS_RESULT_FLAG_HEADERS | flags, soft_limit, rw);
} else if (!query) {
if (!format) format = "text";
interactive(link, bu, format, verbosity, opt_level,
insert_mode ? FS_RESULT_FLAG_CONSTRUCT_AS_INSERT : flags,
soft_limit, rw);
}
int ret = 0;
fs_query_state *qs = fs_query_init(link, NULL, NULL);
qs->verbosity = verbosity;
fs_query *qr = fs_query_execute(qs, link, bu, query, flags, opt_level, soft_limit, explain);
if (fs_query_errors(qr)) {
ret = 1;
}
fs_query_results_output(qr, format, 0, stdout);
fs_query_free(qr);
if (show_timing) {
printf("seg bind\t(secs)\t\tprice\t(secs)\t\tresolve\t(secs)\t\twait (secs)\n");
long long *tics = fsp_profile_write(link);
for (int seg = 0; seg < segments; seg++) {
fs_query_timing newtimes;
fsp_get_query_times(link, seg, &newtimes);
printf("%2d: %4d\t%f\t%4d\t%f\t%4d\t%f\t%f\n", seg,
newtimes.bind_count - timing[seg].bind_count,
newtimes.bind - timing[seg].bind,
newtimes.price_count - timing[seg].price_count,
newtimes.price - timing[seg].price,
newtimes.resolve_count - timing[seg].resolve_count,
newtimes.resolve - timing[seg].resolve,
tics[seg] * 0.001);
}
}
raptor_free_uri(bu);
raptor_free_world(rw);
fs_query_cache_flush(qs, verbosity);
fs_query_fini(qs);
fsp_close_link(link);
return ret;
}
