/* * 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); }