int
main(void)
{
WT_CONNECTION *conn;
WT_SESSION *session;
int i, j, k, ret;
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
if (getenv("WIREDTIGER_HOME") == NULL) {
home = "WT_HOME";
ret = system("rm -rf WT_HOME && mkdir WT_HOME");
} else
home = NULL;
/* Open a connection to the database, creating it if necessary. */
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
/* Open a session for the current thread's work. */
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
fprintf(stderr, "Error opening a session on %s: %s\n",
home, wiredtiger_strerror(ret));
{
/*! [packing] */
size_t size;
char buf[50];
ret = wiredtiger_struct_size(session, &size, "iii", 42, 1000, -9);
if (size > sizeof(buf)) {
/* Allocate a bigger buffer. */
}
ret = wiredtiger_struct_pack(session, buf, size, "iii", 42, 1000, -9);
ret = wiredtiger_struct_unpack(session, buf, size, "iii", &i, &j, &k);
/*! [packing] */
}
/* Note: closing the connection implicitly closes open session(s). */
if ((ret = conn->close(conn, NULL)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
return (ret);
}
static int
run_child(const char *homedir, int op, int expect)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
int i, ret;
const char *cfg;
/*
* We expect the read-only database will allow the second read-only
* handle to succeed because no one can create or set the lock file.
*/
if (op == OP_READ)
cfg = ENV_CONFIG_RD;
else
cfg = ENV_CONFIG_WR;
if ((ret = wiredtiger_open(homedir, NULL, cfg, &conn)) == 0) {
if (expect == EXPECT_ERR)
testutil_die(
ret, "wiredtiger_open expected error, succeeded");
} else {
if (expect == EXPECT_SUCCESS)
testutil_die(
ret, "wiredtiger_open expected success, error");
/*
* If we expect an error and got one, we're done.
*/
return (0);
}
/*
* Make sure we can read the data.
*/
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
if ((ret =
session->open_cursor(session, uri, NULL, NULL, &cursor)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri);
i = 0;
while ((ret = cursor->next(cursor)) == 0)
++i;
if (i != MAX_KV)
testutil_die(EPERM, "cursor walk");
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "conn_close");
return (0);
}
int main(void)
{
/*! [access example connection] */
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
const char *key, *value;
int ret;
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0 ||
(ret = conn->open_session(conn, NULL, NULL, &session)) != 0) {
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
return (ret);
}
/*! [access example connection] */
/*! [access example table create] */
ret = session->create(session,
"table:access", "key_format=S,value_format=S");
/*! [access example table create] */
/*! [access example cursor open] */
ret = session->open_cursor(session,
"table:access", NULL, NULL, &cursor);
/*! [access example cursor open] */
/*! [access example cursor insert] */
cursor->set_key(cursor, "key1"); /* Insert a record. */
cursor->set_value(cursor, "value1");
ret = cursor->insert(cursor);
/*! [access example cursor insert] */
/*! [access example cursor list] */
ret = cursor->reset(cursor); /* Restart the scan. */
while ((ret = cursor->next(cursor)) == 0) {
ret = cursor->get_key(cursor, &key);
ret = cursor->get_value(cursor, &value);
printf("Got record: %s : %s\n", key, value);
}
/*! [access example cursor list] */
/*! [access example close] */
ret = conn->close(conn, NULL);
/*! [access example close] */
return (ret);
}
static void
open_normal(const char *sfx, TABLE_INFO *table_data)
{
WT_CONNECTION *conn;
char buf[1024];
printf("=== wt_open normal ===\n");
if (sfx != NULL)
testutil_check(__wt_snprintf(buf, sizeof(buf),
"%s.%s", home, sfx));
else
testutil_check(__wt_snprintf(buf, sizeof(buf), "%s", home));
testutil_check(wiredtiger_open(buf, &event_handler, NULL, &conn));
verify_metadata(conn, &table_data[0]);
testutil_check(conn->close(conn, NULL));
}
static int
setup_copy(WT_CONNECTION **wt_connp, WT_SESSION **sessionp)
{
int ret;
if ((ret = wiredtiger_open(home2, NULL, CONN_CONFIG, wt_connp)) != 0) {
fprintf(stderr, "Error connecting to %s: %s\n",
home1, wiredtiger_strerror(ret));
return (ret);
}
ret = (*wt_connp)->open_session(*wt_connp, NULL, NULL, sessionp);
ret = (*sessionp)->create(*sessionp, uri,
"key_format=S,value_format=S");
return (ret);
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(
wiredtiger_open(opts->home, NULL, "create", &opts->conn));
/* Run the test. */
modify_run(opts->verbose);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
/*! [thread main] */
int
main(void)
{
WT_CONNECTION *conn;
WT_SESSION *session;
WT_CURSOR *cursor;
pthread_t threads[NUM_THREADS];
int i, ret;
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
if (getenv("WIREDTIGER_HOME") == NULL) {
home = "WT_HOME";
ret = system("rm -rf WT_HOME && mkdir WT_HOME");
} else
home = NULL;
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home == NULL ? "." : home, wiredtiger_strerror(ret));
/* Note: further error checking omitted for clarity. */
ret = conn->open_session(conn, NULL, NULL, &session);
ret = session->create(session, "table:access",
"key_format=S,value_format=S");
ret = session->open_cursor(session, "table:access", NULL,
"overwrite", &cursor);
cursor->set_key(cursor, "key1");
cursor->set_value(cursor, "value1");
ret = cursor->insert(cursor);
ret = session->close(session, NULL);
for (i = 0; i < NUM_THREADS; i++)
ret = pthread_create(&threads[i], NULL, scan_thread, conn);
for (i = 0; i < NUM_THREADS; i++)
ret = pthread_join(threads[i], NULL);
ret = conn->close(conn, NULL);
return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
int
main(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
int ret;
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
if (getenv("WIREDTIGER_HOME") == NULL) {
home = "WT_HOME";
ret = system("rm -rf WT_HOME && mkdir WT_HOME");
} else
home = NULL;
ret = wiredtiger_open(home, NULL, "create,statistics=(all)", &conn);
ret = conn->open_session(conn, NULL, NULL, &session);
ret = session->create(
session, "table:access", "key_format=S,value_format=S");
ret = session->open_cursor(
session, "table:access", NULL, NULL, &cursor);
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
ret = cursor->insert(cursor);
ret = cursor->close(cursor);
ret = session->checkpoint(session, NULL);
ret = print_database_stats(session);
ret = print_file_stats(session);
ret = print_overflow_pages(session);
ret = print_derived_stats(session);
return (conn->close(conn, NULL) == 0 ? ret : EXIT_FAILURE);
}
int
main(void)
{
WT_CONNECTION *conn;
WT_SESSION *session;
int ret;
ret = wiredtiger_open(home, NULL, "create", &conn);
ret = conn->open_session(conn, NULL, NULL, &session);
ret = session->create(
session, "table:access", "key_format=S,value_format=S");
ret = print_database_stats(session);
ret = print_file_stats(session);
ret = print_overflow_pages(session);
return (conn->close(conn, NULL) == 0 ? ret : EXIT_FAILURE);
}
/*
* wt_connect --
* Configure the WiredTiger connection.
*/
static void
wt_connect(char *config_open)
{
static WT_EVENT_HANDLER event_handler = {
NULL,
handle_message,
NULL
};
int ret;
char config[128];
snprintf(config, sizeof(config),
"create,error_prefix=\"%s\",cache_size=5MB%s%s",
progname,
config_open == NULL ? "" : ",",
config_open == NULL ? "" : config_open);
if ((ret = wiredtiger_open(NULL, &event_handler, config, &conn)) != 0)
die("wiredtiger_open", ret);
}
int setup(char *name, const char *kf, const char *vf, const char *cconfig, WT_CURSOR **cursor){
WT_SESSION *session;
int creating, ret;
char tconfig[64];
creating = (kf != NULL);
if((ret = wiredtiger_open(NULL, NULL, "create", &conn) != 0) ||
(ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
return ret;
/* If we get a configuration, create the table. */
if(creating) {
(void)session->drop(session, name, "force");
snprintf(tconfig, sizeof(tconfig), "key_format=%s,value_format=%s", kf, vf);
if ((ret = session->create(session, name, tconfig)) != 0)
return ret;
}
return session->open_cursor(session, name, NULL, cconfig, cursor);
}
int
main(int argc, char *argv[])
{
WT_CONNECTION *conn;
WT_SESSION *session;
home = example_setup(argc, argv);
error_check(
wiredtiger_open(home, NULL, "create,cache_size=500M", &conn));
add_extractor(conn);
error_check(conn->open_session(conn, NULL, NULL, &session));
setup_table(session);
read_index(session);
remove_items(session);
error_check(conn->close(conn, NULL));
return (EXIT_SUCCESS);
}
int WiredTigerEngine::Init(const WiredTigerConfig& cfg)
{
m_cfg = cfg;
make_dir(cfg.path);
int ret = 0;
if (m_cfg.init_options.empty())
{
m_cfg.init_options = "create,cache_size=500M,statistics=(fast)";
}
if ((ret = wiredtiger_open(m_cfg.path.c_str(), NULL, m_cfg.init_options.c_str(), &m_db)) != 0)
{
ERROR_LOG("Error connecting to %s: %s", m_cfg.path.c_str(), wiredtiger_strerror(ret));
return -1;
}
ret = m_db->add_collator(m_db, "ardb_comparator", &ardb_comparator, NULL);
CHECK_WT_RETURN(ret);
// m_running = true;
// m_background = new Thread(this);
// m_background->Start();
return 0;
}
int main(void)
{
int ret;
WT_CONNECTION *conn;
WT_SESSION *session;
WT_CURSOR *cursor;
const char *key, *value;
/*! [configure cache size] */
if ((ret = wiredtiger_open(home, NULL,
"create,cache_size=500M", &conn)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
/*! [configure cache size] */
/*! [create a table] */
ret = conn->open_session(conn, NULL, NULL, &session);
ret = session->create(session,
"table:access", "key_format=S,value_format=S");
/*! [create a table] */
/*! [transaction] */
ret = session->begin_transaction(session, "priority=100,name=mytxn");
ret = session->open_cursor(session, "config:", NULL, NULL, &cursor);
while ((ret = cursor->next(cursor)) == 0) {
cursor->get_key(cursor, &key);
cursor->get_value(cursor, &value);
printf("configuration value: %s = %s\n", key, value);
}
ret = session->commit_transaction(session, NULL);
/*! [transaction] */
ret = conn->close(conn, NULL);
return (ret);
}
int
main(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
int ret, tret;
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
if (getenv("WIREDTIGER_HOME") == NULL) {
home = "WT_HOME";
ret = system("rm -rf WT_HOME && mkdir WT_HOME");
} else
home = NULL;
/* Open a connection, create a simple table, open a cursor. */
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0 ||
(ret = conn->open_session(conn, NULL, NULL, &session)) != 0) {
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
return (ret);
}
ret = session->create(session,
"table:scope", "key_format=S,value_format=S,columns=(k,v)");
ret = session->open_cursor(session,
"table:scope", NULL, NULL, &cursor);
ret = cursor_scope_ops(cursor);
/* Close the connection and clean up. */
if ((tret = conn->close(conn, NULL)) != 0 && ret == 0)
ret = tret;
return (ret);
}
int
main(void)
{
int ret;
WT_CONNECTION *conn;
WT_SESSION *session;
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
if (getenv("WIREDTIGER_HOME") == NULL) {
home = "WT_HOME";
ret = system("rm -rf WT_HOME && mkdir WT_HOME");
} else
home = NULL;
/* Open a connection to the database, creating it if necessary. */
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home == NULL ? "." : home, wiredtiger_strerror(ret));
/*! [add collator nocase] */
ret = conn->add_collator(conn, "nocase", &nocasecoll, NULL);
/*! [add collator nocase] */
/*! [add collator prefix10] */
ret = conn->add_collator(conn, "prefix10", &pcoll10.iface, NULL);
/* Open a session for the current thread's work. */
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
fprintf(stderr, "Error opening a session on %s: %s\n",
home == NULL ? "." : home, wiredtiger_strerror(ret));
/* Do some work... */
ret = conn->close(conn, NULL);
/*! [add collator prefix10] */
return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
int
main(void)
{
WT_CONNECTION *conn;
WT_SESSION *session;
int ret;
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0 ||
(ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
/* Note: further error checking omitted for clarity. */
/*! [file create] */
ret = session->create(session, "file:example",
"key_format=u,"
"internal_page_max=32KB,internal_item_max=1KB,"
"leaf_page_max=1MB,leaf_item_max=32KB");
/*! [file create] */
return (conn->close(conn, NULL) == 0 ? ret : EXIT_FAILURE);
}
int
main(int argc, char *argv[])
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
home = example_setup(argc, argv);
error_check(
wiredtiger_open(home, NULL, "create,statistics=(all)", &conn));
error_check(conn->open_session(conn, NULL, NULL, &session));
error_check(session->create(session,
"table:access", "key_format=S,value_format=S,columns=(k,v)"));
error_check(session->open_cursor(
session, "table:access", NULL, NULL, &cursor));
cursor->set_key(cursor, "key");
cursor->set_value(cursor, "value");
error_check(cursor->insert(cursor));
error_check(cursor->close(cursor));
error_check(session->checkpoint(session, NULL));
print_database_stats(session);
print_file_stats(session);
print_join_cursor_stats(session);
print_overflow_pages(session);
print_derived_stats(session);
error_check(conn->close(conn, NULL));
return (EXIT_SUCCESS);
}
/*
* wt_startup --
* Configure the WiredTiger connection.
*/
static void
wt_startup(char *config_open)
{
static WT_EVENT_HANDLER event_handler = {
handle_error,
handle_message,
NULL,
NULL /* Close handler. */
};
int ret;
char config_buf[128];
testutil_make_work_dir(home);
snprintf(config_buf, sizeof(config_buf),
"create,error_prefix=\"%s\",cache_size=5MB%s%s",
progname,
config_open == NULL ? "" : ",",
config_open == NULL ? "" : config_open);
if ((ret = wiredtiger_open(
home, &event_handler, config_buf, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
}
static void
open_with_salvage(const char *sfx, TABLE_INFO *table_data)
{
WT_CONNECTION *conn;
char buf[1024];
printf("=== wt_open with salvage ===\n");
/*
* Then call wiredtiger_open with the salvage configuration setting.
* That should succeed. We should be able to then verify the contents
* of the metadata file.
*/
test_abort = true;
if (sfx != NULL)
testutil_check(__wt_snprintf(buf, sizeof(buf),
"%s.%s", home, sfx));
else
testutil_check(__wt_snprintf(buf, sizeof(buf), "%s", home));
testutil_check(wiredtiger_open(buf,
&event_handler, "salvage=true", &conn));
testutil_assert(conn != NULL);
if (sfx != NULL)
testutil_check(__wt_snprintf(buf, sizeof(buf),
"%s.%s/%s", home, sfx, WT_METAFILE_SLVG));
else
testutil_check(__wt_snprintf(buf, sizeof(buf),
"%s/%s", home, WT_METAFILE_SLVG));
testutil_assert(file_exists(buf));
/*
* Confirm we salvaged the metadata file by looking for the saved
* copy of the original metadata.
*/
printf("verify with salvaged connection\n");
verify_metadata(conn, &table_data[0]);
testutil_check(conn->close(conn, NULL));
}
int main(void)
{
WT_CONNECTION *conn;
WT_SESSION *session;
char buf[50];
size_t size;
int i, j, k, ret;
/* Open a connection to the database, creating it if necessary. */
if ((ret = wiredtiger_open(home, NULL, "create", &conn)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
/* Open a session for the current thread's work. */
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
fprintf(stderr, "Error opening a session on %s: %s\n",
home, wiredtiger_strerror(ret));
/*! [packing] */
ret = wiredtiger_struct_size(session, &size, "iii", 42, 1000, -9);
if (size > sizeof(buf)) {
/* Allocate a bigger buffer. */
}
ret = wiredtiger_struct_pack(session, buf, size, "iii", 42, 1000, -9);
ret = wiredtiger_struct_unpack(session, buf, size, "iii", &i, &j, &k);
/*! [packing] */
/* Note: closing the connection implicitly closes open session(s). */
if ((ret = conn->close(conn, NULL)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
return (ret);
}
static void
wt_open_corrupt(const char *sfx)
{
WT_CONNECTION *conn;
WT_DECL_RET;
char buf[1024];
if (sfx != NULL)
testutil_check(__wt_snprintf(buf, sizeof(buf),
"%s.%s", home, sfx));
else
testutil_check(__wt_snprintf(buf, sizeof(buf), "%s", home));
ret = wiredtiger_open(buf, &event_handler, NULL, &conn);
/*
* Not all out of sync combinations lead to corruption. We keep
* the previous checkpoint in the file so some combinations of
* future or old turtle files and metadata files will succeed.
*/
if (ret != WT_TRY_SALVAGE && ret != 0)
fprintf(stderr,
"OPEN_CORRUPT: wiredtiger_open returned %d\n", ret);
testutil_assert(ret == WT_TRY_SALVAGE || ret == 0);
exit (EXIT_SUCCESS);
}
int
main(void)
{
WT_CONNECTION *conn;
int ret;
/*! [Open a connection] */
ret = wiredtiger_open(home, NULL, "create,cache_size=500M", &conn);
/*! [Open a connection] */
if (ret == 0)
connection_ops(conn);
/*
* The connection has been closed.
*/
#ifdef MIGHT_NOT_RUN
/*
* This example code gets run, and the compression libraries might not
* be installed, causing the open to fail. The documentation requires
* the code snippets, use #ifdef's to avoid running it.
*/
/*! [Configure bzip2 extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_bzip2.so]", &conn);
/*! [Configure bzip2 extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure snappy extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_snappy.so]", &conn);
/*! [Configure snappy extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure zlib extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_zlib.so]", &conn);
/*! [Configure zlib extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*
* This example code gets run, and direct I/O might not be available,
* causing the open to fail. The documentation requires code snippets,
* use #ifdef's to avoid running it.
*/
/* Might Not Run: direct I/O may not be available. */
/*! [Configure direct_io for data files] */
ret = wiredtiger_open(home, NULL, "create,direct_io=[data]", &conn);
/*! [Configure direct_io for data files] */
if (ret == 0)
(void)conn->close(conn, NULL);
#endif
/*! [Configure file_extend] */
ret = wiredtiger_open(
home, NULL, "create,file_extend=(data=16MB)", &conn);
/*! [Configure file_extend] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Statistics configuration] */
ret = wiredtiger_open(home, NULL, "create,statistics=(all)", &conn);
/*! [Statistics configuration] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Statistics logging] */
ret = wiredtiger_open(
home, NULL, "create,statistics_log=(wait=30)", &conn);
/*! [Statistics logging] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Statistics logging with a table] */
ret = wiredtiger_open(home, NULL,
"create,"
"statistics_log=(sources=(\"table:table1\",\"table:table2\"))",
&conn);
/*! [Statistics logging with a table] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Statistics logging with all tables] */
ret = wiredtiger_open(home, NULL,
"create,statistics_log=(sources=(\"table:\"))",
&conn);
/*! [Statistics logging with all tables] */
if (ret == 0)
(void)conn->close(conn, NULL);
#ifdef MIGHT_NOT_RUN
/*
* This example code gets run, and a non-existent log file path might
* cause the open to fail. The documentation requires code snippets,
* use #ifdef's to avoid running it.
*/
/*! [Statistics logging with path] */
ret = wiredtiger_open(home, NULL,
"create,"
"statistics_log=(wait=120,path=/log/log.%m.%d.%y)", &conn);
/*! [Statistics logging with path] */
if (ret == 0)
(void)conn->close(conn, NULL);
#endif
/*! [Get the WiredTiger library version #1] */
printf("WiredTiger version %s\n", wiredtiger_version(NULL, NULL, NULL));
/*! [Get the WiredTiger library version #1] */
{
/*! [Get the WiredTiger library version #2] */
int major, minor, patch;
(void)wiredtiger_version(&major, &minor, &patch);
printf("WiredTiger version is %d, %d (patch %d)\n",
major, minor, patch);
/*! [Get the WiredTiger library version #2] */
}
return (ret);
}
void
wts_open(void)
{
WT_CONNECTION *conn;
WT_SESSION *session;
uint32_t maxintlpage, maxintlitem, maxleafpage, maxleafitem;
int ret;
const char *ext1, *ext2;
char config[512], *end, *p;
/* If the bzip2 compression module has been built, use it. */
#define EXTPATH "../../ext"
ext1 = EXTPATH "compressors/bzip2_compress/.libs/bzip2_compress.so";
if (access(ext1, R_OK) != 0) {
ext1 = "";
g.c_bzip = 0;
}
ext2 = EXTPATH "/collators/reverse/.libs/reverse_collator.so";
/*
* Open configuration -- put command line configuration options at the
* end so they can override "standard" configuration.
*/
snprintf(config, sizeof(config),
"create,error_prefix=\"%s\",cache_size=%" PRIu32 "MB,sync=false,"
"extensions=[\"%s\",\"%s\"],%s",
g.progname, g.c_cache, ext1, ext2,
g.config_open == NULL ? "" : g.config_open);
if ((ret =
wiredtiger_open("RUNDIR", &event_handler, config, &conn)) != 0)
die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
die(ret, "connection.open_session");
maxintlpage = 1U << g.c_intl_page_max;
/* Make sure at least 2 internal page per thread can fit in cache. */
while (2 * g.c_threads * maxintlpage > g.c_cache << 20)
maxintlpage >>= 1;
maxintlitem = MMRAND(maxintlpage / 50, maxintlpage / 40);
if (maxintlitem < 40)
maxintlitem = 40;
maxleafpage = 1U << g.c_leaf_page_max;
/* Make sure at least one leaf page per thread can fit in cache. */
while (g.c_threads * (maxintlpage + maxleafpage) > g.c_cache << 20)
maxleafpage >>= 1;
maxleafitem = MMRAND(maxleafpage / 50, maxleafpage / 40);
if (maxleafitem < 40)
maxleafitem = 40;
p = config;
end = config + sizeof(config);
p += snprintf(p, (size_t)(end - p),
"key_format=%s,"
"internal_page_max=%d,internal_item_max=%d,"
"leaf_page_max=%d,leaf_item_max=%d",
(g.type == ROW) ? "u" : "r",
maxintlpage, maxintlitem, maxleafpage, maxleafitem);
if (g.c_bzip)
p += snprintf(p, (size_t)(end - p),
",block_compressor=\"bzip2_compress\"");
switch (g.type) {
case FIX:
p += snprintf(p, (size_t)(end - p),
",value_format=%dt", g.c_bitcnt);
break;
case ROW:
if (g.c_huffman_key)
p += snprintf(p, (size_t)(end - p),
",huffman_key=english");
if (g.c_reverse)
p += snprintf(p, (size_t)(end - p),
",collator=reverse");
/* FALLTHROUGH */
case VAR:
if (g.c_huffman_value)
p += snprintf(p, (size_t)(end - p),
",huffman_value=english");
if (g.c_dictionary)
p += snprintf(p, (size_t)(end - p),
",dictionary=%d", MMRAND(123, 517));
break;
}
if ((ret = session->create(session, g.uri, config)) != 0)
die(ret, "session.create: %s", g.uri);
if ((ret = session->close(session, NULL)) != 0)
die(ret, "session.close");
g.wts_conn = conn;
}
int
main(int argc, char *argv[])
{
TEST_OPTS *opts, _opts;
WT_CURSOR *balancecur, *flagcur, *joincur, *postcur;
WT_CURSOR *maincur;
WT_SESSION *session;
int balance, count, flag, key, key2, post, ret;
char balanceuri[256];
char cfg[128];
char flaguri[256];
char joinuri[256];
char posturi[256];
const char *tablename;
opts = &_opts;
memset(opts, 0, sizeof(*opts));
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_progress(opts, "start");
testutil_check(wiredtiger_open(opts->home, NULL,
"create,cache_size=250M", &opts->conn));
testutil_progress(opts, "wiredtiger_open");
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_progress(opts, "sessions opened");
/*
* Note: repeated primary key 'id' as 'id2'. This makes
* it easier to dump an index and know which record we're
* looking at.
*/
testutil_check(session->create(session, opts->uri,
"key_format=i,value_format=iiii,"
"columns=(id,post,balance,flag,id2)"));
tablename = strchr(opts->uri, ':');
testutil_assert(tablename != NULL);
tablename++;
testutil_check(__wt_snprintf(
posturi, sizeof(posturi), "index:%s:post", tablename));
testutil_check(__wt_snprintf(
balanceuri, sizeof(balanceuri), "index:%s:balance", tablename));
testutil_check(__wt_snprintf(
flaguri, sizeof(flaguri), "index:%s:flag", tablename));
testutil_check(__wt_snprintf(
joinuri, sizeof(joinuri), "join:%s", opts->uri));
testutil_check(session->create(session, posturi, "columns=(post)"));
testutil_check(session->create(session, balanceuri,
"columns=(balance)"));
testutil_check(session->create(session, flaguri, "columns=(flag)"));
testutil_progress(opts, "setup complete");
/*
* Insert a single record with all items we are search for,
* this makes our logic easier.
*/
testutil_check(session->open_cursor(session, opts->uri, NULL, NULL,
&maincur));
maincur->set_key(maincur, N_RECORDS);
maincur->set_value(maincur, 54321, 0, "", 0, N_RECORDS);
testutil_check(maincur->insert(maincur));
testutil_check(maincur->close(maincur));
testutil_check(session->close(session, NULL));
testutil_progress(opts, "populate start");
populate(opts);
testutil_progress(opts, "populate end");
testutil_check(opts->conn->open_session(
opts->conn, NULL, NULL, &session));
testutil_check(session->open_cursor(session,
posturi, NULL, NULL, &postcur));
testutil_check(session->open_cursor(session,
balanceuri, NULL, NULL, &balancecur));
testutil_check(session->open_cursor(session,
flaguri, NULL, NULL, &flagcur));
testutil_check(session->open_cursor(session,
joinuri, NULL, NULL, &joincur));
postcur->set_key(postcur, 54321);
testutil_check(postcur->search(postcur));
testutil_check(session->join(session, joincur, postcur,
"compare=eq"));
balancecur->set_key(balancecur, 0);
testutil_check(balancecur->search(balancecur));
testutil_check(__wt_snprintf(cfg, sizeof(cfg),
"compare=lt,strategy=bloom,count=%d", N_RECORDS / 100));
testutil_check(session->join(session, joincur, balancecur, cfg));
flagcur->set_key(flagcur, 0);
testutil_check(flagcur->search(flagcur));
testutil_check(__wt_snprintf(cfg, sizeof(cfg),
"compare=eq,strategy=bloom,count=%d", N_RECORDS / 100));
testutil_check(session->join(session, joincur, flagcur, cfg));
/* Expect no values returned */
count = 0;
while ((ret = joincur->next(joincur)) == 0) {
/*
* The values may already have been changed, but
* print them for informational purposes.
*/
testutil_check(joincur->get_key(joincur, &key));
testutil_check(joincur->get_value(joincur, &post,
&balance, &flag, &key2));
fprintf(stderr, "FAIL: "
"key=%d/%d, postal_code=%d, balance=%d, flag=%d\n",
key, key2, post, balance, flag);
count++;
}
testutil_assert(ret == WT_NOTFOUND);
testutil_assert(count == 0);
testutil_progress(opts, "cleanup starting");
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
WT_SESSION *session;
clock_t ce, cs;
pthread_t idlist[100];
uint64_t i, id;
char buf[100];
/* Bypass this test for valgrind */
if (testutil_is_flag_set("TESTUTIL_BYPASS_VALGRIND"))
return (EXIT_SUCCESS);
opts = &_opts;
memset(opts, 0, sizeof(*opts));
opts->table_type = TABLE_ROW;
opts->n_append_threads = N_APPEND_THREADS;
opts->nrecords = N_RECORDS;
testutil_check(testutil_parse_opts(argc, argv, opts));
testutil_make_work_dir(opts->home);
testutil_check(__wt_snprintf(buf, sizeof(buf),
"create,"
"cache_size=%s,"
"eviction=(threads_max=5),"
"statistics=(fast)",
opts->table_type == TABLE_FIX ? "500MB" : "2GB"));
testutil_check(wiredtiger_open(opts->home, NULL, buf, &opts->conn));
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
testutil_check(__wt_snprintf(buf, sizeof(buf),
"key_format=r,value_format=%s,"
"allocation_size=4K,leaf_page_max=64K",
opts->table_type == TABLE_FIX ? "8t" : "S"));
testutil_check(session->create(session, opts->uri, buf));
testutil_check(session->close(session, NULL));
page_init(5000);
/* Force to disk and re-open. */
testutil_check(opts->conn->close(opts->conn, NULL));
testutil_check(wiredtiger_open(opts->home, NULL, NULL, &opts->conn));
(void)signal(SIGINT, onsig);
cs = clock();
id = 0;
for (i = 0; i < opts->n_append_threads; ++i, ++id) {
printf("append: %" PRIu64 "\n", id);
testutil_check(
pthread_create(&idlist[id], NULL, thread_append, opts));
}
for (i = 0; i < id; ++i)
testutil_check(pthread_join(idlist[i], NULL));
ce = clock();
printf("%" PRIu64 "M records: %.2lf processor seconds\n",
opts->max_inserted_id / MILLION,
(ce - cs) / (double)CLOCKS_PER_SEC);
testutil_cleanup(opts);
return (EXIT_SUCCESS);
}
int
main(void)
{
WT_CONNECTION *conn;
int ret;
/*
* Create a clean test directory for this run of the test program if the
* environment variable isn't already set (as is done by make check).
*/
if (getenv("WIREDTIGER_HOME") == NULL) {
home = "WT_HOME";
ret = system("rm -rf WT_HOME && mkdir WT_HOME");
} else
home = NULL;
/*! [Open a connection] */
ret = wiredtiger_open(home, NULL,
"create,cache_size=5GB,log=(enabled,recover=on)", &conn);
/*! [Open a connection] */
if (ret == 0)
ret = connection_ops(conn);
/*
* The connection has been closed.
*/
#ifdef MIGHT_NOT_RUN
/*
* This example code gets run, and the compression libraries might not
* be installed, causing the open to fail. The documentation requires
* the code snippets, use #ifdef's to avoid running it.
*/
/*! [Configure lz4 extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_lz4.so]", &conn);
/*! [Configure lz4 extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure snappy extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_snappy.so]", &conn);
/*! [Configure snappy extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure zlib extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_zlib.so]", &conn);
/*! [Configure zlib extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure zlib extension with compression level] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/"
"libwiredtiger_zlib.so=[config=[compression_level=3]]]", &conn);
/*! [Configure zlib extension with compression level] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure zstd extension] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/libwiredtiger_zstd.so]", &conn);
/*! [Configure zstd extension] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*! [Configure zstd extension with compression level] */
ret = wiredtiger_open(home, NULL,
"create,"
"extensions=[/usr/local/lib/"
"libwiredtiger_zstd.so=[config=[compression_level=9]]]", &conn);
/*! [Configure zstd extension with compression level] */
if (ret == 0)
(void)conn->close(conn, NULL);
/*
* This example code gets run, and direct I/O might not be available,
* causing the open to fail. The documentation requires code snippets,
* use #ifdef's to avoid running it.
*/
/* Might Not Run: direct I/O may not be available. */
/*! [Configure direct_io for data files] */
ret = wiredtiger_open(home, NULL, "create,direct_io=[data]", &conn);
/*! [Configure direct_io for data files] */
if (ret == 0)
(void)conn->close(conn, NULL);
#endif
/*! [Configure file_extend] */
ret = wiredtiger_open(
home, NULL, "create,file_extend=(data=16MB)", &conn);
/*! [Configure file_extend] */
if (ret == 0)
ret = conn->close(conn, NULL);
/*! [Eviction configuration] */
/*
* Configure eviction to begin at 90% full, and run until the cache
* is only 75% dirty.
*/
ret = wiredtiger_open(home, NULL,
"create,eviction_trigger=90,eviction_dirty_target=75", &conn);
/*! [Eviction configuration] */
if (ret == 0)
ret = conn->close(conn, NULL);
/*! [Eviction worker configuration] */
/* Configure up to four eviction threads */
ret = wiredtiger_open(home, NULL,
"create,eviction_trigger=90,eviction=(threads_max=4)", &conn);
/*! [Eviction worker configuration] */
if (ret == 0)
ret = conn->close(conn, NULL);
/*! [Statistics configuration] */
ret = wiredtiger_open(home, NULL, "create,statistics=(all)", &conn);
/*! [Statistics configuration] */
if (ret == 0)
ret = conn->close(conn, NULL);
/*! [Statistics logging] */
ret = wiredtiger_open(
home, NULL, "create,statistics_log=(wait=30)", &conn);
/*! [Statistics logging] */
if (ret == 0)
ret = conn->close(conn, NULL);
#ifdef MIGHT_NOT_RUN
/*
* Don't run this code, statistics logging doesn't yet support tables.
*/
/*! [Statistics logging with a table] */
ret = wiredtiger_open(home, NULL,
"create, statistics_log=("
"sources=(\"table:table1\",\"table:table2\"), wait=5)",
&conn);
/*! [Statistics logging with a table] */
if (ret == 0)
ret = conn->close(conn, NULL);
/*
* Don't run this code, statistics logging doesn't yet support indexes.
*/
/*! [Statistics logging with a source type] */
ret = wiredtiger_open(home, NULL,
"create, statistics_log=(sources=(\"index:\"), wait=5)",
&conn);
/*! [Statistics logging with a source type] */
if (ret == 0)
ret = conn->close(conn, NULL);
/*
* Don't run this code, because memory checkers get very upset when we
* leak memory.
*/
(void)wiredtiger_open(home, NULL, "create", &conn);
/*! [Connection close leaking memory] */
ret = conn->close(conn, "leak_memory=true");
/*! [Connection close leaking memory] */
#endif
/*! [Get the WiredTiger library version #1] */
printf("WiredTiger version %s\n", wiredtiger_version(NULL, NULL, NULL));
/*! [Get the WiredTiger library version #1] */
{
/*! [Get the WiredTiger library version #2] */
int major_v, minor_v, patch;
(void)wiredtiger_version(&major_v, &minor_v, &patch);
printf("WiredTiger version is %d, %d (patch %d)\n",
major_v, minor_v, patch);
/*! [Get the WiredTiger library version #2] */
}
return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
int
main(int argc, char *argv[])
{
struct stat sb;
FILE *fp;
WT_CONNECTION *conn;
WT_CURSOR *cur_coll, *cur_local, *cur_oplog, *cur_stable;
WT_RAND_STATE rnd;
WT_SESSION *session;
pid_t pid;
uint64_t absent_coll, absent_local, absent_oplog, count, key, last_key;
uint64_t first_miss, middle_coll, middle_local, middle_oplog;
uint64_t stable_fp, stable_val, val[MAX_TH+1];
uint32_t i, nth, timeout;
int ch, status, ret;
const char *working_dir;
char buf[512], fname[64], kname[64], statname[1024];
bool fatal, rand_th, rand_time, verify_only;
(void)testutil_set_progname(argv);
compat = inmem = false;
use_ts = true;
nth = MIN_TH;
rand_th = rand_time = true;
timeout = MIN_TIME;
verify_only = false;
working_dir = "WT_TEST.timestamp-abort";
while ((ch = __wt_getopt(progname, argc, argv, "Ch:mT:t:vz")) != EOF)
switch (ch) {
case 'C':
compat = true;
break;
case 'h':
working_dir = __wt_optarg;
break;
case 'm':
inmem = true;
break;
case 'T':
rand_th = false;
nth = (uint32_t)atoi(__wt_optarg);
break;
case 't':
rand_time = false;
timeout = (uint32_t)atoi(__wt_optarg);
break;
case 'v':
verify_only = true;
break;
case 'z':
use_ts = false;
break;
default:
usage();
}
argc -= __wt_optind;
argv += __wt_optind;
if (argc != 0)
usage();
testutil_work_dir_from_path(home, sizeof(home), working_dir);
/*
* If the user wants to verify they need to tell us how many threads
* there were so we can find the old record files.
*/
if (verify_only && rand_th) {
fprintf(stderr,
"Verify option requires specifying number of threads\n");
exit (EXIT_FAILURE);
}
if (!verify_only) {
testutil_make_work_dir(home);
__wt_random_init_seed(NULL, &rnd);
if (rand_time) {
timeout = __wt_random(&rnd) % MAX_TIME;
if (timeout < MIN_TIME)
timeout = MIN_TIME;
}
if (rand_th) {
nth = __wt_random(&rnd) % MAX_TH;
if (nth < MIN_TH)
nth = MIN_TH;
}
printf("Parent: compatibility: %s, "
"in-mem log sync: %s, timestamp in use: %s\n",
compat ? "true" : "false",
inmem ? "true" : "false",
use_ts ? "true" : "false");
printf("Parent: Create %" PRIu32
" threads; sleep %" PRIu32 " seconds\n", nth, timeout);
/*
* Fork a child to insert as many items. We will then randomly
* kill the child, run recovery and make sure all items we wrote
* exist after recovery runs.
*/
testutil_checksys((pid = fork()) < 0);
if (pid == 0) { /* child */
run_workload(nth);
return (EXIT_SUCCESS);
}
/* parent */
/*
* Sleep for the configured amount of time before killing
* the child. Start the timeout from the time we notice that
* the file has been created. That allows the test to run
* correctly on really slow machines. Verify the process ID
* still exists in case the child aborts for some reason we
* don't stay in this loop forever.
*/
testutil_check(__wt_snprintf(
statname, sizeof(statname), "%s/%s", home, ckpt_file));
while (stat(statname, &sb) != 0 && kill(pid, 0) == 0)
sleep(1);
sleep(timeout);
/*
* !!! It should be plenty long enough to make sure more than
* one log file exists. If wanted, that check would be added
* here.
*/
printf("Kill child\n");
testutil_checksys(kill(pid, SIGKILL) != 0);
testutil_checksys(waitpid(pid, &status, 0) == -1);
}
/*
* !!! If we wanted to take a copy of the directory before recovery,
* this is the place to do it.
*/
if (chdir(home) != 0)
testutil_die(errno, "parent chdir: %s", home);
testutil_check(__wt_snprintf(buf, sizeof(buf),
"rm -rf ../%s.SAVE && mkdir ../%s.SAVE && "
"cp -p WiredTigerLog.* ../%s.SAVE",
home, home, home));
(void)system(buf);
printf("Open database, run recovery and verify content\n");
/*
* Open the connection which forces recovery to be run.
*/
if ((ret = wiredtiger_open(NULL, NULL, ENV_CONFIG_REC, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
/*
* Open a cursor on all the tables.
*/
if ((ret = session->open_cursor(session,
uri_collection, NULL, NULL, &cur_coll)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri_collection);
if ((ret = session->open_cursor(session,
uri_local, NULL, NULL, &cur_local)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri_local);
if ((ret = session->open_cursor(session,
uri_oplog, NULL, NULL, &cur_oplog)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", uri_oplog);
if ((ret = session->open_cursor(session,
stable_store, NULL, NULL, &cur_stable)) != 0)
testutil_die(ret, "WT_SESSION.open_cursor: %s", stable_store);
/*
* Find the biggest stable timestamp value that was saved.
*/
stable_val = 0;
memset(val, 0, sizeof(val));
while (cur_stable->next(cur_stable) == 0) {
cur_stable->get_key(cur_stable, &key);
cur_stable->get_value(cur_stable, &val[key]);
if (val[key] > stable_val)
stable_val = val[key];
if (use_ts)
printf("Stable: key %" PRIu64 " value %" PRIu64 "\n",
key, val[key]);
}
if (use_ts)
printf("Got stable_val %" PRIu64 "\n", stable_val);
count = 0;
absent_coll = absent_local = absent_oplog = 0;
fatal = false;
for (i = 1; i <= nth; ++i) {
first_miss = middle_coll = middle_local = middle_oplog = 0;
testutil_check(__wt_snprintf(
fname, sizeof(fname), RECORDS_FILE, i));
if ((fp = fopen(fname, "r")) == NULL)
testutil_die(errno, "fopen: %s", fname);
/*
* For every key in the saved file, verify that the key exists
* in the table after recovery. If we're doing in-memory
* log buffering we never expect a record missing in the middle,
* but records may be missing at the end. If we did
* write-no-sync, we expect every key to have been recovered.
*/
for (last_key = UINT64_MAX;; ++count, last_key = key) {
ret = fscanf(fp, "%" SCNu64 "%" SCNu64 "\n",
&stable_fp, &key);
if (ret != EOF && ret != 2) {
/*
* If we find a partial line, consider it
* like an EOF.
*/
if (ret == 1 || ret == 0)
break;
testutil_die(errno, "fscanf");
}
if (ret == EOF)
break;
/*
* If we're unlucky, the last line may be a partially
* written key at the end that can result in a false
* negative error for a missing record. Detect it.
*/
if (last_key != UINT64_MAX && key != last_key + 1) {
printf("%s: Ignore partial record %" PRIu64
" last valid key %" PRIu64 "\n",
fname, key, last_key);
break;
}
testutil_check(__wt_snprintf(
kname, sizeof(kname), "%" PRIu64, key));
cur_coll->set_key(cur_coll, kname);
cur_local->set_key(cur_local, kname);
cur_oplog->set_key(cur_oplog, kname);
/*
* The collection table should always only have the
* data as of the checkpoint.
*/
if ((ret = cur_coll->search(cur_coll)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
/*
* If we don't find a record, the stable
* timestamp written to our file better be
* larger than the saved one.
*/
if (!inmem &&
stable_fp != 0 && stable_fp <= val[i]) {
printf("%s: COLLECTION no record with "
"key %" PRIu64 " record ts %" PRIu64
" <= stable ts %" PRIu64 "\n",
fname, key, stable_fp, val[i]);
absent_coll++;
}
if (middle_coll == 0)
first_miss = key;
middle_coll = key;
} else if (middle_coll != 0) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
printf("%s: COLLECTION after absent records %"
PRIu64 "-%" PRIu64 " key %" PRIu64
" exists\n",
fname, first_miss, middle_coll, key);
fatal = true;
}
/*
* The local table should always have all data.
*/
if ((ret = cur_local->search(cur_local)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
if (!inmem)
printf("%s: LOCAL no record with key %"
PRIu64 "\n", fname, key);
absent_local++;
middle_local = key;
} else if (middle_local != 0) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
printf("%s: LOCAL after absent record at %"
PRIu64 " key %" PRIu64 " exists\n",
fname, middle_local, key);
fatal = true;
}
/*
* The oplog table should always have all data.
*/
if ((ret = cur_oplog->search(cur_oplog)) != 0) {
if (ret != WT_NOTFOUND)
testutil_die(ret, "search");
if (!inmem)
printf("%s: OPLOG no record with key %"
PRIu64 "\n", fname, key);
absent_oplog++;
middle_oplog = key;
} else if (middle_oplog != 0) {
/*
* We should never find an existing key after
* we have detected one missing.
*/
printf("%s: OPLOG after absent record at %"
PRIu64 " key %" PRIu64 " exists\n",
fname, middle_oplog, key);
fatal = true;
}
}
testutil_checksys(fclose(fp) != 0);
}
if ((ret = conn->close(conn, NULL)) != 0)
testutil_die(ret, "WT_CONNECTION:close");
if (fatal)
return (EXIT_FAILURE);
if (!inmem && absent_coll) {
printf("COLLECTION: %" PRIu64
" record(s) absent from %" PRIu64 "\n",
absent_coll, count);
fatal = true;
}
if (!inmem && absent_local) {
printf("LOCAL: %" PRIu64 " record(s) absent from %" PRIu64 "\n",
absent_local, count);
fatal = true;
}
if (!inmem && absent_oplog) {
printf("OPLOG: %" PRIu64 " record(s) absent from %" PRIu64 "\n",
absent_oplog, count);
fatal = true;
}
if (fatal)
return (EXIT_FAILURE);
printf("%" PRIu64 " records verified\n", count);
return (EXIT_SUCCESS);
}
static void
run_workload(uint32_t nth)
{
WT_CONNECTION *conn;
WT_SESSION *session;
WT_THREAD_DATA *td;
wt_thread_t *thr;
uint32_t i;
int ret;
char envconf[512];
thr = dcalloc(nth+1, sizeof(*thr));
td = dcalloc(nth+1, sizeof(WT_THREAD_DATA));
if (chdir(home) != 0)
testutil_die(errno, "Child chdir: %s", home);
if (inmem)
strcpy(envconf, ENV_CONFIG_DEF);
else
strcpy(envconf, ENV_CONFIG_TXNSYNC);
if (compat)
strcat(envconf, ENV_CONFIG_COMPAT);
if ((ret = wiredtiger_open(NULL, NULL, envconf, &conn)) != 0)
testutil_die(ret, "wiredtiger_open");
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "WT_CONNECTION:open_session");
/*
* Create all the tables.
*/
if ((ret = session->create(session, uri_collection,
"key_format=S,value_format=u,log=(enabled=false)")) != 0)
testutil_die(ret, "WT_SESSION.create: %s", uri_collection);
if ((ret = session->create(session,
uri_local, "key_format=S,value_format=u")) != 0)
testutil_die(ret, "WT_SESSION.create: %s", uri_local);
if ((ret = session->create(session,
uri_oplog, "key_format=S,value_format=u")) != 0)
testutil_die(ret, "WT_SESSION.create: %s", uri_oplog);
/*
* Don't log the stable timestamp table so that we know what timestamp
* was stored at the checkpoint.
*/
if ((ret = session->create(session, stable_store,
"key_format=Q,value_format=Q,log=(enabled=false)")) != 0)
testutil_die(ret, "WT_SESSION.create: %s", stable_store);
if ((ret = session->close(session, NULL)) != 0)
testutil_die(ret, "WT_SESSION:close");
/*
* Thread 0 is the checkpoint thread.
*/
td[0].conn = conn;
td[0].id = 0;
printf("Create checkpoint thread\n");
testutil_check(__wt_thread_create(
NULL, &thr[0], thread_ckpt_run, &td[0]));
for (i = 1; i <= nth; ++i) {
td[i].conn = conn;
td[i].start = (UINT64_MAX / nth) * (i - 1);
td[i].id = i;
testutil_check(__wt_thread_create(
NULL, &thr[i], thread_run, &td[i]));
}
/*
* The threads never exit, so the child will just wait here until
* it is killed.
*/
printf("Create %" PRIu32 " writer threads\n", nth);
fflush(stdout);
for (i = 0; i <= nth; ++i)
testutil_check(__wt_thread_join(NULL, thr[i]));
/*
* NOTREACHED
*/
free(thr);
free(td);
exit(EXIT_SUCCESS);
}
int main(void)
{
/*! [example connection] */
WT_ASYNC_OP *op;
WT_CONNECTION *wt_conn;
WT_SESSION *session;
int i, ret;
char k[MAX_KEYS][16], v[MAX_KEYS][16];
if ((ret = wiredtiger_open(home, NULL,
"create,cache_size=100MB,async=(enabled=true,ops_max=10,threads=2)",
&wt_conn)) != 0) {
fprintf(stderr, "Error connecting to %s: %s\n",
home, wiredtiger_strerror(ret));
return (ret);
}
/*! [example connection] */
/*! [example table create] */
ret = wt_conn->open_session(wt_conn, NULL, NULL, &session);
ret = session->create(session, uri,
"key_format=S,value_format=S");
/*! [example table create] */
for (i = 0; i < MAX_KEYS; i++) {
/*! [Allocate a handle] */
op = NULL;
retry:
ret = wt_conn->async_new_op(wt_conn, uri, NULL, &cb, &op);
if (ret != 0) {
/*
* If we used up all the ops, pause and retry to
* give the workers a chance to process them.
*/
fprintf(stderr,
"Iteration %d: async_new_op ret %d\n",i,ret);
sleep(1);
goto retry;
}
/*! [Allocate a handle] */
snprintf(k[i], sizeof(k), "key%d", i);
snprintf(v[i], sizeof(v), "value%d", i);
/*! [Set the operation's string key] */
op->set_key(op, k[i]);
/*! [Set the operation's string key] */
/*! [Set the operation's string value] */
op->set_value(op, v[i]);
/*! [Set the operation's string value] */
/*! [example insert] */
ret = op->insert(op);
/*! [example insert] */
}
/*! [flush] */
wt_conn->async_flush(wt_conn);
/*! [flush] */
/*! [Compact a table] */
ret = wt_conn->async_new_op(wt_conn, uri, "timeout=10", &cb, &op);
op->compact(op);
/*! [Compact a table] */
for (i = 0; i < MAX_KEYS; i++) {
op = NULL;
retry2:
ret = wt_conn->async_new_op(wt_conn, uri, NULL, &cb, &op);
if (ret != 0) {
/*
* If we used up all the ops, pause and retry to
* give the workers a chance to process them.
*/
fprintf(stderr,
"Iteration %d: async_new_op ret %d\n",i,ret);
sleep(1);
goto retry2;
}
snprintf(k[i], sizeof(k), "key%d", i);
op->set_key(op, k[i]);
/*! [search] */
op->search(op);
/*! [search] */
}
/*! [example close] */
/*
* Connection close automatically does an async_flush so it will
* allow all queued search operations to complete.
*/
ret = wt_conn->close(wt_conn, NULL);
/*! [example close] */
return (ret);
}
