void fill_sql(int sql_id)
{
if (param_text) {
snprintf(sql_buf, BUF_SIZE,
sql_template,
value_gen_text(sql_id, 0),
value_gen_text(sql_id, 1),
value_gen_text(sql_id, 2),
value_gen_text(sql_id, 3),
value_gen_text(sql_id, 4),
value_gen_text(sql_id, 5),
value_gen_text(sql_id, 6),
value_gen_text(sql_id, 7),
value_gen_text(sql_id, 8),
value_gen_text(sql_id, 9));
return;
}
snprintf(sql_buf, BUF_SIZE,
sql_template,
value_gen(sql_id, 0), // sql_id
value_gen(sql_id, 1), // mod10
value_gen(sql_id, 2), // mod10
value_gen(sql_id, 3), // mod10
value_gen(sql_id, 4), // sql_id
value_gen(sql_id, 5), // sql_id
value_gen(sql_id, 6), // sql_id
value_gen(sql_id, 7), // sql_id
value_gen(sql_id, 8), // sql_id
value_gen(sql_id, 9)); // sql_id
return;
}
/*
* row_update --
* Update a row in a row-store file.
*/
static void
row_update(
WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t keyno, int insert)
{
WT_SESSION *session;
int notfound, ret;
session = cursor->session;
key_gen((uint8_t *)key->data, &key->size, keyno, insert);
value_gen((uint8_t *)value->data, &value->size, keyno);
/* Log the operation */
if (g.logging == LOG_OPS)
(void)session->msg_printf(session, "%-10s{%.*s}\n%-10s{%.*s}",
insert ? "insertK" : "putK",
(int)key->size, (char *)key->data,
insert ? "insertV" : "putV",
(int)value->size, (char *)value->data);
cursor->set_key(cursor, key);
cursor->set_value(cursor, value);
ret = cursor->insert(cursor);
if (ret != 0 && ret != WT_NOTFOUND)
die(ret,
"row_update: %s row %" PRIu64 " by key",
insert ? "insert" : "update", keyno);
if (!SINGLETHREADED)
return;
bdb_update(key->data, key->size, value->data, value->size, ¬found);
(void)notfound_chk("row_update", ret, notfound, keyno);
}
/*
* row_insert --
* Insert a row in a row-store file.
*/
static int
row_insert(
WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t keyno)
{
WT_SESSION *session;
int notfound, ret;
session = cursor->session;
key_gen((uint8_t *)key->data, &key->size, keyno, 1);
value_gen((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}",
"insertK", (int)key->size, (char *)key->data,
"insertV", (int)value->size, (char *)value->data);
cursor->set_key(cursor, key);
cursor->set_value(cursor, value);
ret = cursor->insert(cursor);
if (ret == WT_DEADLOCK)
return (WT_DEADLOCK);
if (ret != 0 && ret != WT_NOTFOUND)
die(ret, "row_insert: insert row %" PRIu64 " by key", keyno);
if (!SINGLETHREADED)
return (0);
bdb_update(key->data, key->size, value->data, value->size, ¬found);
(void)notfound_chk("row_insert", ret, notfound, keyno);
return (0);
}
/*
* col_insert --
* Insert an element in a column-store file.
*/
static void
col_insert(WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t *keynop)
{
WT_SESSION *session;
uint64_t keyno;
int notfound, ret;
session = cursor->session;
value_gen((uint8_t *)value->data, &value->size, g.rows + 1);
if (g.c_file_type == FIX)
cursor->set_value(cursor, *(uint8_t *)value->data);
else
cursor->set_value(cursor, value);
if ((ret = cursor->insert(cursor)) != 0)
die(ret, "cursor.insert");
if ((ret = cursor->get_key(cursor, &keyno)) != 0)
die(ret, "cursor.get_key");
*keynop = (uint32_t)keyno;
/*
* Assign the maximum number of rows to the returned key: that key may
* not be the current maximum value, if we race with another thread,
* but that's OK, we just want it to keep increasing so we don't ignore
* records at the end of the table.
*/
g.rows = (uint32_t)keyno;
if (g.logging == LOG_OPS) {
if (g.c_file_type == FIX)
(void)session->msg_printf(session,
"%-10s%" PRIu64 " {0x%02" PRIx8 "}",
"insert", keyno,
((uint8_t *)value->data)[0]);
else
(void)session->msg_printf(session,
"%-10s%" PRIu64 " {%.*s}",
"insert", keyno,
(int)value->size, (char *)value->data);
}
if (!SINGLETHREADED)
return;
key_gen((uint8_t *)key->data, &key->size, keyno, 0);
bdb_update(key->data, key->size, value->data, value->size, ¬found);
}
/*
* col_insert --
* Insert an element in a column-store file.
*/
static int
col_insert(WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t *keynop)
{
WT_SESSION *session;
uint64_t keyno;
int notfound, ret;
session = cursor->session;
value_gen((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_DEADLOCK)
return (WT_DEADLOCK);
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);
}
if (!SINGLETHREADED)
return (0);
key_gen((uint8_t *)key->data, &key->size, keyno, 0);
bdb_update(key->data, key->size, value->data, value->size, ¬found);
return (0);
}
/*
* col_update --
* Update a row in a column-store file.
*/
static int
col_update(WT_CURSOR *cursor, WT_ITEM *key, WT_ITEM *value, uint64_t keyno)
{
WT_SESSION *session;
int notfound, ret;
session = cursor->session;
value_gen((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_DEADLOCK)
return (WT_DEADLOCK);
if (ret != 0 && ret != WT_NOTFOUND)
die(ret, "col_update: %" PRIu64, keyno);
if (!SINGLETHREADED)
return (0);
key_gen((uint8_t *)key->data, &key->size, keyno, 0);
bdb_update(key->data, key->size, value->data, value->size, ¬found);
(void)notfound_chk("col_update", ret, notfound, keyno);
return (0);
}
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 default key buffer. */
key_gen_setup(&keybuf);
val_gen_setup(&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, 0);
key.data = keybuf;
value_gen(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");
if (!SINGLETHREADED)
continue;
/* Insert the item into BDB. */
bdb_insert(key.data, key.size, value.data, value.size);
}
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);
}
