Refactoring progress

4 files changed, 110 insertions, 106 deletions

diff --git a/tests/wss_tests.cpp b/tests/alias_tests.cpp
index cdc8001..b9e678b 100644
--- a/tests/wss_tests.cpp
+++ b/tests/alias_tests.cpp
@@ -1,7 +1,7 @@
 /*
- * tests/wss_tests.cpp
+ * tests/alias_tests.cpp
  *
- * Unit tests for WSS (Augmented B+Tree) shard
+ * Unit tests for Alias shard
  *
  * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
  *                    Dong Xie <dongx@psu.edu>
@@ -10,14 +10,15 @@
  *
  */
 
-#include "shard/WSS.h"
+#include "shard/Alias.h"
+#include "query/wss.h"
 #include "testing.h"
 
 #include <check.h>
 
 using namespace de;
 
-typedef WSS<WRec> Shard;
+typedef Alias<WRec> Shard;
 
 START_TEST(t_mbuffer_init)
 {
@@ -45,7 +46,7 @@ START_TEST(t_mbuffer_init)
 }
 
 
-START_TEST(t_wss_init)
+START_TEST(t_alias_init)
 {
     size_t n = 512;
     auto mbuffer1 = create_test_mbuffer<WRec>(n);
@@ -101,7 +102,7 @@ START_TEST(t_point_lookup)
     size_t n = 10000;
 
     auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto wss = Shard(buffer);
+    auto alias = Shard(buffer);
 
     for (size_t i=0; i<n; i++) {
         WRec r;
@@ -109,7 +110,7 @@ START_TEST(t_point_lookup)
         r.key = rec->rec.key;
         r.value = rec->rec.value;
 
-        auto result = wss.point_lookup(r);
+        auto result = alias.point_lookup(r);
         ck_assert_ptr_nonnull(result);
         ck_assert_int_eq(result->rec.key, r.key);
         ck_assert_int_eq(result->rec.value, r.value);
@@ -125,14 +126,14 @@ START_TEST(t_point_lookup_miss)
     size_t n = 10000;
 
     auto buffer = create_double_seq_mbuffer<WRec>(n, false);
-    auto wss = Shard(buffer);
+    auto alias = Shard(buffer);
 
     for (size_t i=n + 100; i<2*n; i++) {
         WRec r;
         r.key = i;
         r.value = i;
 
-        auto result = wss.point_lookup(r);
+        auto result = alias.point_lookup(r);
         ck_assert_ptr_null(result);
     }
 
@@ -169,7 +170,7 @@ START_TEST(t_full_cancelation)
 END_TEST
 
 
-START_TEST(t_wss_query)
+START_TEST(t_alias_query)
 {
     size_t n=1000;
     auto buffer = create_weighted_mbuffer<WRec>(n);
@@ -179,15 +180,15 @@ START_TEST(t_wss_query)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
+    wss:Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = WSSQuery<WRec>::get_query_state(shard, &parms);
-        ((WSSState<WRec> *) state)->sample_size = k;
-        auto result = WSSQuery<WRec>::query(shard, state, &parms);
+        auto state = wss::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wss::State<WRec> *) state)->sample_size = k;
+        auto result = wss::Query<Shard, WRec>::query(shard, state, &parms);
 
         total_samples += result.size();
 
@@ -195,7 +196,7 @@ START_TEST(t_wss_query)
             cnt[result[j].rec.key - 1]++;
         }
 
-        WSSQuery<WRec>::delete_query_state(state);
+        wss::Query<Shard, WRec>::delete_query_state(state);
     }
 
     ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
@@ -209,7 +210,7 @@ START_TEST(t_wss_query)
 END_TEST
 
 
