Adjusted the way that Wrapping records works to clean up interfaces

5 files changed, 63 insertions, 79 deletions

diff --git a/tests/dynamic_extension_tests.cpp b/tests/dynamic_extension_tests.cpp
index b74ab38..9fdd5f9 100644
--- a/tests/dynamic_extension_tests.cpp
+++ b/tests/dynamic_extension_tests.cpp
@@ -20,7 +20,7 @@
 #include <check.h>
 using namespace de;
 
-typedef DynamicExtension<WRec, WIRS<WrappedRecord<WRec>>, WIRSQuery<WrappedRecord<WRec>>> DE;
+typedef DynamicExtension<WRec, WIRS<WRec>, WIRSQuery<WRec>> DE;
 
 START_TEST(t_create)
 {
@@ -147,7 +147,9 @@ START_TEST(t_range_sample_memlevels)
     delete ext_wirs;
 }
 END_TEST
+*/
 
+/*
 START_TEST(t_range_sample_weighted)
 {
     auto ext_wirs = new DE(100, 2, 1);
@@ -186,23 +188,24 @@ START_TEST(t_range_sample_weighted)
             weight = 8;
         }
 
-        WRec r = {keys[i], (uint32_t) i, weight, 0};
+        WRec r = {keys[i], (uint32_t) i, weight};
         ext_wirs->insert(r);
     }
     size_t k = 1000;
     uint64_t lower_key = 0;
     uint64_t upper_key = 5;
 
-    WRec* buffer = new WRec[k]();
-    char *buffer1 = (char *) std::aligned_alloc(SECTOR_SIZE, PAGE_SIZE);
-    char *buffer2 = (char *) std::aligned_alloc(SECTOR_SIZE, PAGE_SIZE);
-
     size_t cnt[3] = {0};
     for (size_t i=0; i<1000; i++) {
-        ext_wirs->range_sample(buffer, lower_key, upper_key, k);
+        wirs_query_parms<WRec> p;
+        p.lower_bound = lower_key;
+        p.upper_bound = upper_key;
+        p.sample_size = k;
+
+        auto result = ext_wirs->query(&p);
 
         for (size_t j=0; j<k; j++) {
-            cnt[buffer[j].key - 1]++;
+            cnt[result[j].key - 1]++;
         }
     }
 
@@ -211,9 +214,6 @@ START_TEST(t_range_sample_weighted)
     ck_assert(roughly_equal(cnt[2] / 1000, (double) k/2.0, k, .05));
 
     delete ext_wirs;
-    delete[] buffer;
-    free(buffer1);
-    free(buffer2);
 }
 END_TEST
 */
