/*
* Each thread inserts a set of keys into the record store database. The keys
* are generated in such a way that there are large gaps in the key range.
*/
static void *
thread_func(void *arg)
{
TEST_OPTS *opts;
WT_CURSOR *cursor, *idx_cursor;
WT_SESSION *session;
uint64_t i, ins_rotor, ins_thr_idx, thr_idx, ts;
uint64_t *obj_data;
opts = (TEST_OPTS *)arg;
thr_idx = __wt_atomic_fetch_addv64(&opts->next_threadid, 1);
ts = g_ts;
obj_data = dcalloc(
(NR_OBJECTS/NR_THREADS + 1) * NR_FIELDS, sizeof(*obj_data));
testutil_check(opts->conn->open_session(
opts->conn, NULL, NULL, &session));
testutil_check(session->open_cursor(
session, opts->uri, NULL, NULL, &cursor));
testutil_check(session->open_cursor(
session, "table:index", NULL, NULL, &idx_cursor));
for (ins_rotor = 1; ins_rotor < 10; ++ins_rotor) {
for (ins_thr_idx = thr_idx, i = 0; ins_thr_idx < NR_OBJECTS;
ins_thr_idx += NR_THREADS, i += NR_FIELDS) {
testutil_check(
session->begin_transaction(session, "sync=false"));
cursor->set_key(cursor, ins_thr_idx << 40 | ins_rotor);
cursor->set_value(cursor, ts,
obj_data[i+0], obj_data[i+1], obj_data[i+2],
obj_data[i+3], obj_data[i+4], obj_data[i+5],
obj_data[i+6], obj_data[i+7]);
testutil_check(cursor->insert(cursor));
idx_cursor->set_key(
idx_cursor, ins_thr_idx << 40 | ts);
idx_cursor->set_value(idx_cursor, ins_rotor);
testutil_check(idx_cursor->insert(idx_cursor));
testutil_check(
session->commit_transaction(session, NULL));
/* change object fields */
++obj_data[i + ((ins_thr_idx + ins_rotor) % NR_FIELDS)];
++obj_data[i +
((ins_thr_idx + ins_rotor + 1) % NR_FIELDS)];
++g_ts;
/* 5K updates/sec */
(void)usleep(1000000ULL * NR_THREADS / 5000);
}
}
testutil_check(session->close(session, NULL));
free(obj_data);
return (NULL);
}
const std::string WiredTigerEngine::Stats()
{
std::string info;
int major_v, minor_v, patch;
(void) wiredtiger_version(&major_v, &minor_v, &patch);
info.append("WiredTiger version:").append(stringfromll(major_v)).append(".").append(stringfromll(minor_v)).append(
".").append(stringfromll(patch)).append("\r\n");
info.append("WiredTiger Init Options:").append(m_cfg.init_options).append("\r\n");
info.append("WiredTiger Table Init Options:").append(m_cfg.init_table_options).append("\r\n");
ContextHolder& holder = m_context.GetValue();
WT_SESSION* session = holder.session;
if (NULL == session)
{
return info;
}
WT_CURSOR *cursor;
int ret;
/*! [statistics database function] */
if ((ret = session->open_cursor(session, "statistics:", NULL, NULL, &cursor)) == 0)
{
print_cursor(cursor, info);
cursor->close(cursor);
}
if ((ret = session->open_cursor(session, "statistics:table:ardb", NULL, NULL, &cursor)) == 0)
{
print_cursor(cursor, info);
cursor->close(cursor);
}
return info;
}
/*
* wts_stats --
* Dump the run's statistics.
*/
void
wts_stats(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
FILE *fp;
const char *pval, *desc;
uint64_t v;
int ret;
track("stat", 0ULL, NULL);
conn = g.wts_conn;
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
die(ret, "connection.open_session");
if ((fp = fopen("__stats", "w")) == NULL)
die(errno, "fopen: __stats");
/* Connection statistics. */
if ((ret = session->open_cursor(session,
"statistics:", NULL, NULL, &cursor)) != 0)
die(ret, "session.open_cursor");
while ((ret = cursor->next(cursor)) == 0 &&
(ret = cursor->get_value(cursor, &desc, &pval, &v)) == 0)
if (fprintf(fp, "%s=%s\n", desc, pval) < 0)
die(errno, "fprintf");
if (ret != WT_NOTFOUND)
die(ret, "cursor.next");
if ((ret = cursor->close(cursor)) != 0)
die(ret, "cursor.close");
/* File statistics. */
if ((ret = session->open_cursor(session,
"statistics:" WT_TABLENAME, NULL, NULL, &cursor)) != 0)
die(ret, "session.open_cursor");
while ((ret = cursor->next(cursor)) == 0 &&
(ret = cursor->get_value(cursor, &desc, &pval, &v)) == 0)
if (fprintf(fp, "%s=%s\n", desc, pval) < 0)
die(errno, "fprintf");
if (ret != WT_NOTFOUND)
die(ret, "cursor.next");
if ((ret = cursor->close(cursor)) != 0)
die(ret, "cursor.close");
if ((ret = fclose(fp)) != 0)
die(ret, "fclose");
if ((ret = session->close(session, NULL)) != 0)
die(ret, "session.close");
}
int
main(int argc, char *argv[])
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
home = example_setup(argc, argv);
/* Open a connection to the database, creating it if necessary. */
error_check(wiredtiger_open(
home, NULL, "create,statistics=(fast)", &conn));
/* Open a session for the current thread's work. */
error_check(conn->open_session(conn, NULL, NULL, &session));
error_check(session->create(session, "table:world",
"key_format=r,value_format=5sii,"
"columns=(id,country,population,area)"));
/*! [open cursor #1] */
error_check(session->open_cursor(
session, "table:world", NULL, NULL, &cursor));
/*! [open cursor #1] */
/*! [open cursor #2] */
error_check(session->open_cursor(session,
"table:world(country,population)", NULL, NULL, &cursor));
/*! [open cursor #2] */
/*! [open cursor #3] */
error_check(session->open_cursor(
session, "statistics:", NULL, NULL, &cursor));
/*! [open cursor #3] */
/* Create a simple string table to illustrate basic operations. */
error_check(session->create(
session, "table:map", "key_format=S,value_format=S"));
error_check(session->open_cursor(
session, "table:map", NULL, NULL, &cursor));
error_check(cursor_insert(cursor));
error_check(cursor_reset(cursor));
error_check(cursor_forward_scan(cursor));
error_check(cursor_reset(cursor));
error_check(cursor_reverse_scan(cursor));
error_check(cursor_search_near(cursor));
error_check(cursor_update(cursor));
error_check(cursor_remove(cursor));
error_check(cursor->close(cursor));
/* Note: closing the connection implicitly closes open session(s). */
error_check(conn->close(conn, NULL));
return (EXIT_SUCCESS);
}
int main(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
int 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));
ret = session->create(session, "table:world",
"key_format=r,value_format=5sii,"
"columns=(id,country,population,area)");
/*! [open cursor #1] */
ret = session->open_cursor(session, "table:world", NULL, NULL, &cursor);
/*! [open cursor #1] */
/*! [open cursor #2] */
ret = session->open_cursor(session,
"table:world(country,population)", NULL, NULL, &cursor);
/*! [open cursor #2] */
/*! [open cursor #3] */
ret = session->open_cursor(session, "statistics:", NULL, NULL, &cursor);
/*! [open cursor #3] */
/* Create a simple string table to illustrate basic operations. */
ret = session->create(session, "table:map",
"key_format=S,value_format=S");
ret = session->open_cursor(session, "table:map", NULL, NULL, &cursor);
ret = cursor_insert(cursor);
ret = cursor_reset(cursor);
ret = cursor_forward_scan(cursor);
ret = cursor_reset(cursor);
ret = cursor_reverse_scan(cursor);
ret = cursor_update(cursor);
ret = cursor_remove(cursor);
ret = cursor->close(cursor);
/* 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);
}
WiredTigerSizeStorer::WiredTigerSizeStorer(WT_CONNECTION* conn, const std::string& storageUri)
: _session(conn) {
WT_SESSION* session = _session.getSession();
int ret = session->open_cursor(session, storageUri.c_str(), NULL, "overwrite=true", &_cursor);
if (ret == ENOENT) {
// Need to create table.
std::string config = WiredTigerCustomizationHooks::get(getGlobalServiceContext())
->getTableCreateConfig(storageUri);
invariantWTOK(session->create(session, storageUri.c_str(), config.c_str()));
ret = session->open_cursor(session, storageUri.c_str(), NULL, "overwrite=true", &_cursor);
}
invariantWTOK(ret);
_magic = MAGIC;
}
/*! [thread main] */
int
main(void)
{
WT_SESSION *session;
WT_CURSOR *cursor;
pthread_t threads[NUM_THREADS];
int i, ret;
if ((ret = wiredtiger_open(home, NULL,
"create", &conn)) != 0)
fprintf(stderr, "Error connecting to %s: %s\n",
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, NULL);
for (i = 0; i < NUM_THREADS; i++)
ret = pthread_join(threads[i], NULL);
ret = conn->close(conn, NULL);
return (ret);
}
void
obj_bulk(void)
{
WT_CURSOR *c;
WT_SESSION *session;
int ret;
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "conn.session");
if ((ret = session->create(session, uri, config)) != 0)
if (ret != EEXIST && ret != EBUSY)
testutil_die(ret, "session.create");
if (ret == 0) {
__wt_yield();
if ((ret = session->open_cursor(
session, uri, NULL, "bulk", &c)) == 0) {
if ((ret = c->close(c)) != 0)
testutil_die(ret, "cursor.close");
} else if (ret != ENOENT && ret != EBUSY && ret != EINVAL)
testutil_die(ret, "session.open_cursor bulk");
}
if ((ret = session->close(session, NULL)) != 0)
testutil_die(ret, "session.close");
}
/*! [thread scan] */
void *
scan_thread(void *conn_arg)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
const char *key, *value;
int ret;
conn = conn_arg;
ret = conn->open_session(conn, NULL, NULL, &session);
ret = session->open_cursor(
session, "table:access", NULL, NULL, &cursor);
/* Show all records. */
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);
}
if (ret != WT_NOTFOUND)
fprintf(stderr,
"WT_CURSOR.next: %s\n", session->strerror(session, ret));
return (NULL);
}
static void
sweep_stats(void)
{
static const int list[] = {
WT_STAT_CONN_CURSOR_SWEEP_BUCKETS,
WT_STAT_CONN_CURSOR_SWEEP_CLOSED,
WT_STAT_CONN_CURSOR_SWEEP_EXAMINED,
WT_STAT_CONN_CURSOR_SWEEP,
WT_STAT_CONN_DH_SWEEP_REF,
WT_STAT_CONN_DH_SWEEP_CLOSE,
WT_STAT_CONN_DH_SWEEP_REMOVE,
WT_STAT_CONN_DH_SWEEP_TOD,
WT_STAT_CONN_DH_SWEEPS,
WT_STAT_CONN_DH_SESSION_SWEEPS,
-1
};
WT_SESSION *session;
WT_CURSOR *cursor;
uint64_t value;
int i;
const char *desc, *pvalue;
testutil_check(conn->open_session(conn, NULL, NULL, &session));
testutil_check(session->open_cursor(
session, "statistics:", NULL, NULL, &cursor));
for (i = 0;; ++i) {
if (list[i] == -1)
break;
cursor->set_key(cursor, list[i]);
testutil_check(cursor->search(cursor));
testutil_check(
cursor->get_value(cursor, &desc, &pvalue, &value));
printf("\t" "%s=%s\n", desc, pvalue);
}
}
/*
* Open and close cursor on a table.
*/
void
op_cursor(void *arg)
{
TEST_OPTS *opts;
TEST_PER_THREAD_OPTS *args;
WT_CURSOR *cursor;
WT_SESSION *session;
int i, ret;
args = (TEST_PER_THREAD_OPTS *)arg;
opts = args->testopts;
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
if ((ret = session->open_cursor(
session, opts->uri, NULL, NULL, &cursor)) != 0) {
if (ret != ENOENT && ret != EBUSY)
testutil_die(ret, "session.open_cursor");
} else {
/* Put some data in if asked to. */
if (args->testopts->do_data_ops) {
for (i = 0; i < 1000; i++) {
cursor->set_key(cursor, i);
cursor->set_value(cursor, "abcdef");
cursor->insert(cursor);
}
}
testutil_check(cursor->close(cursor));
}
testutil_check(session->close(session, NULL));
args->thread_counter++;
}
/*
* Create a table and open a bulk cursor on it.
*/
void
op_bulk(void *arg)
{
TEST_OPTS *opts;
TEST_PER_THREAD_OPTS *args;
WT_CURSOR *c;
WT_SESSION *session;
int ret;
args = (TEST_PER_THREAD_OPTS *)arg;
opts = args->testopts;
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
if ((ret = session->create(session,
opts->uri, DEFAULT_TABLE_SCHEMA)) != 0)
if (ret != EEXIST && ret != EBUSY)
testutil_die(ret, "session.create");
if (ret == 0) {
__wt_yield();
if ((ret = session->open_cursor(session,
opts->uri, NULL, "bulk,checkpoint_wait=false", &c)) == 0) {
testutil_check(c->close(c));
} else if (ret != ENOENT && ret != EBUSY && ret != EINVAL)
testutil_die(ret, "session.open_cursor bulk");
}
testutil_check(session->close(session, NULL));
args->thread_counter++;
}
/*
* Ensure that icount matches the number of records in the
* existing table.
*/
int find_table_count(CONFIG *cfg)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
char *key;
int ret;
conn = cfg->conn;
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0) {
lprintf(cfg, ret, 0,
"open_session failed finding existing table count");
goto err;
}
if ((ret = session->open_cursor(session, cfg->uri,
NULL, NULL, &cursor)) != 0) {
lprintf(cfg, ret, 0,
"open_cursor failed finding existing table count");
goto err;
}
if ((ret = cursor->prev(cursor)) != 0) {
lprintf(cfg, ret, 0,
"cursor prev failed finding existing table count");
goto err;
}
cursor->get_key(cursor, &key);
cfg->icount = (uint32_t)atoi(key);
err: session->close(session, NULL);
return (ret);
}
int
main(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
int ret;
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);
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);
}
static void
page_init(uint64_t n)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
uint64_t recno, vrecno;
char buf[64];
conn = opts->conn;
testutil_check(conn->open_session(conn, NULL, NULL, &session));
testutil_check(
session->open_cursor(session, opts->uri, NULL, "append", &cursor));
vrecno = 0;
buf[0] = '\2';
for (recno = 1;; ++recno) {
if (opts->table_type == TABLE_FIX)
cursor->set_value(cursor, buf[0]);
else {
if (recno % 3 == 0)
++vrecno;
testutil_check(__wt_snprintf(buf,
sizeof(buf), "%" PRIu64 " VALUE ------", vrecno));
cursor->set_value(cursor, buf);
}
testutil_check(cursor->insert(cursor));
testutil_check(cursor->get_key(cursor, &opts->max_inserted_id));
if (opts->max_inserted_id >= n)
break;
}
}
explicit WtDbTransaction(WtWritableSegment* seg)
: m_seg(seg), m_sconf(*seg->m_schema)
{
WT_CONNECTION* conn = seg->m_wtConn;
int err = conn->open_session(conn, NULL, NULL, &m_session.ses);
if (err) {
THROW_STD(invalid_argument
, "FATAL: wiredtiger open session(dir=%s) = %s"
, conn->get_home(conn), wiredtiger_strerror(err)
);
}
WT_SESSION* ses = m_session.ses;
err = ses->open_cursor(ses, g_dataStoreUri, NULL, "overwrite=true", &m_store.cursor);
if (err) {
THROW_STD(invalid_argument
, "ERROR: wiredtiger store open cursor: %s"
, ses->strerror(ses, err));
}
m_indices.resize(seg->m_indices.size());
for (size_t indexId = 0; indexId < m_indices.size(); ++indexId) {
ReadableIndex* index = seg->m_indices[indexId].get();
WtWritableIndex* wtIndex = dynamic_cast<WtWritableIndex*>(index);
assert(NULL != wtIndex);
const char* uri = wtIndex->getIndexUri().c_str();
err = ses->open_cursor(ses, uri, NULL, "overwrite=false", &m_indices[indexId].insert.cursor);
if (err) {
THROW_STD(invalid_argument
, "ERROR: wiredtiger open index cursor: %s"
, ses->strerror(ses, err));
}
err = ses->open_cursor(ses, uri, NULL, "overwrite=true", &m_indices[indexId].overwrite.cursor);
if (err) {
THROW_STD(invalid_argument
, "ERROR: wiredtiger open index cursor: %s"
, ses->strerror(ses, err));
}
}
m_sizeDiff = 0;
m_wrtStore = dynamic_cast<WtWritableStore*>(seg->m_wrtStore.get());
assert(nullptr != m_store);
g_wtDbTxnLiveCnt++;
g_wtDbTxnCreatedCnt++;
if (getEnvBool("TerarkDB_TrackBuggyObjectLife")) {
fprintf(stderr, "DEBUG: WtDbTransaction live count = %zd, created = %zd\n"
, g_wtDbTxnLiveCnt.load(), g_wtDbTxnCreatedCnt.load());
}
}
/*
* stats
* Dump the database/file statistics.
*/
void
stats(void)
{
FILE *fp;
WT_CURSOR *cursor;
WT_SESSION *session;
uint64_t v;
int ret;
const char *desc, *pval;
char name[64];
testutil_check(conn->open_session(conn, NULL, NULL, &session));
if ((fp = fopen(FNAME_STAT, "w")) == NULL)
testutil_die(errno, "fopen " FNAME_STAT);
/* Connection statistics. */
testutil_check(session->open_cursor(
session, "statistics:", NULL, NULL, &cursor));
while ((ret = cursor->next(cursor)) == 0 &&
(ret = cursor->get_value(cursor, &desc, &pval, &v)) == 0)
(void)fprintf(fp, "%s=%s\n", desc, pval);
if (ret != WT_NOTFOUND)
testutil_die(ret, "cursor.next");
testutil_check(cursor->close(cursor));
/* File statistics. */
if (!multiple_files) {
testutil_check(__wt_snprintf(
name, sizeof(name), "statistics:" FNAME, 0));
testutil_check(session->open_cursor(
session, name, NULL, NULL, &cursor));
while ((ret = cursor->next(cursor)) == 0 &&
(ret = cursor->get_value(cursor, &desc, &pval, &v)) == 0)
(void)fprintf(fp, "%s=%s\n", desc, pval);
if (ret != WT_NOTFOUND)
testutil_die(ret, "cursor.next");
testutil_check(cursor->close(cursor));
testutil_check(session->close(session, NULL));
}
(void)fclose(fp);
}
WiredTigerSizeStorer::WiredTigerSizeStorer(WT_CONNECTION* conn, const std::string& storageUri)
: _session(conn)
{
WT_SESSION* session = _session.getSession();
int ret = session->open_cursor(session, storageUri.c_str(), NULL,
"overwrite=true", &_cursor);
if (ret == ENOENT) {
// Need to create table.
// TODO any config options we want?
invariantWTOK(session->create(session, storageUri.c_str(), NULL));
ret = session->open_cursor(session, storageUri.c_str(), NULL,
"overwrite=true", &_cursor);
}
invariantWTOK(ret);
_magic = MAGIC;
}
bool restore() final {
// We can't use the CursorCache since this cursor needs a special config string.
WT_SESSION* session = WiredTigerRecoveryUnit::get(_txn)->getSession(_txn)->getSession();
if (!_cursor) {
invariantWTOK(
session->open_cursor(session, _rs->_uri.c_str(), NULL, "next_random", &_cursor));
invariant(_cursor);
}
return true;
}
/*
* Create a guaranteed unique table and open and close a bulk cursor on it.
*/
void
op_bulk_unique(void *arg)
{
TEST_OPTS *opts;
TEST_PER_THREAD_OPTS *args;
WT_CURSOR *c;
WT_RAND_STATE rnd;
WT_SESSION *session;
int ret;
char new_uri[64];
args = (TEST_PER_THREAD_OPTS *)arg;
opts = args->testopts;
__wt_random_init_seed(NULL, &rnd);
testutil_check(
opts->conn->open_session(opts->conn, NULL, NULL, &session));
/* Generate a unique object name. */
testutil_check(__wt_snprintf(
new_uri, sizeof(new_uri), "%s.%" PRIu64,
opts->uri, __wt_atomic_add64(&opts->unique_id, 1)));
testutil_check(session->create(session, new_uri, DEFAULT_TABLE_SCHEMA));
__wt_yield();
/*
* Opening a bulk cursor may have raced with a forced checkpoint
* which created a checkpoint of the empty file, and triggers an EINVAL.
*/
if ((ret = session->open_cursor(
session, new_uri, NULL, "bulk,checkpoint_wait=false", &c)) == 0) {
testutil_check(c->close(c));
} else if (ret != EINVAL && ret != EBUSY)
testutil_die(ret,
"session.open_cursor bulk unique: %s", new_uri);
while ((ret = session->drop(session, new_uri, __wt_random(&rnd) & 1 ?
"force,checkpoint_wait=false" : "checkpoint_wait=false")) != 0)
if (ret != EBUSY)
testutil_die(ret, "session.drop: %s", new_uri);
else
/*
* The EBUSY is expected when we run with
* checkpoint_wait set to false, so we increment the
* counter while in this loop to avoid false positives.
*/
args->thread_counter++;
testutil_check(session->close(session, NULL));
args->thread_counter++;
}
WT_CURSOR *
wt_ctx_index_cursor(wt_ctx *wc, struct berval *name, int create)
{
WT_CURSOR *cursor = NULL;
WT_SESSION *session = wc->session;
char tablename[1024];
int rc;
snprintf(tablename, sizeof(tablename), "table:%s", name->bv_val);
rc = session->open_cursor(session, tablename, NULL,
"overwrite=false", &cursor);
if (rc == ENOENT && create) {
rc = session->create(session,
tablename,
"key_format=uQ,"
"value_format=x,"
"columns=(key, id, none)");
if( rc ) {
Debug( LDAP_DEBUG_ANY,
LDAP_XSTRING(indexer) ": table \"%s\": "
"cannot create idnex table: %s (%d)\n",
tablename, wiredtiger_strerror(rc), rc);
return NULL;
}
rc = session->open_cursor(session, tablename, NULL,
"overwrite=false", &cursor);
}
if ( rc ) {
Debug( LDAP_DEBUG_ANY,
LDAP_XSTRING(wt_id2entry_put)
": open cursor failed: %s (%d)\n",
wiredtiger_strerror(rc), rc, 0 );
return NULL;
}
return cursor;
}
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);
}
Status WiredTigerKVEngine::beginBackup(OperationContext* txn) {
invariant(!_backupSession);
// This cursor will be freed by the backupSession being closed as the session is uncached
auto session = stdx::make_unique<WiredTigerSession>(_conn);
WT_CURSOR* c = NULL;
WT_SESSION* s = session->getSession();
int ret = WT_OP_CHECK(s->open_cursor(s, "backup:", NULL, NULL, &c));
if (ret != 0) {
return wtRCToStatus(ret);
}
_backupSession = std::move(session);
return Status::OK();
}
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);
}
void
load(SHARED_CONFIG *cfg, const char *name)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_ITEM *value, _value;
WT_SESSION *session;
size_t len;
uint64_t keyno;
char keybuf[64], valuebuf[64];
conn = cfg->conn;
file_create(cfg, name);
testutil_check(conn->open_session(conn, NULL, NULL, &session));
testutil_check(
session->open_cursor(session, name, NULL, "bulk", &cursor));
value = &_value;
for (keyno = 1; keyno <= cfg->nkeys; ++keyno) {
if (cfg->ftype == ROW) {
testutil_check(__wt_snprintf(
keybuf, sizeof(keybuf), "%016" PRIu64, keyno));
cursor->set_key(cursor, keybuf);
} else
cursor->set_key(cursor, (uint32_t)keyno);
value->data = valuebuf;
if (cfg->ftype == FIX)
cursor->set_value(cursor, 0x01);
else {
testutil_check(__wt_snprintf_len_set(
valuebuf, sizeof(valuebuf),
&len, "%37" PRIu64, keyno));
value->size = (uint32_t)len;
cursor->set_value(cursor, value);
}
testutil_check(cursor->insert(cursor));
}
/* Setup the starting key range for the workload phase. */
cfg->key_range = cfg->nkeys;
testutil_check(cursor->close(cursor));
testutil_check(session->checkpoint(session, NULL));
testutil_check(session->close(session, NULL));
}
/*
* process --
* Salvage, verify and dump the created file.
*/
void
process(void)
{
FILE *fp;
WT_CONNECTION *conn;
WT_CURSOR *cursor;
const char *key, *value;
WT_SESSION *session;
char config[100];
/* Salvage. */
config[0] = '\0';
if (verbose)
snprintf(config, sizeof(config),
"error_prefix=\"%s\",verbose=[salvage,verify],",
progname);
strcat(config, "log=(enabled=false),");
CHECK(wiredtiger_open(NULL, NULL, config, &conn) == 0);
CHECK(conn->open_session(conn, NULL, NULL, &session) == 0);
CHECK(session->salvage(session, "file:" SLVG, 0) == 0);
CHECK(conn->close(conn, 0) == 0);
/* Verify. */
CHECK(wiredtiger_open(NULL, NULL, config, &conn) == 0);
CHECK(conn->open_session(conn, NULL, NULL, &session) == 0);
CHECK(session->verify(session, "file:" SLVG, 0) == 0);
CHECK(conn->close(conn, 0) == 0);
/* Dump. */
CHECK((fp = fopen(DUMP, "w")) != NULL);
CHECK(wiredtiger_open(NULL, NULL, config, &conn) == 0);
CHECK(conn->open_session(conn, NULL, NULL, &session) == 0);
CHECK(session->open_cursor(
session, "file:" SLVG, NULL, "dump=print", &cursor) == 0);
while (cursor->next(cursor) == 0) {
if (page_type == WT_PAGE_ROW_LEAF) {
CHECK(cursor->get_key(cursor, &key) == 0);
CHECK(fputs(key, fp) >= 0);
CHECK(fputc('\n', fp) >= 0);
}
CHECK(cursor->get_value(cursor, &value) == 0);
CHECK(fputs(value, fp) >= 0);
CHECK(fputc('\n', fp) >= 0);
}
CHECK(conn->close(conn, 0) == 0);
CHECK(fclose(fp) == 0);
}
/*
* Append to a table in a "racy" fashion - that is attempt to insert the
* same record another thread is likely to also be inserting.
*/
void *
thread_insert_race(void *arg)
{
TEST_OPTS *opts;
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_SESSION *session;
uint64_t i, value;
int ret;
opts = (TEST_OPTS *)arg;
conn = opts->conn;
testutil_check(conn->open_session(conn, NULL, NULL, &session));
testutil_check(session->open_cursor(
session, opts->uri, NULL, NULL, &cursor));
printf("Running insert thread\n");
for (i = 0; i < opts->nrecords; ++i) {
testutil_check(
session->begin_transaction(session, "isolation=snapshot"));
cursor->set_key(cursor, 1);
testutil_check(cursor->search(cursor));
testutil_check(cursor->get_value(cursor, &value));
cursor->set_key(cursor, 1);
cursor->set_value(cursor, value + 1);
if ((ret = cursor->update(cursor)) != 0) {
if (ret == WT_ROLLBACK) {
testutil_check(session->rollback_transaction(
session, NULL));
i--;
continue;
}
printf("Error in update: %d\n", ret);
}
testutil_check(session->commit_transaction(session, NULL));
if (i % 10000 == 0) {
printf("insert: %" PRIu64 "\r", i);
fflush(stdout);
}
}
if (i > 10000)
printf("\n");
opts->running = false;
return (NULL);
}
/*
* wts_read_scan --
* Read and verify all elements in a file.
*/
void
wts_read_scan(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_ITEM key;
WT_SESSION *session;
uint64_t cnt, last_cnt;
uint8_t *keybuf;
int ret;
conn = g.wts_conn;
/* Set up the default key buffer. */
key_gen_setup(&keybuf);
/* Open a session and cursor pair. */
if ((ret = conn->open_session(
conn, NULL, ops_session_config(NULL), &session)) != 0)
die(ret, "connection.open_session");
if ((ret = session->open_cursor(
session, g.uri, NULL, NULL, &cursor)) != 0)
die(ret, "session.open_cursor");
/* Check a random subset of the records using the key. */
for (last_cnt = cnt = 0; cnt < g.key_cnt;) {
cnt += mmrand(NULL, 1, 17);
if (cnt > g.rows)
cnt = g.rows;
if (cnt - last_cnt > 1000) {
track("read row scan", cnt, NULL);
last_cnt = cnt;
}
key.data = keybuf;
if ((ret = read_row(cursor, &key, cnt)) != 0)
die(ret, "read_scan");
}
if ((ret = session->close(session, NULL)) != 0)
die(ret, "session.close");
free(keybuf);
}
void
load(const char *name)
{
WT_CURSOR *cursor;
WT_ITEM *key, _key, *value, _value;
WT_SESSION *session;
size_t len;
uint64_t keyno;
char keybuf[64], valuebuf[64];
file_create(name);
testutil_check(conn->open_session(conn, NULL, NULL, &session));
testutil_check(
session->open_cursor(session, name, NULL, "bulk", &cursor));
key = &_key;
value = &_value;
for (keyno = 1; keyno <= nkeys; ++keyno) {
if (ftype == ROW) {
testutil_check(__wt_snprintf_len_set(
keybuf, sizeof(keybuf),
&len, "%017" PRIu64, keyno));
key->data = keybuf;
key->size = (uint32_t)len;
cursor->set_key(cursor, key);
} else
cursor->set_key(cursor, keyno);
if (ftype == FIX)
cursor->set_value(cursor, 0x01);
else {
testutil_check(__wt_snprintf_len_set(
valuebuf, sizeof(valuebuf),
&len, "%37" PRIu64, keyno));
value->data = valuebuf;
value->size = (uint32_t)len;
cursor->set_value(cursor, value);
}
testutil_check(cursor->insert(cursor));
}
testutil_check(session->close(session, NULL));
}
void
load(const char *name)
{
WT_CURSOR *cursor;
WT_ITEM *key, _key, *value, _value;
WT_SESSION *session;
char keybuf[64], valuebuf[64];
u_int keyno;
int ret;
file_create(name);
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
testutil_die(ret, "conn.session");
if ((ret =
session->open_cursor(session, name, NULL, "bulk", &cursor)) != 0)
testutil_die(ret, "cursor.open");
key = &_key;
value = &_value;
for (keyno = 1; keyno <= nkeys; ++keyno) {
if (ftype == ROW) {
key->data = keybuf;
key->size = (uint32_t)
snprintf(keybuf, sizeof(keybuf), "%017u", keyno);
cursor->set_key(cursor, key);
} else
cursor->set_key(cursor, (uint32_t)keyno);
value->data = valuebuf;
if (ftype == FIX)
cursor->set_value(cursor, 0x01);
else {
value->size = (uint32_t)
snprintf(valuebuf, sizeof(valuebuf), "%37u", keyno);
cursor->set_value(cursor, value);
}
if ((ret = cursor->insert(cursor)) != 0)
testutil_die(ret, "cursor.insert");
}
if ((ret = session->close(session, NULL)) != 0)
testutil_die(ret, "session.close");
}