-START_TEST(t_wss_query_merge)
+START_TEST(t_alias_query_merge)
 {
     size_t n=1000;
     auto buffer = create_weighted_mbuffer<WRec>(n);
@@ -222,25 +223,25 @@ START_TEST(t_wss_query_merge)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
+    wss:Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     std::vector<std::vector<Wrapped<WRec>>> results(2);
 
     for (size_t i=0; i<1000; i++) {
-        auto state1 = WSSQuery<WRec>::get_query_state(shard, &parms);
-        ((WSSState<WRec> *) state1)->sample_size = k;
-        results[0] = WSSQuery<WRec>::query(shard, state1, &parms);
+        auto state1 = wss::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wss::State<WRec> *) state1)->sample_size = k;
+        results[0] = wss::Query<Shard, WRec>::query(shard, state1, &parms);
 
-        auto state2 = WSSQuery<WRec>::get_query_state(shard, &parms);
-        ((WSSState<WRec> *) state2)->sample_size = k;
-        results[1] = WSSQuery<WRec>::query(shard, state2, &parms);
+        auto state2 = wss::Query<Shard, WRec>::get_query_state(shard, &parms);
+        ((wss::State<WRec> *) state2)->sample_size = k;
+        results[1] = wss::Query<Shard, WRec>::query(shard, state2, &parms);
 
-        WSSQuery<WRec>::delete_query_state(state1);
-        WSSQuery<WRec>::delete_query_state(state2);
+        wss::Query<Shard, WRec>::delete_query_state(state1);
+        wss::Query<Shard, WRec>::delete_query_state(state2);
     }
 
-    auto merged = WSSQuery<WRec>::merge(results, nullptr);
+    auto merged = wss::Query<Shard, WRec>::merge(results, nullptr);
 
     ck_assert_int_eq(merged.size(), 2*k);
     for (size_t i=0; i<merged.size(); i++) {
@@ -255,7 +256,7 @@ START_TEST(t_wss_query_merge)
 END_TEST
 
 
-START_TEST(t_wss_buffer_query_scan)
+START_TEST(t_alias_buffer_query_scan)
 {
     size_t n=1000;
     auto buffer = create_weighted_mbuffer<WRec>(n);
@@ -266,22 +267,22 @@ START_TEST(t_wss_buffer_query_scan)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
+    wss:Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = WSSQuery<WRec, false>::get_buffer_query_state(buffer, &parms);
-        ((WSSBufferState<WRec> *) state)->sample_size = k;
-        auto result = WSSQuery<WRec, false>::buffer_query(buffer, state, &parms);
+        auto state = wss::Query<Shard, WRec, false>::get_buffer_query_state(buffer, &parms);
+        ((wss::BufferState<WRec> *) state)->sample_size = k;
+        auto result = wss::Query<Shard, WRec, false>::buffer_query(buffer, state, &parms);
         total_samples += result.size();
 
         for (size_t j=0; j<result.size(); j++) {
             cnt[result[j].rec.key - 1]++;
         }
 
-        WSSQuery<WRec, false>::delete_buffer_query_state(state);
+        wss::Query<Shard, WRec, false>::delete_buffer_query_state(state);
     }
 
     ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .05));
@@ -294,7 +295,7 @@ START_TEST(t_wss_buffer_query_scan)
 END_TEST
 
 
-START_TEST(t_wss_buffer_query_rejection)
+START_TEST(t_alias_buffer_query_rejection)
 {
     size_t n=1000;
     auto buffer = create_weighted_mbuffer<WRec>(n);
@@ -305,15 +306,15 @@ START_TEST(t_wss_buffer_query_rejection)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    wss_query_parms<WRec> parms = {k};
+    wss:Parms<WRec> parms = {k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = WSSQuery<WRec>::get_buffer_query_state(buffer, &parms);
-        ((WSSBufferState<WRec> *) state)->sample_size = k;
-        auto result = WSSQuery<WRec>::buffer_query(buffer, state, &parms);
+        auto state = wss::Query<Shard, WRec>::get_buffer_query_state(buffer, &parms);
+        ((wss::BufferState<WRec> *) state)->sample_size = k;
+        auto result = wss::Query<Shard, WRec>::buffer_query(buffer, state, &parms);
 
         total_samples += result.size();
 
@@ -321,7 +322,7 @@ START_TEST(t_wss_buffer_query_rejection)
             cnt[result[j].rec.key - 1]++;
         }
 
-        WSSQuery<WRec>::delete_buffer_query_state(state);
+        wss::Query<Shard, WRec>::delete_buffer_query_state(state);
     }
 
     ck_assert(roughly_equal(cnt[0], (double) total_samples/4.0, total_samples, .1));