@@ -242,7 +242,7 @@ START_TEST(t_tombstone_merging_01)
     size_t deletes = 0;
     size_t cnt=0;
     for (auto rec : records) {
-        WRec r = {rec.first, rec.second, 1, 0};
+        WRec r = {rec.first, rec.second, 1};
         ck_assert_int_eq(ext_wirs->insert(r), 1);
 
          if (gsl_rng_uniform(rng) < 0.05 && !to_delete.empty()) {
@@ -251,8 +251,7 @@ START_TEST(t_tombstone_merging_01)
 
             for (size_t i=0; i<del_vec.size(); i++) {
                 WRec dr = {del_vec[i].first, del_vec[i].second, 1};
-                dr.set_tombstone();
-                ext_wirs->insert(dr);
+                ext_wirs->erase(dr);
                 deletes++;
                 to_delete.erase(del_vec[i]);
                 deleted.insert(del_vec[i]);
@@ -300,8 +299,7 @@ DE *create_test_tree(size_t reccnt, size_t memlevel_cnt) {
             std::sample(to_delete.begin(), to_delete.end(), std::back_inserter(del_vec), 3, std::mt19937{std::random_device{}()});
 
             for (size_t i=0; i<del_vec.size(); i++) {
-                del_vec[i].set_tombstone();
-                ext_wirs->insert(del_vec[i]);
+                ext_wirs->erase(del_vec[i]);
                 deletes++;
                 to_delete.erase(del_vec[i]);
                 deleted.insert(del_vec[i]);
@@ -349,9 +347,7 @@ START_TEST(t_sorted_array)
 
             for (size_t i=0; i<del_vec.size(); i++) {
                 WRec dr = {del_vec[i].first, del_vec[i].second, 1};
-                dr.set_tombstone();
-
-                ext_wirs->insert(dr );
+                ext_wirs->erase(dr);
                 deletes++;
                 to_delete.erase(del_vec[i]);
                 deleted.insert(del_vec[i]);
@@ -368,7 +364,7 @@ START_TEST(t_sorted_array)
 
     uint64_t prev_key = 0;
     for (size_t i=0; i<flat->get_record_count(); i++) {
-        auto k = flat->get_record_at(i)->key;
+        auto k = flat->get_record_at(i)->rec.key;
         ck_assert_int_ge(k, prev_key);
         prev_key = k;
     }
diff --git a/tests/internal_level_tests.cpp b/tests/internal_level_tests.cpp
index 42c9044..1bbc458 100644
--- a/tests/internal_level_tests.cpp
+++ b/tests/internal_level_tests.cpp
@@ -21,12 +21,12 @@
 
 using namespace de;
 
-typedef InternalLevel<WrappedRecord<WRec>, WIRS<WrappedRecord<WRec>>, WIRSQuery<WrappedRecord<WRec>>> ILevel;
+typedef InternalLevel<WRec, WIRS<WRec>, WIRSQuery<WRec>> ILevel;
 
 START_TEST(t_memlevel_merge)
 {
-    auto tbl1 = create_test_mbuffer<WrappedWRec>(100);
-    auto tbl2 = create_test_mbuffer<WrappedWRec>(100);
+    auto tbl1 = create_test_mbuffer<WRec>(100);
+    auto tbl2 = create_test_mbuffer<WRec>(100);
 
     auto base_level = new ILevel(1, 1);
     base_level->append_buffer(tbl1);
@@ -50,8 +50,8 @@ START_TEST(t_memlevel_merge)
 
 
 ILevel *create_test_memlevel(size_t reccnt) {
-    auto tbl1 = create_test_mbuffer<WrappedWRec>(reccnt/2);
-    auto tbl2 = create_test_mbuffer<WrappedWRec>(reccnt/2);
+    auto tbl1 = create_test_mbuffer<WRec>(reccnt/2);
+    auto tbl2 = create_test_mbuffer<WRec>(reccnt/2);
 
     auto base_level = new ILevel(1, 2);
     base_level->append_buffer(tbl1); 
diff --git a/tests/mutable_buffer_tests.cpp b/tests/mutable_buffer_tests.cpp
index fc8b511..bb8e2c2 100644
--- a/tests/mutable_buffer_tests.cpp
+++ b/tests/mutable_buffer_tests.cpp
@@ -25,7 +25,7 @@ using namespace de;
 
 START_TEST(t_create)
 {
-    auto buffer = new MutableBuffer<WrappedRec>(100, true, 50);
+    auto buffer = new MutableBuffer<Rec>(100, true, 50);
 
     ck_assert_ptr_nonnull(buffer);
     ck_assert_int_eq(buffer->get_capacity(), 100);
@@ -42,12 +42,12 @@ END_TEST
 
 START_TEST(t_insert)
 {
-    auto buffer = new MutableBuffer<WrappedWRec>(100, true, 50);
+    auto buffer = new MutableBuffer<WRec>(100, true, 50);
 
     uint64_t key = 0;
     uint32_t val = 5;
 
-    WrappedWRec rec = {0, 5, 1};
+    WRec rec = {0, 5, 1};
 
     for (size_t i=0; i<99; i++) {
         ck_assert_int_eq(buffer->append(rec), 1);
@@ -77,11 +77,11 @@ END_TEST
 
 START_TEST(t_insert_tombstones)
 {
-    auto buffer = new MutableBuffer<WrappedRec>(100, true, 50);
+    auto buffer = new MutableBuffer<Rec>(100, true, 50);
 
     size_t ts_cnt = 0;
 
-    WrappedRec rec = {0, 5};
+    Rec rec = {0, 5};
 
     for (size_t i=0; i<99; i++) {
         bool ts = false;
@@ -90,9 +90,7 @@ START_TEST(t_insert_tombstones)
             ts=true;
         }
 
-        rec.set_tombstone(ts);
-
-        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->append(rec, ts), 1);
         ck_assert_int_eq(buffer->check_tombstone(rec), ts);
 
         rec.key++;
@@ -104,11 +102,9 @@ START_TEST(t_insert_tombstones)
     }
 
     // inserting one more tombstone should not be possible
-    rec.set_tombstone();
-    ck_assert_int_eq(buffer->append(rec), 0);
+    ck_assert_int_eq(buffer->append(rec, true), 0);
 
 
-    rec.set_tombstone(false);
     ck_assert_int_eq(buffer->append(rec), 1);
 
     rec.key++;
@@ -124,10 +120,10 @@ END_TEST
 
 START_TEST(t_truncate)
 {
-    auto buffer = new MutableBuffer<WrappedRec>(100, true, 100);
+    auto buffer = new MutableBuffer<Rec>(100, true, 100);
 
     size_t ts_cnt = 0;
-    WrappedRec rec = {0, 5};
+    Rec rec = {0, 5};
 
     for (size_t i=0; i<100; i++) {
         bool ts = false;
@@ -136,9 +132,7 @@ START_TEST(t_truncate)
             ts=true;
         }
 
-        rec.set_tombstone(ts);
-
-        ck_assert_int_eq(buffer->append(rec), 1);
+        ck_assert_int_eq(buffer->append(rec, ts), 1);
         ck_assert_int_eq(buffer->check_tombstone(rec), ts);
 
         rec.key++;
@@ -149,7 +143,6 @@ START_TEST(t_truncate)
     }
 
     ck_assert_int_eq(buffer->is_full(), 1);
-    rec.set_tombstone(false);
     ck_assert_int_eq(buffer->append(rec), 0);
 
     ck_assert_int_eq(buffer->truncate(), 1);
@@ -165,11 +158,11 @@ START_TEST(t_truncate)
 END_TEST
 
 
-START_TEST(t_sorted_output)
+START_TEST(t_get_data)
 {
     size_t cnt = 100;
 
-    auto buffer = new MutableBuffer<WrappedRec>(cnt, true, cnt/2);
+    auto buffer = new MutableBuffer<Rec>(cnt, true, cnt/2);
 
 
     std::vector<uint64_t> keys(cnt);
@@ -184,23 +177,22 @@ START_TEST(t_sorted_output)
 
     uint32_t val = 12345;
     for (size_t i=0; i<cnt-2; i++) {
-        buffer->append(WrappedRec {keys[i], val});
+        buffer->append(Rec {keys[i], val});
     }
 
-    WrappedRec r1 = {keys[cnt-2], val};
-    r1.set_tombstone();
-    buffer->append(r1);
+    Rec r1 = {keys[cnt-2], val};
+    buffer->append(r1, true);
 
-    WrappedRec r2 = {keys[cnt-1], val};
-    r2.set_tombstone();
-    buffer->append(r2);
+    Rec r2 = {keys[cnt-1], val};
+    buffer->append(r2, true);
 
 
     auto *sorted_records = buffer->get_data();
     std::sort(keys.begin(), keys.end());
+    std::sort(sorted_records, sorted_records + buffer->get_record_count(), std::less<Wrapped<Rec>>());
 
     for (size_t i=0; i<cnt; i++) {
-        ck_assert_int_eq(sorted_records[i].key, keys[i]);
+        ck_assert_int_eq(sorted_records[i].rec.key, keys[i]);
     }
 
     delete buffer;
@@ -208,7 +200,7 @@ START_TEST(t_sorted_output)
 END_TEST
 
 
-void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t start, size_t stop, MutableBuffer<WrappedRec> *buffer)
+void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t start, size_t stop, MutableBuffer<Rec> *buffer)
 {
     for (size_t i=start; i<stop; i++) {
         buffer->append({(*values)[i].first, (*values)[i].second});
@@ -220,11 +212,11 @@ void insert_records(std::vector<std::pair<uint64_t, uint32_t>> *values, size_t s
 START_TEST(t_multithreaded_insert)
 {
     size_t cnt = 10000;
-    auto buffer = new MutableBuffer<WrappedRec>(cnt, true, cnt/2);
+    auto buffer = new MutableBuffer<Rec>(cnt, true, cnt/2);
 
-    std::vector<WrappedRec> records(cnt);
+    std::vector<Rec> records(cnt);
     for (size_t i=0; i<cnt; i++) {
-        records[i] = WrappedRec {(uint64_t) rand(), (uint32_t) rand()};
+        records[i] = Rec {(uint64_t) rand(), (uint32_t) rand()};
     }
 
     // perform a t_multithreaded insertion
@@ -285,8 +277,8 @@ Suite *unit_testing()
     suite_add_tcase(unit, truncate);
 
 
-    TCase *sorted_out = tcase_create("de::MutableBuffer::sorted_output");
-    tcase_add_test(sorted_out, t_sorted_output);
+    TCase *sorted_out = tcase_create("de::MutableBuffer::get_data");
+    tcase_add_test(sorted_out, t_get_data);
 
     suite_add_tcase(unit, sorted_out);
 
diff --git a/tests/testing.h b/tests/testing.h
index 3ffafcd..cd0045a 100644
--- a/tests/testing.h
+++ b/tests/testing.h
@@ -22,8 +22,6 @@
 
 typedef de::WeightedRecord<uint64_t, uint32_t, uint64_t> WRec;
 typedef de::Record<uint64_t, uint32_t> Rec;
-typedef de::WrappedRecord<WRec> WrappedWRec;
-typedef de::WrappedRecord<Rec> WrappedRec;
 
 static bool initialize_test_file(std::string fname, size_t page_cnt)
 {
@@ -149,18 +147,16 @@ static de::MutableBuffer<R> *create_double_seq_mbuffer(size_t cnt, bool ts=false
         R rec;
         rec.key = i;
         rec.value = i;
-        if (ts) rec.set_tombstone();
 
-        buffer->append(rec);
+        buffer->append(rec, ts);
     }
 
     for (size_t i = 0; i < cnt / 2; i++) {
         R rec;
         rec.key = i;
         rec.value = i + 1;
-        if (ts) rec.set_tombstone();
 
-        buffer->append(rec);
+        buffer->append(rec, ts);
     }
 
     return buffer;
diff --git a/tests/wirs_tests.cpp b/tests/wirs_tests.cpp
index 3a80a9e..ba4b754 100644
--- a/tests/wirs_tests.cpp
+++ b/tests/wirs_tests.cpp
@@ -17,39 +17,39 @@
 
 using namespace de;
 
-typedef WIRS<WrappedWRec> Shard;
+typedef WIRS<WRec> Shard;
 
 START_TEST(t_mbuffer_init)
 {
-    auto mem_table = new MutableBuffer<WrappedWRec>(1024, true, 1024);
+    auto buffer = new MutableBuffer<WRec>(1024, true, 1024);
     for (uint64_t i = 512; i > 0; i--) {
         uint32_t v = i;
-        mem_table->append({i,v, 1});
+        buffer->append({i,v, 1});
     }
     
     for (uint64_t i = 1; i <= 256; ++i) {
         uint32_t v = i;
-        mem_table->append({i, v, 1, 1});
+        buffer->append({i, v, 1}, true);
     }
 
     for (uint64_t i = 257; i <= 512; ++i) {
         uint32_t v = i + 1;
-        mem_table->append({i, v, 1});
+        buffer->append({i, v, 1});
     }
 
-    Shard* shard = new Shard(mem_table);
+    Shard* shard = new Shard(buffer);
     ck_assert_uint_eq(shard->get_record_count(), 512);
 
-    delete mem_table;
+    delete buffer;
     delete shard;
 }
 
 START_TEST(t_wirs_init)
 {
     size_t n = 512;
-    auto mbuffer1 = create_test_mbuffer<WrappedWRec>(n);
-    auto mbuffer2 = create_test_mbuffer<WrappedWRec>(n);
-    auto mbuffer3 = create_test_mbuffer<WrappedWRec>(n);
+    auto mbuffer1 = create_test_mbuffer<WRec>(n);
+    auto mbuffer2 = create_test_mbuffer<WRec>(n);
+    auto mbuffer3 = create_test_mbuffer<WRec>(n);
 
     auto shard1 = new Shard(mbuffer1);
     auto shard2 = new Shard(mbuffer2);
@@ -73,11 +73,11 @@ START_TEST(t_wirs_init)
 
         auto cur_rec = shard4->get_record_at(i);
 
-        if (shard1_idx < n && *cur_rec == *rec1) {
+        if (shard1_idx < n && cur_rec->rec == rec1->rec) {
             ++shard1_idx;
-        } else if (shard2_idx < n && *cur_rec == *rec2) {
+        } else if (shard2_idx < n && cur_rec->rec == rec2->rec) {
             ++shard2_idx;
-        } else if (shard3_idx < n && *cur_rec == *rec3) {
+        } else if (shard3_idx < n && cur_rec->rec == rec3->rec) {
             ++shard3_idx;
         } else {
            assert(false);
@@ -123,8 +123,8 @@ START_TEST(t_get_lower_bound_index)
 START_TEST(t_full_cancelation)
 {
     size_t n = 100;
-    auto buffer = create_double_seq_mbuffer<WrappedWRec>(n, false);
-    auto buffer_ts = create_double_seq_mbuffer<WrappedWRec>(n, true);
+    auto buffer = create_double_seq_mbuffer<WRec>(n, false);
+    auto buffer_ts = create_double_seq_mbuffer<WRec>(n, true);
 
     Shard* shard = new Shard(buffer);
     Shard* shard_ts = new Shard(buffer_ts);