/*
* col_insert --
* Insert an element in a column-store file.
*/
static int
col_insert(TINFO *tinfo,
WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t *keynop)
{
WT_SESSION *session;
uint64_t keyno;
int ret;
session = cursor->session;
val_gen(&tinfo->rnd, (uint8_t *)value->data, &value->size, g.rows + 1);
if (g.type == FIX)
cursor->set_value(cursor, *(uint8_t *)value->data);
else
cursor->set_value(cursor, value);
if ((ret = cursor->insert(cursor)) != 0) {
if (ret == WT_ROLLBACK)
return (WT_ROLLBACK);
die(ret, "cursor.insert");
}
if ((ret = cursor->get_key(cursor, &keyno)) != 0)
die(ret, "cursor.get_key");
*keynop = (uint32_t)keyno;
table_append(keyno); /* Extend the object. */
if (g.logging == LOG_OPS) {
if (g.type == FIX)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s%" PRIu64 " {0x%02" PRIx8 "}",
"insert", keyno,
((uint8_t *)value->data)[0]);
else
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s%" PRIu64 " {%.*s}",
"insert", keyno,
(int)value->size, (char *)value->data);
}
#ifdef HAVE_BERKELEY_DB
if (!SINGLETHREADED)
return (0);
{
int notfound;
key_gen((uint8_t *)key->data, &key->size, keyno);
bdb_update(key->data, key->size, value->data, value->size, ¬found);
}
#else
(void)key; /* [-Wunused-variable] */
#endif
return (0);
}
/*
* col_update --
* Update a row in a column-store file.
*/
static int
col_update(TINFO *tinfo,
WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t keyno)
{
WT_SESSION *session;
int ret;
session = cursor->session;
val_gen(&tinfo->rnd, (uint8_t *)value->data, &value->size, keyno);
/* Log the operation */
if (g.logging == LOG_OPS) {
if (g.type == FIX)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s%" PRIu64 " {0x%02" PRIx8 "}",
"update", keyno,
((uint8_t *)value->data)[0]);
else
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s%" PRIu64 " {%.*s}",
"update", keyno,
(int)value->size, (char *)value->data);
}
cursor->set_key(cursor, keyno);
if (g.type == FIX)
cursor->set_value(cursor, *(uint8_t *)value->data);
else
cursor->set_value(cursor, value);
ret = cursor->update(cursor);
if (ret == WT_ROLLBACK)
return (WT_ROLLBACK);
if (ret != 0 && ret != WT_NOTFOUND)
die(ret, "col_update: %" PRIu64, keyno);
#ifdef HAVE_BERKELEY_DB
if (!SINGLETHREADED)
return (0);
{
int notfound;
key_gen((uint8_t *)key->data, &key->size, keyno);
bdb_update(key->data, key->size, value->data, value->size, ¬found);
(void)notfound_chk("col_update", ret, notfound, keyno);
}
#else
(void)key; /* [-Wunused-variable] */
#endif
return (0);
}
/*
* row_update --
* Update a row in a row-store file.
*/
static int
row_update(TINFO *tinfo,
WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t keyno)
{
WT_SESSION *session;
int ret;
session = cursor->session;
key_gen((uint8_t *)key->data, &key->size, keyno);
val_gen(&tinfo->rnd, (uint8_t *)value->data, &value->size, keyno);
/* Log the operation */
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s{%.*s}\n%-10s{%.*s}",
"putK", (int)key->size, (char *)key->data,
"putV", (int)value->size, (char *)value->data);
cursor->set_key(cursor, key);
cursor->set_value(cursor, value);
ret = cursor->update(cursor);
if (ret == WT_ROLLBACK)
return (WT_ROLLBACK);
if (ret != 0 && ret != WT_NOTFOUND)
testutil_die(ret,
"row_update: update row %" PRIu64 " by key", keyno);
#ifdef HAVE_BERKELEY_DB
if (!SINGLETHREADED)
return (0);
{
int notfound;
bdb_update(key->data, key->size, value->data, value->size, ¬found);
(void)notfound_chk("row_update", ret, notfound, keyno);
}
#endif
return (0);
}
void
wts_load(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_DECL_RET;
WT_ITEM key, value;
WT_SESSION *session;
bool is_bulk;
conn = g.wts_conn;
testutil_check(conn->open_session(conn, NULL, NULL, &session));
if (g.logging != 0)
(void)g.wt_api->msg_printf(g.wt_api, session,
"=============== bulk load start ===============");
/*
* No bulk load with data-sources.
*
* No bulk load with custom collators, the order of insertion will not
* match the collation order.
*/
is_bulk = true;
if (DATASOURCE("kvsbdb"))
is_bulk = false;
if (g.c_reverse)
is_bulk = false;
/*
* open_cursor can return EBUSY if concurrent with a metadata
* operation, retry in that case.
*/
while ((ret = session->open_cursor(session, g.uri, NULL,
is_bulk ? "bulk,append" : NULL, &cursor)) == EBUSY)
__wt_yield();
testutil_check(ret);
/* Set up the key/value buffers. */
key_gen_init(&key);
val_gen_init(&value);
for (;;) {
if (++g.key_cnt > g.c_rows) {
g.key_cnt = g.rows = g.c_rows;
break;
}
/* Report on progress every 100 inserts. */
if (g.key_cnt % 1000 == 0)
track("bulk load", g.key_cnt, NULL);
key_gen(&key, g.key_cnt);
val_gen(NULL, &value, g.key_cnt);
switch (g.type) {
case FIX:
if (!is_bulk)
cursor->set_key(cursor, g.key_cnt);
cursor->set_value(cursor, *(uint8_t *)value.data);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu64 " {0x%02" PRIx8 "}",
"bulk V",
g.key_cnt, ((uint8_t *)value.data)[0]);
break;
case VAR:
if (!is_bulk)
cursor->set_key(cursor, g.key_cnt);
cursor->set_value(cursor, &value);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu64 " {%.*s}", "bulk V",
g.key_cnt,
(int)value.size, (char *)value.data);
break;
case ROW:
cursor->set_key(cursor, &key);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu64 " {%.*s}", "bulk K",
g.key_cnt, (int)key.size, (char *)key.data);
cursor->set_value(cursor, &value);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu64 " {%.*s}", "bulk V",
g.key_cnt,
(int)value.size, (char *)value.data);
break;
}
/*
* We don't want to size the cache to ensure the initial data
* set can load in the in-memory case, guaranteeing the load
* succeeds probably means future updates are also guaranteed
* to succeed, which isn't what we want. If we run out of space
* in the initial load, reset the row counter and continue.
*
* Decrease inserts, they can't be successful if we're at the
* cache limit, and increase the delete percentage to get some
* extra space once the run starts.
*/
if ((ret = cursor->insert(cursor)) != 0) {
if (ret != WT_CACHE_FULL)
testutil_die(ret, "cursor.insert");
g.rows = --g.key_cnt;
g.c_rows = (uint32_t)g.key_cnt;
if (g.c_insert_pct > 5)
g.c_insert_pct = 5;
if (g.c_delete_pct < 20)
g.c_delete_pct += 20;
break;
}
#ifdef HAVE_BERKELEY_DB
if (SINGLETHREADED)
bdb_insert(key.data, key.size, value.data, value.size);
#endif
}
testutil_check(cursor->close(cursor));
if (g.logging != 0)
(void)g.wt_api->msg_printf(g.wt_api, session,
"=============== bulk load stop ===============");
testutil_check(session->close(session, NULL));
key_gen_teardown(&key);
val_gen_teardown(&value);
}
void
wts_load(void)
{
WT_CONNECTION *conn;
WT_CURSOR *cursor;
WT_ITEM key, value;
WT_SESSION *session;
uint8_t *keybuf, *valbuf;
int is_bulk, ret;
conn = g.wts_conn;
if ((ret = conn->open_session(conn, NULL, NULL, &session)) != 0)
die(ret, "connection.open_session");
if (g.logging != 0)
(void)g.wt_api->msg_printf(g.wt_api, session,
"=============== bulk load start ===============");
/*
* Avoid bulk load with KVS (there's no bulk load support for a
* data-source); avoid bulk load with a custom collator, because
* the order of insertion will not match the collation order.
*/
is_bulk = !g.c_reverse &&
!DATASOURCE("kvsbdb") && !DATASOURCE("helium");
if ((ret = session->open_cursor(session, g.uri, NULL,
is_bulk ? "bulk" : NULL, &cursor)) != 0)
die(ret, "session.open_cursor");
/* Set up the key/value buffers. */
key_gen_setup(&keybuf);
val_gen_setup(NULL, &valbuf);
for (;;) {
if (++g.key_cnt > g.c_rows) {
g.key_cnt = g.rows = g.c_rows;
break;
}
/* Report on progress every 100 inserts. */
if (g.key_cnt % 100 == 0)
track("bulk load", g.key_cnt, NULL);
key_gen(keybuf, &key.size, (uint64_t)g.key_cnt);
key.data = keybuf;
val_gen(NULL, valbuf, &value.size, (uint64_t)g.key_cnt);
value.data = valbuf;
switch (g.type) {
case FIX:
if (!is_bulk)
cursor->set_key(cursor, g.key_cnt);
cursor->set_value(cursor, *(uint8_t *)value.data);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu32 " {0x%02" PRIx8 "}",
"bulk V",
g.key_cnt, ((uint8_t *)value.data)[0]);
break;
case VAR:
if (!is_bulk)
cursor->set_key(cursor, g.key_cnt);
cursor->set_value(cursor, &value);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu32 " {%.*s}", "bulk V",
g.key_cnt,
(int)value.size, (char *)value.data);
break;
case ROW:
cursor->set_key(cursor, &key);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu32 " {%.*s}", "bulk K",
g.key_cnt, (int)key.size, (char *)key.data);
cursor->set_value(cursor, &value);
if (g.logging == LOG_OPS)
(void)g.wt_api->msg_printf(g.wt_api, session,
"%-10s %" PRIu32 " {%.*s}", "bulk V",
g.key_cnt,
(int)value.size, (char *)value.data);
break;
}
if ((ret = cursor->insert(cursor)) != 0)
die(ret, "cursor.insert");
#ifdef HAVE_BERKELEY_DB
if (SINGLETHREADED)
bdb_insert(key.data, key.size, value.data, value.size);
#endif
}
if ((ret = cursor->close(cursor)) != 0)
die(ret, "cursor.close");
if (g.logging != 0)
(void)g.wt_api->msg_printf(g.wt_api, session,
"=============== bulk load stop ===============");
if ((ret = session->close(session, NULL)) != 0)
die(ret, "session.close");
free(keybuf);
free(valbuf);
}
