118 lines
3.8 KiB
C++
118 lines
3.8 KiB
C++
/*
|
|
* Copyright (C) 2017 ScyllaDB
|
|
*
|
|
* Modified by 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/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "make_random_string.hh"
|
|
#include "schema.hh"
|
|
#include "keys.hh"
|
|
#include "streamed_mutation.hh"
|
|
#include "mutation.hh"
|
|
|
|
// Helper for working with the following table:
|
|
//
|
|
// CREATE TABLE ks.cf (pk utf8, ck utf8, v utf8, s1 utf8 static, PRIMARY KEY (pk, ck));
|
|
//
|
|
class simple_schema {
|
|
schema_ptr _s;
|
|
api::timestamp_type _timestamp = api::min_timestamp;
|
|
private:
|
|
api::timestamp_type new_timestamp() {
|
|
return _timestamp++;
|
|
}
|
|
public:
|
|
simple_schema()
|
|
: _s(schema_builder("ks", "cf")
|
|
.with_column("pk", utf8_type, column_kind::partition_key)
|
|
.with_column("ck", utf8_type, column_kind::clustering_key)
|
|
.with_column("s1", utf8_type, column_kind::static_column)
|
|
.with_column("v", utf8_type)
|
|
.build())
|
|
{ }
|
|
|
|
clustering_key make_ckey(sstring ck) {
|
|
return clustering_key::from_single_value(*_s, data_value(ck).serialize());
|
|
}
|
|
|
|
// Make a clustering_key which is n-th in some arbitrary sequence of keys
|
|
clustering_key make_ckey(uint32_t n) {
|
|
return make_ckey(sprint("ck%010d", n));
|
|
}
|
|
|
|
// Make a partition key which is n-th in some arbitrary sequence of keys.
|
|
// There is no particular order for the keys, they're not in ring order.
|
|
dht::decorated_key make_pkey(uint32_t n) {
|
|
return make_pkey(sprint("pk%010d", n));
|
|
}
|
|
|
|
dht::decorated_key make_pkey(sstring pk) {
|
|
auto key = partition_key::from_single_value(*_s, data_value(pk).serialize());
|
|
return dht::global_partitioner().decorate_key(*_s, key);
|
|
}
|
|
|
|
void add_row(mutation& m, const clustering_key& key, sstring v) {
|
|
m.set_clustered_cell(key, to_bytes("v"), data_value(v), new_timestamp());
|
|
}
|
|
|
|
mutation_fragment make_row(const clustering_key& key, sstring v) {
|
|
auto row = clustering_row(key);
|
|
row.cells().apply(*_s->get_column_definition(to_bytes(sstring("v"))),
|
|
atomic_cell::make_live(new_timestamp(), data_value(v).serialize()));
|
|
return mutation_fragment(std::move(row));
|
|
}
|
|
|
|
void add_static_row(mutation& m, sstring s1) {
|
|
m.set_static_cell(to_bytes("s1"), data_value(s1), new_timestamp());
|
|
}
|
|
|
|
range_tombstone delete_range(mutation& m, const query::clustering_range& range) {
|
|
auto rt = make_range_tombstone(range);
|
|
m.partition().apply_delete(*_s, rt);
|
|
return rt;
|
|
}
|
|
|
|
range_tombstone make_range_tombstone(const query::clustering_range& range) {
|
|
auto bv_range = bound_view::from_range(range);
|
|
range_tombstone rt(bv_range.first, bv_range.second, tombstone(new_timestamp(), gc_clock::now()));
|
|
return rt;
|
|
}
|
|
|
|
mutation new_mutation(sstring pk) {
|
|
return mutation(make_pkey(pk), _s);
|
|
}
|
|
|
|
schema_ptr schema() {
|
|
return _s;
|
|
}
|
|
|
|
// Creates a sequence of keys in ring order
|
|
std::vector<dht::decorated_key> make_pkeys(int n) {
|
|
std::vector<dht::decorated_key> keys;
|
|
for (int i = 0; i < n; ++i) {
|
|
keys.push_back(make_pkey(i));
|
|
}
|
|
std::sort(keys.begin(), keys.end(), dht::decorated_key::less_comparator(_s));
|
|
return keys;
|
|
}
|
|
};
|