/* * 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); }
void bdb_remove(uint64_t keyno, int *notfoundp) { DBC *dbc = g.dbc; size_t size; int ret; size = 0; key_gen(&keyitem, keyno); key.data = (void *)keyitem.data; key.size = (u_int32_t)keyitem.size; bdb_read(keyno, &value.data, &size, notfoundp); value.size = (u_int32_t)size; if (*notfoundp) return; /* Deleting a fixed-length item is the same as setting the bits to 0. */ if (g.type == FIX) bdb_update(key.data, key.size, "", 1); else if ((ret = dbc->del(dbc, 0)) != 0) { if (ret != DB_NOTFOUND) bdb_die(ret, "dbc.del: {%.*s}", (int)key.size, (char *)key.data); *notfoundp = 1; } }
/* * 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 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); }
/* * 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_remove -- * Remove a row from a column-store file. */ static int col_remove(WT_CURSOR *cursor, WT_ITEM *key, uint64_t keyno, int *notfoundp) { WT_SESSION *session; int ret; session = cursor->session; /* Log the operation */ if (g.logging == LOG_OPS) (void)g.wt_api->msg_printf( g.wt_api, session, "%-10s%" PRIu64, "remove", keyno); cursor->set_key(cursor, keyno); /* We use the cursor in overwrite mode, check for existence. */ if ((ret = cursor->search(cursor)) == 0) ret = cursor->remove(cursor); if (ret == WT_ROLLBACK) return (WT_ROLLBACK); if (ret != 0 && ret != WT_NOTFOUND) testutil_die(ret, "col_remove: remove %" PRIu64 " by key", keyno); *notfoundp = (ret == WT_NOTFOUND); #ifdef HAVE_BERKELEY_DB if (!SINGLETHREADED) return (0); { int notfound; /* * Deleting a fixed-length item is the same as setting the bits to 0; * do the same thing for the BDB store. */ if (g.type == FIX) { key_gen((uint8_t *)key->data, &key->size, keyno); bdb_update(key->data, key->size, "\0", 1, ¬found); } else bdb_remove(keyno, ¬found); (void)notfound_chk("col_remove", ret, notfound, keyno); } #else (void)key; /* [-Wunused-variable] */ #endif 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); }
/* * 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); }