int internal_key_compare(void *a, void *b) { TXID atxid; TXID btxid; struct msg ma; struct msg mb; register int r; register struct fixkey *fk; if (!a) return -1; if (!b) return +1; fk = (struct fixkey*)a; atxid = fk->txid >> 8; ma.size = fk->ksize; ma.data = ((char*)a + FIXKEY_SIZE); fk = (struct fixkey*)b; btxid = fk->txid >> 8; mb.size = fk->ksize; mb.data = ((char*)b + FIXKEY_SIZE); r = msg_key_compare(&ma, &mb); if (r == 0) { if (atxid > btxid) r = -1; else if (atxid < btxid) r = +1; } return r; }
CTEST(basement, insert_and_lookup) { int i; int ret; int R = 1000; char kbuf[KEY_SIZE]; char vbuf[VAL_SIZE]; struct basement_iter iter; struct basement *bsm = basement_new(); struct msg **msgs = xcalloc(R, sizeof(*msgs)); struct txnid_pair xidpair = { .child_xid = TXNID_NONE, .parent_xid = TXNID_NONE }; MSN msn = 0U; _random_key(vbuf, VAL_SIZE); for (i = 0; i < R; i++) { memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-%d", i); struct msg k = {.data = kbuf, .size = KEY_SIZE}; struct msg v = {.data = vbuf, .size = VAL_SIZE}; msgs[i] = msgdup(&k); basement_put(bsm, msn++, MSG_INSERT, &k, &v, &xidpair ); } basement_iter_init(&iter, bsm); basement_iter_seektolast(&iter); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); for (i = 0; i < R; i++) { basement_iter_seek(&iter, msgs[i]); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); ret = msg_key_compare(msgs[i], &iter.key); ASSERT_EQUAL(0, ret); } /* do msg free */ for (i = 0; i < R; i++) { xfree(msgs[i]->data); xfree(msgs[i]); } xfree(msgs); basement_free(bsm); xcheck_all_free(); }
int search_pivotbound_compare(struct search *so, struct msg *m) { return msg_key_compare(so->pivot_bound, m); }
CTEST(node_serial_test, node_2th_part_empty) { int ret = 0; NID nid; uint32_t n_children = 3; int fd = ness_os_open(BRT_FILE, O_RDWR | O_CREAT, 0777); struct block *b = block_new(); struct hdr *hdr = (struct hdr*)xcalloc(1, sizeof(*hdr)); struct options *opts = options_new(); /* * serialize */ struct node *dummy_node; hdr->last_nid++; nid = hdr->last_nid; dummy_node = nonleaf_alloc_empty(nid, 1, n_children); nonleaf_alloc_buffer(dummy_node); struct msg p0; p0.size = 6; p0.data = "pivot0"; msgcpy(&dummy_node->u.n.pivots[0], &p0); struct msg p1; p1.size = 6; p1.data = "pivot1"; msgcpy(&dummy_node->u.n.pivots[1], &p1); MSN msn = 0U; struct xids *xids = NULL; struct msg k, v; k.size = 5; k.data = "hello"; v.size = 5; v.data = "world"; basement_put(dummy_node->u.n.parts[0].buffer, &k, &v, MSG_INSERT, msn, xids); hdr->method = NESS_QUICKLZ_METHOD; ret = serialize_node_to_disk(fd, b, dummy_node, hdr); ASSERT_TRUE(ret > 0); node_free(dummy_node); //deserialize int light = 0; struct node *dummy_node1; ret = deserialize_node_from_disk(fd, b, nid, &dummy_node1, light); ASSERT_TRUE(ret > 0); ASSERT_EQUAL(1, dummy_node1->height); ASSERT_EQUAL(3, dummy_node1->u.n.n_children); ASSERT_DATA((const unsigned char*)"pivot0", 6, (const unsigned char*)dummy_node1->u.n.pivots[0].data, dummy_node1->u.n.pivots[0].size); ASSERT_DATA((const unsigned char*)"pivot1", 6, (const unsigned char*)dummy_node1->u.n.pivots[1].data, dummy_node1->u.n.pivots[1].size); ASSERT_EQUAL(3, dummy_node1->u.n.n_children); if (!light) { int cmp; struct basement_iter iter; struct basement *bsm; bsm = dummy_node1->u.n.parts[0].buffer; basement_iter_init(&iter, bsm); int mb_c = basement_count(dummy_node1->u.n.parts[0].buffer); ASSERT_EQUAL(1, mb_c); basement_iter_seek(&iter, &k); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); cmp = msg_key_compare(&k, &iter.key); ASSERT_EQUAL(0, cmp); cmp = msg_key_compare(&v, &iter.val); ASSERT_EQUAL(0, cmp); mb_c = basement_count(dummy_node1->u.n.parts[1].buffer); ASSERT_EQUAL(0, mb_c); } node_free(dummy_node1); ness_os_close(fd); block_free(b); xfree(hdr); options_free(opts); xcheck_all_free(); }
CTEST(basement, multiversion) { int i; int ret; int R = 123; char kbuf[KEY_SIZE]; char vbuf[VAL_SIZE]; struct basement_iter iter; struct basement *bsm = basement_new(); struct txnid_pair xidpair = { .child_xid = TXNID_NONE, .parent_xid = TXNID_NONE }; _random_key(vbuf, VAL_SIZE); MSN msn = 0U; for (i = 0; i < R; i++) { memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-%d", i); struct msg k = {.data = kbuf, .size = KEY_SIZE}; struct msg v = {.data = vbuf, .size = VAL_SIZE}; basement_put(bsm, msn++, MSG_INSERT, &k, &v, &xidpair ); } /* 3 versions of key-66 */ R = 3; for (i = 0; i < R; i++) { memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-66"); struct msg k = {.data = kbuf, .size = KEY_SIZE}; struct msg v = {.data = vbuf, .size = VAL_SIZE}; basement_put(bsm, msn++, MSG_INSERT, &k, &v, &xidpair ); } /* 5 versions of key-88 */ R = 5; for (i = 0; i < R; i++) { memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-88"); struct msg k = {.data = kbuf, .size = KEY_SIZE}; struct msg v = {.data = vbuf, .size = VAL_SIZE}; basement_put(bsm, msn++, MSG_INSERT, &k, &v, &xidpair ); } /* key-66 */ memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-66"); struct msg k1 = {.data = kbuf, .size = KEY_SIZE}; basement_iter_init(&iter, bsm); basement_iter_seek(&iter, &k1); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); ASSERT_EQUAL(66, iter.msn); basement_iter_next(&iter); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); ASSERT_EQUAL(123, iter.msn); /* less than valid */ ret = basement_iter_valid_lessorequal(&iter, &k1); ASSERT_EQUAL(1, ret); memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-67"); k1.size = KEY_SIZE; k1.data = kbuf; ret = basement_iter_valid_lessorequal(&iter, &k1); ASSERT_EQUAL(1, ret); memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-65"); k1.size = KEY_SIZE; k1.data = kbuf; ret = basement_iter_valid_lessorequal(&iter, &k1); ASSERT_EQUAL(0, ret); /* key-88 */ memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-88"); struct msg k2 = {.data = kbuf, .size = KEY_SIZE}; basement_iter_seek(&iter, &k2); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); ASSERT_EQUAL(88, iter.msn); basement_iter_next(&iter); basement_iter_next(&iter); ret = basement_iter_valid(&iter); ASSERT_EQUAL(1, ret); ASSERT_EQUAL(127, iter.msn); /* next&prev diff key */ /* key-87 */ memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-87"); struct msg k3 = {.data = kbuf, .size = KEY_SIZE}; basement_iter_prev_diff_key(&iter); ret = msg_key_compare(&k3, &iter.key); ASSERT_EQUAL(0, ret); /* key-88 */ basement_iter_next(&iter); memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-88"); struct msg k22 = {.data = kbuf, .size = KEY_SIZE}; ret = msg_key_compare(&k22, &iter.key); ASSERT_EQUAL(0, ret); /* key-89 */ memset(kbuf, 0, KEY_SIZE); snprintf(kbuf, KEY_SIZE, "key-89"); struct msg k4 = {.data = kbuf, .size = KEY_SIZE}; basement_iter_next_diff_key(&iter); ret = msg_key_compare(&k4, &iter.key); ASSERT_EQUAL(0, ret); basement_free(bsm); xcheck_all_free(); }