@@ -336,32 +337,32 @@ END_TEST
 
 Suite *unit_testing()
 {
-    Suite *unit = suite_create("WSS Shard Unit Testing");
+    Suite *unit = suite_create("Alias Shard Unit Testing");
 
-    TCase *create = tcase_create("de::WSS constructor Testing");
+    TCase *create = tcase_create("de::Alias constructor Testing");
     tcase_add_test(create, t_mbuffer_init);
-    tcase_add_test(create, t_wss_init);
+    tcase_add_test(create, t_alias_init);
     tcase_set_timeout(create, 100);
     suite_add_tcase(unit, create);
 
 
-    TCase *tombstone = tcase_create("de:WSS::tombstone cancellation Testing");
+    TCase *tombstone = tcase_create("de:Alias::tombstone cancellation Testing");
     tcase_add_test(tombstone, t_full_cancelation);
     suite_add_tcase(unit, tombstone);
 
 
-    TCase *lookup = tcase_create("de:WSS:point_lookup Testing");
+    TCase *lookup = tcase_create("de:Alias:point_lookup Testing");
     tcase_add_test(lookup, t_point_lookup);
     tcase_add_test(lookup, t_point_lookup_miss);
     suite_add_tcase(unit, lookup);
 
 
 
-    TCase *sampling = tcase_create("de:WSS::WSSQuery Testing");
-    tcase_add_test(sampling, t_wss_query);
-    tcase_add_test(sampling, t_wss_query_merge);
-    tcase_add_test(sampling, t_wss_buffer_query_rejection);
-    tcase_add_test(sampling, t_wss_buffer_query_scan);
+    TCase *sampling = tcase_create("de:Alias::AliasQuery Testing");
+    tcase_add_test(sampling, t_alias_query);
+    tcase_add_test(sampling, t_alias_query_merge);
+    tcase_add_test(sampling, t_alias_buffer_query_rejection);
+    tcase_add_test(sampling, t_alias_buffer_query_scan);
     suite_add_tcase(unit, sampling);
 
     return unit;
diff --git a/tests/memisam_tests.cpp b/tests/memisam_tests.cpp
index 0ae97dc..d3b8087 100644
--- a/tests/memisam_tests.cpp
+++ b/tests/memisam_tests.cpp
@@ -1,7 +1,7 @@
 /*
- * tests/irs_tests.cpp
+ * tests/isam_tests.cpp
  *
- * Unit tests for MemISAM (Augmented B+Tree) shard
+ * Unit tests for ISAM Tree shard
  *
  * Copyright (C) 2023 Douglas Rumbaugh <drumbaugh@psu.edu> 
  *                    Dong Xie <dongx@psu.edu>
@@ -10,14 +10,15 @@
  *
  */
 
-#include "shard/MemISAM.h"
+#include "shard/ISAMTree.h"
+#include "query/irs.h"
 #include "testing.h"
 
 #include <check.h>
 
 using namespace de;
 
-typedef MemISAM<Rec> Shard;
+typedef ISAMTree<Rec> Shard;
 
 START_TEST(t_mbuffer_init)
 {
@@ -181,15 +182,15 @@ START_TEST(t_irs_query)
     size_t k = 100;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = IRSQuery<Rec, false>::get_query_state(&isam, &parms);
-        ((IRSState<WRec> *) state)->sample_size = k;
-        auto result = IRSQuery<Rec, false>::query(&isam, state, &parms);
+        auto state = irs::Query<Shard, Rec, false>::get_query_state(&isam, &parms);
+        ((irs::State<WRec> *) state)->sample_size = k;
+        auto result = irs::Query<Shard, Rec, false>::query(&isam, state, &parms);
 
         ck_assert_int_eq(result.size(), k);
 
@@ -198,7 +199,7 @@ START_TEST(t_irs_query)
             ck_assert_int_ge(rec.rec.key, lower_key);
         }
 
-        IRSQuery<Rec, false>::delete_query_state(state);
+        irs::Query<Shard, Rec, false>::delete_query_state(state);
     }
 
     gsl_rng_free(parms.rng);
