mirrors/scylladb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
eb31ec00a22e93c0f8a2e89552c89d5aedcb3525
scylladb/tests/partitioner_test.cc
Asias He 2a794db61b tests: Add test_selective_token_range_sharder
2017-07-04 18:46:19 +08:00

1047 lines
46 KiB
C++
Raw Blame History

/*
* Copyright (C) 2015 ScyllaDB
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#define BOOST_TEST_MODULE core
#include <boost/test/unit_test.hpp>
#include <boost/algorithm/cxx11/all_of.hpp>
#include "dht/i_partitioner.hh"
#include "dht/murmur3_partitioner.hh"
#include "dht/byte_ordered_partitioner.hh"
#include "dht/random_partitioner.hh"
#include "schema.hh"
#include "types.hh"
#include "schema_builder.hh"
#include "utils/div_ceil.hh"
#include "repair/range_split.hh"
#include "disk-error-handler.hh"
#include "simple_schema.hh"
#include "total_order_check.hh"
thread_local disk_error_signal_type commit_error;
thread_local disk_error_signal_type general_disk_error;
template <typename... Args>
static
void
debug(Args&&... args) {
if (false) {
print(std::forward<Args>(args)...);
}
}
static dht::token token_from_long(uint64_t value) {
auto t = net::hton(value);
bytes b(bytes::initialized_later(), 8);
std::copy_n(reinterpret_cast<int8_t*>(&t), 8, b.begin());
return { dht::token::kind::key, std::move(b) };
}
static int64_t long_from_token(dht::token token) {
int64_t data;
std::copy_n(token._data.data(), 8, reinterpret_cast<char*>(&data));
return net::ntoh(data);
}
BOOST_AUTO_TEST_CASE(test_decorated_key_is_compatible_with_origin) {
auto s = schema_builder("ks", "cf")
.with_column("c1", int32_type, column_kind::partition_key)
.with_column("c2", int32_type, column_kind::partition_key)
.with_column("v", int32_type)
.build();
dht::murmur3_partitioner partitioner;
auto key = partition_key::from_deeply_exploded(*s, {143, 234});
auto dk = partitioner.decorate_key(*s, key);
// Expected value was taken from Origin
BOOST_REQUIRE_EQUAL(dk._token, token_from_long(4958784316840156970));
BOOST_REQUIRE(dk._key.equal(*s, key));
}
BOOST_AUTO_TEST_CASE(test_token_wraparound_1) {
auto t1 = token_from_long(0x7000'0000'0000'0000);
auto t2 = token_from_long(0xa000'0000'0000'0000);
dht::murmur3_partitioner partitioner;
BOOST_REQUIRE(t1 > t2);
// Even without knowing what the midpoint is, it needs to be inside the
// wrapped range, i.e., between t1 and inf, OR between -inf and t2
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 || midpoint < t2);
// We can also calculate the actual value the midpoint should have:
BOOST_REQUIRE_EQUAL(midpoint, token_from_long(0x8800'0000'0000'0000));
}
BOOST_AUTO_TEST_CASE(test_token_wraparound_2) {
auto t1 = token_from_long(0x6000'0000'0000'0000);
auto t2 = token_from_long(0x9000'0000'0000'0000);
dht::murmur3_partitioner partitioner;
BOOST_REQUIRE(t1 > t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 || midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, token_from_long(0x7800'0000'0000'0000));
}
BOOST_AUTO_TEST_CASE(test_ring_position_is_comparable_with_decorated_key) {
auto s = schema_builder("ks", "cf")
.with_column("pk", bytes_type, column_kind::partition_key)
.with_column("v", int32_type)
.build();
std::vector<dht::decorated_key> keys = {
dht::global_partitioner().decorate_key(*s,
partition_key::from_single_value(*s, "key1")),
dht::global_partitioner().decorate_key(*s,
partition_key::from_single_value(*s, "key2")),
};
std::sort(keys.begin(), keys.end(), dht::decorated_key::less_comparator(s));
auto& k1 = keys[0];
auto& k2 = keys[1];
BOOST_REQUIRE(k1._token != k2._token); // The rest of the test assumes that.
BOOST_REQUIRE(k1.tri_compare(*s, dht::ring_position::starting_at(k1._token)) > 0);
BOOST_REQUIRE(k1.tri_compare(*s, dht::ring_position::ending_at(k1._token)) < 0);
BOOST_REQUIRE(k1.tri_compare(*s, dht::ring_position(k1)) == 0);
BOOST_REQUIRE(k1.tri_compare(*s, dht::ring_position::starting_at(k2._token)) < 0);
BOOST_REQUIRE(k1.tri_compare(*s, dht::ring_position::ending_at(k2._token)) < 0);
BOOST_REQUIRE(k1.tri_compare(*s, dht::ring_position(k2)) < 0);
BOOST_REQUIRE(k2.tri_compare(*s, dht::ring_position::starting_at(k1._token)) > 0);
BOOST_REQUIRE(k2.tri_compare(*s, dht::ring_position::ending_at(k1._token)) > 0);
BOOST_REQUIRE(k2.tri_compare(*s, dht::ring_position(k1)) > 0);
}
BOOST_AUTO_TEST_CASE(test_ring_position_ordering) {
simple_schema table;
auto cmp = dht::ring_position_comparator(*table.schema());
std::vector<dht::decorated_key> keys = table.make_pkeys(6);
// Force keys[2-4] to share the same token
keys[2]._token = keys[3]._token = keys[4]._token;
std::sort(keys.begin() + 2, keys.begin() + 5, dht::ring_position_less_comparator(*table.schema()));
BOOST_TEST_MESSAGE(sprint("Keys: %s", keys));
auto positions = boost::copy_range<std::vector<dht::ring_position>>(keys);
auto views = boost::copy_range<std::vector<dht::ring_position_view>>(positions);
total_order_check<dht::ring_position_comparator, dht::ring_position, dht::ring_position_view, dht::decorated_key>(cmp)
.next(dht::ring_position_view::min())
.next(dht::ring_position(keys[0].token(), dht::ring_position::token_bound::start))
.equal_to(dht::ring_position_view(keys[0].token(), nullptr, -1))
.next(views[0])
.equal_to(keys[0])
.equal_to(positions[0])
.next(dht::ring_position_view::for_after_key(keys[0]))
.next(dht::ring_position(keys[0].token(), dht::ring_position::token_bound::end))
.equal_to(dht::ring_position_view(keys[0].token(), nullptr, 1))
.next(dht::ring_position(keys[1].token(), dht::ring_position::token_bound::start))
.equal_to(dht::ring_position_view(keys[1].token(), nullptr, -1))
.next(views[1])
.equal_to(keys[1])
.equal_to(positions[1])
.next(dht::ring_position_view::for_after_key(keys[1]))
.next(dht::ring_position(keys[1].token(), dht::ring_position::token_bound::end))
.equal_to(dht::ring_position_view(keys[1].token(), nullptr, 1))
.next(dht::ring_position(keys[2].token(), dht::ring_position::token_bound::start))
.equal_to(dht::ring_position_view(keys[2].token(), nullptr, -1))
.next(views[2])
.equal_to(keys[2])
.equal_to(positions[2])
.next(dht::ring_position_view::for_after_key(keys[2]))
.next(views[3])
.equal_to(keys[3])
.equal_to(positions[3])
.next(dht::ring_position_view::for_after_key(keys[3]))
.next(views[4])
.equal_to(keys[4])
.equal_to(positions[4])
.next(dht::ring_position_view::for_after_key(keys[4]))
.next(dht::ring_position(keys[4].token(), dht::ring_position::token_bound::end))
.equal_to(dht::ring_position_view(keys[4].token(), nullptr, 1))
.next(dht::ring_position(keys[5].token(), dht::ring_position::token_bound::start))
.equal_to(dht::ring_position_view(keys[5].token(), nullptr, -1))
.next(views[5])
.equal_to(keys[5])
.equal_to(positions[5])
.next(dht::ring_position_view::for_after_key(keys[5]))
.next(dht::ring_position(keys[5].token(), dht::ring_position::token_bound::end))
.equal_to(dht::ring_position_view(keys[5].token(), nullptr, 1))
.next(dht::ring_position_view::max())
.check();
}
BOOST_AUTO_TEST_CASE(test_token_no_wraparound_1) {
auto t1 = token_from_long(0x5000'0000'0000'0000);
auto t2 = token_from_long(0x7000'0000'0000'0000);
dht::murmur3_partitioner partitioner;
BOOST_REQUIRE(t1 < t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 && midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, token_from_long(0x6000'0000'0000'0000));
}
BOOST_AUTO_TEST_CASE(test_bop_token_nowraparound_1) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("03");
auto t2 = partitioner.from_sstring("09");
BOOST_REQUIRE(t1 < t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 && midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("06"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_nowraparound_2) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("20000000000000000000000000000003");
auto t2 = partitioner.from_sstring("A0000000000000000000000000000009");
BOOST_REQUIRE(t1 < t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 && midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("60000000000000000000000000000006"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_nowraparound_3) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("2000000000000000000000000000000320000000000000000000000000000003");
auto t2 = partitioner.from_sstring("A0000000000000000000000000000009A0000000000000000000000000000009");
BOOST_REQUIRE(t1 < t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 && midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("6000000000000000000000000000000660000000000000000000000000000006"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_nowraparound_4) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("");
auto t2 = partitioner.from_sstring("2000");
BOOST_REQUIRE(t1 < t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 && midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("1000"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_nowraparound_5) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("00");
auto t2 = partitioner.from_sstring("2000");
BOOST_REQUIRE(t1 < t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 && midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("1000"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_nowraparound_6) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring(sstring());
auto t2 = partitioner.from_sstring(sstring());
BOOST_REQUIRE(t1 <= t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint >= t1 && midpoint <= t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring(""));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_wraparound_1) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("00000000000000000000000000000009");
auto t2 = partitioner.from_sstring("00000000000000000000000000000003");
BOOST_REQUIRE(t1 > t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 || midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("80000000000000000000000000000006"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_wraparound_2) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("A0000000000000000000000000000009");
auto t2 = partitioner.from_sstring("20000000000000000000000000000003");
BOOST_REQUIRE(t1 > t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 || midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("E0000000000000000000000000000006"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_wraparound_3) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("A000000000000000000000000000000900000000000000000000000000000009");
auto t2 = partitioner.from_sstring("2000000000000000000000000000000300000000000000000000000000000003");
BOOST_REQUIRE(t1 > t2);
auto midpoint = partitioner.midpoint(t1, t2);
BOOST_REQUIRE(midpoint > t1 || midpoint < t2);
BOOST_REQUIRE_EQUAL(midpoint, partitioner.from_sstring("E000000000000000000000000000000600000000000000000000000000000006"));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_describe_ownership) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("10000000000000000000000000000000");
auto t2 = partitioner.from_sstring("30000000000000000000000000000000");
auto t3 = partitioner.from_sstring("A0000000000000000000000000000000");
auto t4 = partitioner.from_sstring("F0000000000000000000000000000000");
auto sorted_tokens = std::vector<dht::token>{t1, t2, t3, t4};
auto own_map = partitioner.describe_ownership(sorted_tokens);
BOOST_REQUIRE_EQUAL(own_map[t1], 0.1250);
BOOST_REQUIRE_EQUAL(own_map[t2], 0.1250);
BOOST_REQUIRE_EQUAL(own_map[t3], 0.4375);
BOOST_REQUIRE_EQUAL(own_map[t4], 0.3125);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_order) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("123456");
auto t2 = partitioner.from_sstring("12345678");
BOOST_REQUIRE(t1 < t2);
t1 = partitioner.from_sstring("22");
t2 = partitioner.from_sstring("12345678");
BOOST_REQUIRE(t1 > t2);
t1 = partitioner.from_sstring("123456");
t2 = partitioner.from_sstring("123457");
BOOST_REQUIRE(t1 < t2);
t1 = partitioner.from_sstring("123456");
t2 = partitioner.from_sstring("A23456");
BOOST_REQUIRE(t1 < t2);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_midpoint1) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("010000");
auto t2 = partitioner.from_sstring("20");
auto mid = partitioner.midpoint(t1, t2);
// The length of the midpoint token is supposed to be 3 bytes, filled with one zero byte
auto mid_expected = partitioner.from_sstring("008010");
BOOST_REQUIRE(t1 < t2);
BOOST_REQUIRE(mid_expected._data.size() == 3);
BOOST_REQUIRE(mid._data.size() == 3);
BOOST_REQUIRE(mid == mid_expected);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_midpoint2) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("020001");
auto t2 = partitioner.from_sstring("60");
auto mid = partitioner.midpoint(t1, t2);
// The length of the midpoint token is supposed to be 3 bytes, filled with one zero byte
auto mid_expected = partitioner.from_sstring("01003080");
BOOST_REQUIRE(t1 < t2);
BOOST_REQUIRE(mid == mid_expected);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_bop_token_midpoint3) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.ByteOrderedPartitioner"));
dht::byte_ordered_partitioner partitioner;
auto t1 = partitioner.from_sstring("20");
auto t2 = partitioner.from_sstring("81");
auto mid = partitioner.midpoint(t1, t2);
auto mid_expected = partitioner.from_sstring("5080");
BOOST_REQUIRE(t1 < t2);
BOOST_REQUIRE(mid == mid_expected);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_token1) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto str1 = sstring("123456");
auto t = partitioner.from_sstring(str1);
auto str2 = partitioner.to_sstring(t);
BOOST_REQUIRE(str1 == str2);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_token2) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto min = dht::minimum_token();
auto t1 = partitioner.from_sstring(sstring());
auto t2 = partitioner.from_sstring(to_sstring("0"));
BOOST_REQUIRE(min == t1);
BOOST_REQUIRE(min == t2);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_token3) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto t1 = partitioner.from_sstring(to_sstring("255"));
auto bytes1 = partitioner.token_to_bytes(t1);
// Zero byte is prepended, 255 needs one byte, bit 7 is set
BOOST_REQUIRE(bytes1.size() == 2);
BOOST_REQUIRE(bytes1[0] == int8_t(0));
BOOST_REQUIRE(bytes1[1] == int8_t(255));
auto t2 = partitioner.from_sstring(to_sstring("250"));
auto bytes2 = partitioner.token_to_bytes(t2);
// Zero byte is prepended, 250 needs one byte, bit 7 is set
BOOST_REQUIRE(bytes2.size() == 2);
BOOST_REQUIRE(bytes2[0] == int8_t(0));
BOOST_REQUIRE(bytes2[1] == int8_t(250));
auto t3 = partitioner.from_sstring(to_sstring("256"));
auto bytes3 = partitioner.token_to_bytes(t3);
// Zero byte is not prepended, 256 needs two bytes, bit 15 is not set
BOOST_REQUIRE(bytes3.size() == 2);
BOOST_REQUIRE(bytes3[0] == int8_t(1));
BOOST_REQUIRE(bytes3[1] == int8_t(0));
auto t4 = partitioner.from_sstring(to_sstring("127"));
auto bytes4 = partitioner.token_to_bytes(t4);
// Zero byte is not prepended, 127 needs one byte, bit 7 is not set
BOOST_REQUIRE(bytes4.size() == 1);
BOOST_REQUIRE(bytes4[0] == int8_t(127));
auto t5 = partitioner.from_sstring(to_sstring("128"));
auto bytes5 = partitioner.token_to_bytes(t5);
// Zero byte is prepended, 128 needs one byte, bit 7 is set
BOOST_REQUIRE(bytes5.size() == 2);
BOOST_REQUIRE(bytes5[0] == int8_t(0));
BOOST_REQUIRE(bytes5[1] == int8_t(128));
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_token4) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto s = schema_builder("ks", "cf").with_column("a", bytes_type, column_kind::partition_key)
.with_column("b", int32_type) .build();
auto t1 = partitioner.from_sstring("1498727546111218218000240550937185703"); // g1
auto t2 = partitioner.from_sstring("5743128803285680324364720388504740393"); // z
auto t3 = partitioner.from_sstring("24285907100581385209761791172262166336"); // b1
auto t4 = partitioner.from_sstring("74278675443652264562362882013958732244"); // 2
auto t5 = partitioner.from_sstring("78703492656118554854272571946195123045"); // 1
auto t6 = partitioner.from_sstring("114355602889666587562799073732149921607"); // c1
auto t7 = partitioner.from_sstring("114688863869225338471480367428049914939"); // 1000
auto t8 = partitioner.from_sstring("156123446300388841848425604775226615902"); // a1
auto t1_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("g1"))));
auto t2_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("z"))));
auto t3_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("b1"))));
auto t4_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("2"))));
auto t5_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("1"))));
auto t6_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("c1"))));
auto t7_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("1000"))));
auto t8_ = partitioner.get_token(*s, partition_key::from_single_value(*s, to_bytes(sstring("a1"))));
BOOST_REQUIRE(t1 == t1_);
BOOST_REQUIRE(t2 == t2_);
BOOST_REQUIRE(t3 == t3_);
BOOST_REQUIRE(t4 == t4_);
BOOST_REQUIRE(t5 == t5_);
BOOST_REQUIRE(t6 == t6_);
BOOST_REQUIRE(t7 == t7_);
BOOST_REQUIRE(t8 == t8_);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_token_midpoint1) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto t1 = partitioner.from_sstring("1000");
auto t2 = partitioner.from_sstring("5000");
auto mid = partitioner.midpoint(t1, t2);
auto mid_expected = partitioner.from_sstring("3000");
BOOST_REQUIRE(t1 < t2);
BOOST_REQUIRE(mid == mid_expected);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_token_midpoint2) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto t1 = partitioner.from_sstring("5000");
auto t2 = partitioner.from_sstring("1000");
auto mid = partitioner.midpoint(t1, t2);
auto mid_expected = partitioner.from_sstring("85070591730234615865843651857942055864");
BOOST_REQUIRE(t1 > t2);
BOOST_REQUIRE(mid == mid_expected);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
BOOST_AUTO_TEST_CASE(test_rp_describe_ownership) {
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.RandomPartitioner"));
dht::random_partitioner partitioner;
auto t1 = partitioner.from_sstring("34028236692093846346337460743176821144");
auto t2 = partitioner.from_sstring("51042355038140769519506191114765231716");
auto t3 = partitioner.from_sstring("85070591730234615865843651857942052860");
auto t4 = partitioner.from_sstring("153127065114422308558518573344295695148");
auto sorted_tokens = std::vector<dht::token>{t1, t2, t3, t4};
auto own_map = partitioner.describe_ownership(sorted_tokens);
BOOST_REQUIRE(std::fabs(own_map[t1] - 0.3) <= FLT_EPSILON);
BOOST_REQUIRE(std::fabs(own_map[t2] - 0.1) <= FLT_EPSILON);
BOOST_REQUIRE(std::fabs(own_map[t3] - 0.2) <= FLT_EPSILON);
BOOST_REQUIRE(std::fabs(own_map[t4] - 0.4) <= FLT_EPSILON);
dht::set_global_partitioner(to_sstring("org.apache.cassandra.dht.Murmur3Partitioner"));
}
void test_partitioner_sharding(const dht::i_partitioner& part, unsigned shards, std::vector<dht::token> shard_limits,
std::function<dht::token (const dht::i_partitioner&, dht::token)> prev_token, unsigned ignorebits = 0) {
auto s = schema_builder("ks", "cf")
.with_column("c1", int32_type, column_kind::partition_key)
.with_column("c2", int32_type, column_kind::partition_key)
.with_column("v", int32_type)
.build();
for (unsigned i = 0; i < (shards << ignorebits); ++i) {
auto lim = shard_limits[i];
BOOST_REQUIRE_EQUAL(part.shard_of(lim), i % shards);
if (i != 0) {
BOOST_REQUIRE_EQUAL(part.shard_of(prev_token(part, lim)), (i - 1) % shards);
BOOST_REQUIRE(part.is_equal(lim, part.token_for_next_shard(prev_token(part, lim), i % shards)));
}
if (i != (shards << ignorebits) - 1) {
auto next_shard = (i + 1) % shards;
BOOST_REQUIRE_EQUAL(part.shard_of(part.token_for_next_shard(lim, next_shard)), next_shard);
}
}
}
BOOST_AUTO_TEST_CASE(test_murmur3_sharding) {
auto prev_token = [] (const dht::i_partitioner&, dht::token token) {
return token_from_long(long_from_token(token) - 1);
};
auto make_token_vector = [] (std::vector<int64_t> v) {
return boost::copy_range<std::vector<dht::token>>(
v | boost::adaptors::transformed(token_from_long));
};
dht::murmur3_partitioner mm3p7s(7);
auto mm3p7s_shard_limits = make_token_vector({
-9223372036854775807, -6588122883467697006+1, -3952873730080618204+1,
-1317624576693539402+1, 1317624576693539401+1, 3952873730080618203+1,
6588122883467697005+1,
});
test_partitioner_sharding(mm3p7s, 7, mm3p7s_shard_limits, prev_token);
dht::murmur3_partitioner mm3p2s(2);
auto mm3p2s_shard_limits = make_token_vector({
-9223372036854775807, 0,
});
test_partitioner_sharding(mm3p2s, 2, mm3p2s_shard_limits, prev_token);
dht::murmur3_partitioner mm3p1s(1);
auto mm3p1s_shard_limits = make_token_vector({
-9223372036854775807,
});
test_partitioner_sharding(mm3p1s, 1, mm3p1s_shard_limits, prev_token);
}
BOOST_AUTO_TEST_CASE(test_murmur3_sharding_with_ignorebits) {
auto prev_token = [] (const dht::i_partitioner&, dht::token token) {
return token_from_long(long_from_token(token) - 1);
};
auto make_token_vector = [] (std::vector<int64_t> v) {
return boost::copy_range<std::vector<dht::token>>(
v | boost::adaptors::transformed(token_from_long));
};
dht::murmur3_partitioner mm3p7s2i(7, 2);
auto mm3p7s2i_shard_limits = make_token_vector({
-9223372036854775807,
-8564559748508006107, -7905747460161236406, -7246935171814466706, -6588122883467697005,
-5929310595120927305, -5270498306774157604, -4611686018427387904, -3952873730080618203,
-3294061441733848502, -2635249153387078802, -1976436865040309101, -1317624576693539401,
-658812288346769700, 0, 658812288346769701, 1317624576693539402, 1976436865040309102,
2635249153387078803, 3294061441733848503, 3952873730080618204, 4611686018427387904,
5270498306774157605, 5929310595120927306, 6588122883467697006, 7246935171814466707,
7905747460161236407, 8564559748508006108,
});
test_partitioner_sharding(mm3p7s2i, 7, mm3p7s2i_shard_limits, prev_token, 2);
dht::murmur3_partitioner mm3p2s4i(2, 4);
auto mm3p2s_shard_limits = make_token_vector({
-9223372036854775807,
-8646911284551352320, -8070450532247928832, -7493989779944505344, -6917529027641081856,
-6341068275337658368, -5764607523034234880, -5188146770730811392, -4611686018427387904,
-4035225266123964416, -3458764513820540928, -2882303761517117440, -2305843009213693952,
-1729382256910270464, -1152921504606846976, -576460752303423488, 0, 576460752303423488,
1152921504606846976, 1729382256910270464, 2305843009213693952, 2882303761517117440,
3458764513820540928, 4035225266123964416, 4611686018427387904, 5188146770730811392,
5764607523034234880, 6341068275337658368, 6917529027641081856, 7493989779944505344,
8070450532247928832, 8646911284551352320,
});
test_partitioner_sharding(mm3p2s4i, 2, mm3p2s_shard_limits, prev_token, 4);
}
BOOST_AUTO_TEST_CASE(test_random_partitioner) {
using int128 = boost::multiprecision::int128_t;
auto prev_token = [] (const dht::i_partitioner& part, dht::token token) {
return part.from_sstring(std::string(int128(std::string(part.to_sstring(token))) - 1));
};
auto make_token_vector = [] (dht::i_partitioner& part, std::vector<const char*> v) {
auto from_string = [&] (const char* s) { return part.from_sstring(s); };
return boost::copy_range<std::vector<dht::token>>(
v | boost::adaptors::transformed(from_string));
};
dht::random_partitioner rp7s(7);
auto rp7s_shard_limits = make_token_vector(rp7s, {
"0",
"24305883351495604533098186245126300819",
"48611766702991209066196372490252601637",
"72917650054486813599294558735378902455",
"97223533405982418132392744980505203274",
"121529416757478022665490931225631504092",
"145835300108973627198589117470757804910",
});
test_partitioner_sharding(rp7s, 7, rp7s_shard_limits, prev_token);
dht::random_partitioner rp2s(2);
auto rp2s_shard_limits = make_token_vector(rp2s, {
"0", "85070591730234615865843651857942052864",
});
test_partitioner_sharding(rp2s, 2, rp2s_shard_limits, prev_token);
dht::random_partitioner rp1s(1);
auto rp1s_shard_limits = make_token_vector(rp1s, {
"0",
});
test_partitioner_sharding(rp1s, 1, rp1s_shard_limits, prev_token);
}
BOOST_AUTO_TEST_CASE(test_byte_ordered_partitioner) {
auto prev_token = [] (const dht::i_partitioner& part, dht::token token) {
auto& bytes = token._data;
for (auto i = 0u; i < bytes.size(); ++i) {
auto& b = bytes[bytes.size() - 1 - i];
auto bfore = b;
--b;
if (bfore != 0) {
break;
}
}
return token;
};
auto make_token_vector = [] (dht::i_partitioner& part, std::vector<int> v) {
auto from_byte = [&] (bytes::value_type b) { return dht::token(dht::token::kind::key, managed_bytes({b})); };
return boost::copy_range<std::vector<dht::token>>(
v | boost::adaptors::transformed(from_byte));
};
dht::byte_ordered_partitioner bop7s(7);
auto bop7s_shard_limits = make_token_vector(bop7s, {
0, 37, 74, 110, 147, 183, 220,
});
test_partitioner_sharding(bop7s, 7, bop7s_shard_limits, prev_token);
dht::byte_ordered_partitioner bop2s(2);
auto bop2s_shard_limits = make_token_vector(bop2s, {
0, 128,
});
test_partitioner_sharding(bop2s, 2, bop2s_shard_limits, prev_token);
dht::byte_ordered_partitioner bop1s(1);
auto bop1s_shard_limits = make_token_vector(bop1s, {
0,
});
test_partitioner_sharding(bop1s, 1, bop1s_shard_limits, prev_token);
}
static
dht::partition_range
normalize(dht::partition_range pr) {
auto start = pr.start();
if (start && start->value().token() == dht::minimum_token()) {
start = stdx::nullopt;
}
auto end = pr.end();
if (end && end->value().token() == dht::maximum_token()) {
end = stdx::nullopt;
}
return dht::partition_range(start, end);
};
static
void
test_exponential_sharder(const dht::i_partitioner& part, const schema& s, const dht::partition_range& pr) {
dht::set_global_partitioner(part.name()); // so we can print tokens, also ring_position_comparator is not global_partitioner() clean
// Step 1: run the exponential sharder fully, and collect all results
debug("input range: %s\n", pr);
auto results = std::vector<dht::ring_position_exponential_sharder_result>();
auto sharder = dht::ring_position_exponential_sharder(part, pr);
auto partial_result = sharder.next(s);
while (partial_result) {
results.push_back(std::move(*partial_result));
partial_result = sharder.next(s);
}
// Step 2: "de-exponentialize" the result by fragmenting large ranges
struct fragmented_sharder_result {
bool inorder;
struct shard_result {
shard_id shard;
std::vector<dht::partition_range> ranges;
};
std::vector<shard_result> shards;
};
auto fragmented_results = std::vector<fragmented_sharder_result>();
for (auto&& partial_result : results) {
auto fsr = fragmented_sharder_result();
fsr.inorder = partial_result.inorder;
debug("looking at partial result\n");
for (auto&& per_shard_range : partial_result.per_shard_ranges) {
debug("partial_result: looking at %s (shard %d)\n", per_shard_range.ring_range, per_shard_range.shard);
auto sr = fragmented_sharder_result::shard_result();
sr.shard = per_shard_range.shard;
auto sharder = dht::ring_position_range_sharder(part, per_shard_range.ring_range);
auto next = sharder.next(s);
while (next) {
debug("seeing: shard %d frag %s\n", next->shard, next->ring_range);
if (next->shard == sr.shard) {
debug("fragmented to %d\n", next->ring_range);
sr.ranges.push_back(std::move(next->ring_range));
}
next = sharder.next(s);
}
fsr.shards.push_back(std::move(sr));
}
fragmented_results.push_back(std::move(fsr));
}
// Step 3: collect all fragmented ranges
auto all_fragments = std::vector<dht::partition_range>();
for (auto&& fr : fragmented_results) {
for (auto&& sr : fr.shards) {
for (auto&& f : sr.ranges) {
all_fragments.push_back(f);
}
}
}
// Step 4: verify no overlaps
bool no_overlaps = true;
if (all_fragments.size() > 1) {
for (auto i : boost::irange<size_t>(1, all_fragments.size() - 1)) {
for (auto j : boost::irange<size_t>(0, i)) {
no_overlaps &= !all_fragments[i].overlaps(all_fragments[j], dht::ring_position_comparator(s));
}
}
}
BOOST_REQUIRE(no_overlaps); // We OOM if BOOST_REQUIRE() is run in the inner loop
// Step 5: verify all fragments are contiguous
auto rplc = dht::ring_position_less_comparator(s);
auto rptc = dht::ring_position_comparator(s);
boost::sort(all_fragments, [&] (const dht::partition_range& a, const dht::partition_range b) {
if (!a.start() || !b.start()) {
return unsigned(bool(a.start())) < unsigned(bool(b.start()));
} else {
return rplc(a.start()->value(), b.start()->value());
}
});
auto not_adjacent = [&] (const dht::partition_range& a, const dht::partition_range b) {
return !a.end() || !b.start() || rptc(a.end()->value(), b.start()->value()) != 0;
};
BOOST_REQUIRE(boost::adjacent_find(all_fragments, not_adjacent) == all_fragments.end());
// Step 6: verify inorder is accurate; allow a false negative
for (auto&& fsr : fragmented_results) {
auto has_one_fragment = [] (const fragmented_sharder_result::shard_result& sr) {
return sr.ranges.size() <= 1; // the sharder may return a range that does not intersect the shard
};
BOOST_REQUIRE(!fsr.inorder || boost::algorithm::all_of(fsr.shards, has_one_fragment));
}
// Step 7: verify that the fragmented range matches the input range (since the fragments are
// contiguous, we need only test the edges).
auto reconstructed = normalize(dht::partition_range(all_fragments.front().start(), all_fragments.back().end()));
auto original = normalize(pr);
debug("original %s reconstructed %s\n", original, reconstructed);
BOOST_REQUIRE(original.contains(reconstructed, rptc) && reconstructed.contains(original, rptc));
// Step 8: verify exponentiality
debug("sizes %d %d\n", results.size(), 1 + log2ceil(div_ceil(all_fragments.size(), part.shard_count())) + log2ceil(part.shard_count()));
BOOST_REQUIRE(results.size() <= 1 + log2ceil(div_ceil(all_fragments.size(), part.shard_count())) + log2ceil(part.shard_count()));
}
static
void
test_something_with_some_interesting_ranges_and_partitioners(std::function<void (const dht::i_partitioner&, const schema&, const dht::partition_range&)> func_to_test) {
auto s = schema_builder("ks", "cf")
.with_column("c1", int32_type, column_kind::partition_key)
.with_column("c2", int32_type, column_kind::partition_key)
.with_column("v", int32_type)
.build();
auto some_murmur3_partitioners = {
dht::murmur3_partitioner(1, 0),
dht::murmur3_partitioner(7, 4),
dht::murmur3_partitioner(4, 0),
dht::murmur3_partitioner(32, 8), // More, and we OOM since memory isn't configured
};
auto some_random_partitioners = {
dht::random_partitioner(1),
dht::random_partitioner(3),
};
auto some_byte_ordered_partitioners = {
dht::byte_ordered_partitioner(1),
dht::byte_ordered_partitioner(7),
};
auto t1 = token_from_long(int64_t(-0x7fff'ffff'ffff'fffe));
auto t2 = token_from_long(int64_t(-1));
auto t3 = token_from_long(int64_t(1));
auto t4 = token_from_long(int64_t(0x7fff'ffff'ffff'fffe));
auto make_bound = [] (dht::ring_position rp) {
return stdx::make_optional(range_bound<dht::ring_position>(std::move(rp)));
};
auto some_murmur3_ranges = {
dht::partition_range::make_open_ended_both_sides(),
dht::partition_range::make_starting_with(dht::ring_position::starting_at(t1)),
dht::partition_range::make_starting_with(dht::ring_position::starting_at(t2)),
dht::partition_range::make_starting_with(dht::ring_position::ending_at(t3)),
dht::partition_range::make_starting_with(dht::ring_position::starting_at(t4)),
dht::partition_range::make_ending_with(dht::ring_position::starting_at(t1)),
dht::partition_range::make_ending_with(dht::ring_position::starting_at(t2)),
dht::partition_range::make_ending_with(dht::ring_position::starting_at(t3)),
dht::partition_range::make_ending_with(dht::ring_position::starting_at(t4)),
dht::partition_range(make_bound(dht::ring_position::starting_at(t2)), make_bound(dht::ring_position::ending_at(t3))),
dht::partition_range(make_bound(dht::ring_position::ending_at(t1)), make_bound(dht::ring_position::starting_at(t4))),
};
for (auto&& part : some_murmur3_partitioners) {
for (auto&& range : some_murmur3_ranges) {
func_to_test(part, *s, range);
}
}
for (auto&& part : some_random_partitioners) {
func_to_test(part, *s, dht::partition_range::make_open_ended_both_sides());
}
for (auto&& part : some_byte_ordered_partitioners) {
func_to_test(part, *s, dht::partition_range::make_open_ended_both_sides());
}
}
BOOST_AUTO_TEST_CASE(test_exponential_sharders) {
return test_something_with_some_interesting_ranges_and_partitioners(test_exponential_sharder);
}
static
void
do_test_split_range_to_single_shard(const dht::i_partitioner& part, const schema& s, const dht::partition_range& pr) {
dht::set_global_partitioner(part.name()); // so we can print tokens, also ring_position_comparator is not global_partitioner() clean
for (auto shard : boost::irange(0u, part.shard_count())) {
auto ranges = dht::split_range_to_single_shard(part, s, pr, shard);
auto sharder = dht::ring_position_range_sharder(part, pr);
auto x = sharder.next(s);
auto cmp = dht::ring_position_comparator(s);
auto reference_ranges = std::vector<dht::partition_range>();
while (x) {
if (x->shard == shard) {
reference_ranges.push_back(std::move(x->ring_range));
}
x = sharder.next(s);
}
BOOST_REQUIRE(ranges.size() == reference_ranges.size());
for (auto&& rs : boost::combine(ranges, reference_ranges)) {
auto&& r1 = normalize(boost::get<0>(rs));
auto&& r2 = normalize(boost::get<1>(rs));
BOOST_REQUIRE(r1.contains(r2, cmp));
BOOST_REQUIRE(r2.contains(r1, cmp));
}
}
}
BOOST_AUTO_TEST_CASE(test_split_range_single_shard) {
return test_something_with_some_interesting_ranges_and_partitioners(do_test_split_range_to_single_shard);
}
// tests for range_split() utility function in repair/range_split.hh
static int test_split(int N, int K) {
auto t1 = token_from_long(0x2000'0000'0000'0000);
auto t2 = token_from_long(0x5000'0000'0000'0000);
dht::token_range r{range_bound<dht::token>(t1), range_bound<dht::token>(t2)};
auto splitter = range_splitter(r, N, K);
int c = 0;
dht::token_range prev_range;
while (splitter.has_next()) {
auto range = splitter.next();
//std::cerr << range << "\n";
if (c == 0) {
BOOST_REQUIRE(range.start() == r.start());
} else {
std::experimental::optional<dht::token_range::bound> e({prev_range.end()->value(), !prev_range.end()->is_inclusive()});
BOOST_REQUIRE(range.start() == e);
}
prev_range = range;
c++;
}
if (c > 0) {
BOOST_REQUIRE(prev_range.end() == r.end());
}
return c;
}
BOOST_AUTO_TEST_CASE(test_split_1) {
BOOST_REQUIRE(test_split(128, 16) == 8);
// will make 7 binary splits: 500, 250, 125.5, 62.5, 31.25, 15.625,
// 7.8125, so expect 2^7 = 128 ranges:
BOOST_REQUIRE(test_split(1000, 11) == 128);
}
static
void
test_something_with_some_interesting_ranges_and_partitioners_with_token_range(std::function<void (const dht::i_partitioner&, const schema&, const dht::token_range&)> func_to_test) {
auto s = schema_builder("ks", "cf")
.with_column("c1", int32_type, column_kind::partition_key)
.with_column("c2", int32_type, column_kind::partition_key)
.with_column("v", int32_type)
.build();
auto some_murmur3_partitioners = {
dht::murmur3_partitioner(1, 0),
dht::murmur3_partitioner(7, 4),
dht::murmur3_partitioner(4, 0),
dht::murmur3_partitioner(32, 8), // More, and we OOM since memory isn't configured
};
auto some_random_partitioners = {
dht::random_partitioner(1),
dht::random_partitioner(3),
};
auto t1 = token_from_long(int64_t(-0x7fff'ffff'ffff'fffe));
auto t2 = token_from_long(int64_t(-1));
auto t3 = token_from_long(int64_t(1));
auto t4 = token_from_long(int64_t(0x7fff'ffff'ffff'fffe));
auto make_bound = [] (dht::token t) {
return range_bound<dht::token>(std::move(t));
};
auto some_murmur3_ranges = {
dht::token_range::make_open_ended_both_sides(),
dht::token_range::make_starting_with(make_bound(t1)),
dht::token_range::make_starting_with(make_bound(t2)),
dht::token_range::make_starting_with(make_bound(t3)),
dht::token_range::make_starting_with(make_bound(t4)),
dht::token_range::make_ending_with(make_bound(t1)),
dht::token_range::make_ending_with(make_bound(t2)),
dht::token_range::make_ending_with(make_bound(t3)),
dht::token_range::make_ending_with(make_bound(t4)),
dht::token_range(make_bound(t2), make_bound(t3)),
dht::token_range(make_bound(t1), make_bound(t4)),
};
for (auto&& part : some_murmur3_partitioners) {
for (auto&& range : some_murmur3_ranges) {
func_to_test(part, *s, range);
}
}
for (auto&& part : some_random_partitioners) {
func_to_test(part, *s, dht::token_range::make_open_ended_both_sides());
}
}
static
void
do_test_selective_token_range_sharder(const dht::i_partitioner& part, const schema& s, const dht::token_range& range) {
dht::set_global_partitioner(part.name());
bool debug = false;
for (auto shard : boost::irange(0u, part.shard_count())) {
auto sharder = dht::selective_token_range_sharder(part, range, shard);
auto range_shard = sharder.next();
while (range_shard) {
if (range_shard->start() && range_shard->start()->is_inclusive()) {
auto start_shard = part.shard_of(range_shard->start()->value());
if (debug) {
std::cout << " start_shard " << start_shard << " shard " << shard << " range " << range_shard << "\n";
}
BOOST_REQUIRE(start_shard == shard);
}
if (range_shard->end() && range_shard->end()->is_inclusive()) {
auto end_shard = part.shard_of(range_shard->end()->value());
if (debug) {
std::cout << " end_shard " << end_shard << " shard " << shard << " range " << range_shard << "\n";
}
BOOST_REQUIRE(end_shard == shard);
}
auto midpoint = part.midpoint(
range_shard->start() ? range_shard->start()->value() : dht::minimum_token(),
range_shard->end() ? range_shard->end()->value() : dht::minimum_token());
auto mid_shard = part.shard_of(midpoint);
if (debug) {
std::cout << " mid " << mid_shard << " shard " << shard << " range " << range_shard << "\n";
}
BOOST_REQUIRE(mid_shard == shard);
range_shard = sharder.next();
}
}
}
BOOST_AUTO_TEST_CASE(test_selective_token_range_sharder) {
return test_something_with_some_interesting_ranges_and_partitioners_with_token_range(do_test_selective_token_range_sharder);
}
Reference in New Issue View Git Blame Copy Permalink