@@ -220,25 +221,25 @@ START_TEST(t_irs_query_merge)
     size_t k = 1000;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     std::vector<std::vector<de::Wrapped<Rec>>> results(2);
 
     for (size_t i=0; i<1000; i++) {
-        auto state1 = IRSQuery<Rec>::get_query_state(&shard, &parms);
-        ((IRSState<WRec> *) state1)->sample_size = k;
-        results[0] = IRSQuery<Rec>::query(&shard, state1, &parms);
+        auto state1 = irs::Query<Shard, Rec>::get_query_state(&shard, &parms);
+        ((irs::State<WRec> *) state1)->sample_size = k;
+        results[0] = irs::Query<Shard, Rec>::query(&shard, state1, &parms);
 
-        auto state2 = IRSQuery<Rec>::get_query_state(&shard, &parms);
-        ((IRSState<WRec> *) state2)->sample_size = k;
-        results[1] = IRSQuery<Rec>::query(&shard, state2, &parms);
+        auto state2 = irs::Query<Shard, Rec>::get_query_state(&shard, &parms);
+        ((irs::State<WRec> *) state2)->sample_size = k;
+        results[1] = irs::Query<Shard, Rec>::query(&shard, state2, &parms);
 
-        IRSQuery<Rec>::delete_query_state(state1);
-        IRSQuery<Rec>::delete_query_state(state2);
+        irs::Query<Shard, Rec>::delete_query_state(state1);
+        irs::Query<Shard, Rec>::delete_query_state(state2);
     }
 
-    auto merged = IRSQuery<Rec>::merge(results, nullptr);
+    auto merged = irs::Query<Shard, Rec>::merge(results, nullptr);
 
     ck_assert_int_eq(merged.size(), 2*k);
     for (size_t i=0; i<merged.size(); i++) {
@@ -263,15 +264,15 @@ START_TEST(t_irs_buffer_query_scan)
     size_t k = 100;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = IRSQuery<Rec, false>::get_buffer_query_state(buffer, &parms);
-        ((IRSBufferState<WRec> *) state)->sample_size = k;
-        auto result = IRSQuery<Rec, false>::buffer_query(buffer, state, &parms);
+        auto state = irs::Query<Shard, Rec, false>::get_buffer_query_state(buffer, &parms);
+        ((irs::BufferState<WRec> *) state)->sample_size = k;
+        auto result = irs::Query<Shard, Rec, false>::buffer_query(buffer, state, &parms);
 
         ck_assert_int_eq(result.size(), k);
 
@@ -280,7 +281,7 @@ START_TEST(t_irs_buffer_query_scan)
             ck_assert_int_ge(rec.rec.key, lower_key);
         }
 
-        IRSQuery<Rec, false>::delete_buffer_query_state(state);
+        irs::Query<Shard, Rec, false>::delete_buffer_query_state(state);
     }
 
     gsl_rng_free(parms.rng);
@@ -300,15 +301,15 @@ START_TEST(t_irs_buffer_query_rejection)
     size_t k = 10000;
 
     size_t cnt[3] = {0};
-    irs_query_parms<Rec> parms = {lower_key, upper_key, k};
+    irs::Parms<Rec> parms = {lower_key, upper_key, k};
     parms.rng = gsl_rng_alloc(gsl_rng_mt19937);
 
     size_t total_samples = 0;
 
     for (size_t i=0; i<1000; i++) {
-        auto state = IRSQuery<Rec>::get_buffer_query_state(buffer, &parms);
-        ((IRSBufferState<WRec> *) state)->sample_size = k;
-        auto result = IRSQuery<Rec>::buffer_query(buffer, state, &parms);
+        auto state = irs::Query<Shard, Rec>::get_buffer_query_state(buffer, &parms);
+        ((irs::BufferState<WRec> *) state)->sample_size = k;
+        auto result = irs::Query<Shard, Rec>::buffer_query(buffer, state, &parms);
 
         ck_assert_int_gt(result.size(), 0);
         ck_assert_int_le(result.size(), k);
@@ -318,7 +319,7 @@ START_TEST(t_irs_buffer_query_rejection)
             ck_assert_int_ge(rec.rec.key, lower_key);
         }
 
-        IRSQuery<Rec>::delete_buffer_query_state(state);
+        irs::Query<Shard, Rec>::delete_buffer_query_state(state);
     }
 
     gsl_rng_free(parms.rng);
@@ -329,27 +330,27 @@ END_TEST
 
 Suite *unit_testing()
 {
-    Suite *unit = suite_create("MemISAM Shard Unit Testing");
+    Suite *unit = suite_create("ISAMTree Shard Unit Testing");
 
-    TCase *create = tcase_create("de::MemISAM constructor Testing");
+    TCase *create = tcase_create("de::ISAMTree constructor Testing");
     tcase_add_test(create, t_mbuffer_init);
     tcase_add_test(create, t_irs_init);
     tcase_set_timeout(create, 100);
     suite_add_tcase(unit, create);
 
 
-    TCase *tombstone = tcase_create("de:MemISAM::tombstone cancellation Testing");
+    TCase *tombstone = tcase_create("de:ISAMTree::tombstone cancellation Testing");
     tcase_add_test(tombstone, t_full_cancelation);
     suite_add_tcase(unit, tombstone);
 
 
-    TCase *lookup = tcase_create("de:MemISAM:point_lookup Testing");
+    TCase *lookup = tcase_create("de:ISAMTree:point_lookup Testing");
     tcase_add_test(lookup, t_point_lookup);
     tcase_add_test(lookup, t_point_lookup_miss);
     suite_add_tcase(unit, lookup);
 
 
-    TCase *sampling = tcase_create("de:MemISAM::MemISAMQuery Testing");
+    TCase *sampling = tcase_create("de:ISAMTree::ISAMTreeQuery Testing");
     tcase_add_test(sampling, t_irs_query);
     tcase_add_test(sampling, t_irs_query_merge);
     tcase_add_test(sampling, t_irs_buffer_query_rejection);
diff --git a/tests/pgm_tests.cpp b/tests/pgm_tests.cpp
index 0552417..1565384 100644
--- a/tests/pgm_tests.cpp
+++ b/tests/pgm_tests.cpp
@@ -11,6 +11,7 @@
  */
 
 #include "shard/PGM.h"
+#include "query/rangequery.h"
 #include "testing.h"
 
 #include <check.h>
@@ -144,13 +145,13 @@ START_TEST(t_range_query)
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
     auto shard = Shard(buffer);
 
-    pgm_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = PGMRangeQuery<Rec>::get_query_state(&shard, &parms);
-    auto result = PGMRangeQuery<Rec>::query(&shard, state, &parms);
-    PGMRangeQuery<Rec>::delete_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_query_state(&shard, &parms);
+    auto result = rq::Query<Shard, Rec>::query(&shard, state, &parms);
+    rq::Query<Shard, Rec>::delete_query_state(state);
 
     ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
     for (size_t i=0; i<result.size(); i++) {
@@ -167,13 +168,13 @@ START_TEST(t_buffer_range_query)
 {
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
 
-    pgm_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = PGMRangeQuery<Rec>::get_buffer_query_state(buffer, &parms);
-    auto result = PGMRangeQuery<Rec>::buffer_query(buffer, state, &parms);
-    PGMRangeQuery<Rec>::delete_buffer_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_buffer_query_state(buffer, &parms);
+    auto result = rq::Query<Shard, Rec>::buffer_query(buffer, state, &parms);
+    rq::Query<Shard, Rec>::delete_buffer_query_state(state);
 
     ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
     for (size_t i=0; i<result.size(); i++) {
@@ -194,21 +195,21 @@ START_TEST(t_range_query_merge)
     auto shard1 = Shard(buffer1);
     auto shard2 = Shard(buffer2);
 
-    pgm_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 150;
     parms.upper_bound = 500;
 
     size_t result_size = parms.upper_bound - parms.lower_bound + 1 - 200;
 
-    auto state1 = PGMRangeQuery<Rec>::get_query_state(&shard1, &parms);
-    auto state2 = PGMRangeQuery<Rec>::get_query_state(&shard2, &parms);
+    auto state1 = rq::Query<Shard, Rec>::get_query_state(&shard1, &parms);
+    auto state2 = rq::Query<Shard, Rec>::get_query_state(&shard2, &parms);
 
     std::vector<std::vector<de::Wrapped<Rec>>> results(2);
-    results[0] = PGMRangeQuery<Rec>::query(&shard1, state1, &parms);
-    results[1] = PGMRangeQuery<Rec>::query(&shard2, state2, &parms);
+    results[0] = rq::Query<Shard, Rec>::query(&shard1, state1, &parms);
+    results[1] = rq::Query<Shard, Rec>::query(&shard2, state2, &parms);
 
-    PGMRangeQuery<Rec>::delete_query_state(state1);
-    PGMRangeQuery<Rec>::delete_query_state(state2);
+    rq::Query<Shard, Rec>::delete_query_state(state1);
+    rq::Query<Shard, Rec>::delete_query_state(state2);
 
     ck_assert_int_eq(results[0].size() + results[1].size(), result_size);
 
@@ -221,7 +222,7 @@ START_TEST(t_range_query_merge)
         }
     }
 
-    auto result = PGMRangeQuery<Rec>::merge(proc_results, nullptr);
+    auto result = rq::Query<Shard, Rec>::merge(proc_results, nullptr);
     std::sort(result.begin(), result.end());
 
     ck_assert_int_eq(result.size(), result_size);
diff --git a/tests/triespline_tests.cpp b/tests/triespline_tests.cpp
index 6f63961..101f143 100644
--- a/tests/triespline_tests.cpp
+++ b/tests/triespline_tests.cpp
@@ -13,6 +13,7 @@
 #include <functional>
 
 #include "shard/TrieSpline.h"
+#include "query/rangequery.h"
 #include "testing.h"
 
 #include <check.h>
@@ -176,13 +177,13 @@ START_TEST(t_range_query)
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
     auto shard = Shard(buffer);
 
-    ts_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = TrieSplineRangeQuery<Rec>::get_query_state(&shard, &parms);
-    auto result = TrieSplineRangeQuery<Rec>::query(&shard, state, &parms);
-    TrieSplineRangeQuery<Rec>::delete_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_query_state(&shard, &parms);
+    auto result = rq::Query<Shard, Rec>::query(&shard, state, &parms);
+    rq::Query<Shard, Rec>::delete_query_state(state);
 
     ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
     for (size_t i=0; i<result.size(); i++) {
@@ -199,13 +200,13 @@ START_TEST(t_buffer_range_query)
 {
     auto buffer = create_sequential_mbuffer<Rec>(100, 1000);
 
-    ts_range_query_parms<Rec> parms;
+    rq::Parms<Rec> parms;
     parms.lower_bound = 300;
     parms.upper_bound = 500;
 
-    auto state = TrieSplineRangeQuery<Rec>::get_buffer_query_state(buffer, &parms);
-    auto result = TrieSplineRangeQuery<Rec>::buffer_query(buffer, state, &parms);
-    TrieSplineRangeQuery<Rec>::delete_buffer_query_state(state);
+    auto state = rq::Query<Shard, Rec>::get_buffer_query_state(buffer, &parms);
+    auto result = rq::Query<Shard, Rec>::buffer_query(buffer, state, &parms);
+    rq::Query<Shard, Rec>::delete_buffer_query_state(state);
 
     ck_assert_int_eq(result.size(), parms.upper_bound - parms.lower_bound + 1);
     for (size_t i=0; i<result.size(); i++) {