fdc1449392
flat_mutation_reader_v2 was introduced in a pair of commits in 2021:e3309322c3"Clone flat_mutation_reader related classes into v2 variants"08b5773c12"Adapt flat_mutation_reader_v2 to the new version of the API" as a replacement for flat_mutation_reader, using range_tombstone_change instead of range_tombstone to represent represent range tombstones. See those commits for more information. The transition was incremental; the last use of the original flat_mutation_reader was removed in 2022 in commit026f8cc1e7"db: Use mutation_partition_v2 in mvcc" In turn, flat_mutation_reader was introduced in 2017 in commit748205ca75"Introduce flat_mutation_reader" To transition from a mutation_reader that nested rows within a partition in a separate stream, to a flat reader that streamed partitions and rows in the same stream. Here, we reclaim the original name and rename the awkward flat_mutation_reader_v2 to mutation_reader. Note that mutation_fragment_v2 remains since we still use the original for compatibilty, sometimes. Some notes about the transition: - files were also renamed. In one case (flat_mutation_reader_test.cc), the rename target already existed, so we rename to mutation_reader_another_test.cc. - a namespace 'mutation_reader' with two definitions existed (in mutation_reader_fwd.hh). Its contents was folded into the mutation_reader class. As a result, a few #includes had to be adjusted. Closes scylladb/scylladb#19356
94 lines
5.1 KiB
C++
94 lines
5.1 KiB
C++
/*
|
|
* Copyright (C) 2015-present ScyllaDB
|
|
*/
|
|
|
|
/*
|
|
* SPDX-License-Identifier: AGPL-3.0-or-later
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "readers/mutation_reader_fwd.hh"
|
|
#include "test/lib/simple_schema.hh"
|
|
|
|
using populate_fn = std::function<mutation_source(schema_ptr s, const std::vector<mutation>&)>;
|
|
using populate_fn_ex = std::function<mutation_source(schema_ptr s, const std::vector<mutation>&, gc_clock::time_point)>;
|
|
|
|
// Must be run in a seastar thread
|
|
void run_mutation_source_tests(populate_fn populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_plain(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_plain_basic(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_plain_reader_conversion(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_plain_fragments_monotonic(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_plain_read_back(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_reverse(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_reverse_basic(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_reverse_reader_conversion(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_reverse_fragments_monotonic(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
void run_mutation_source_tests_reverse_read_back(populate_fn_ex populate, bool with_partition_range_forwarding = true);
|
|
|
|
enum are_equal { no, yes };
|
|
|
|
// Calls the provided function on mutation pairs, equal and not equal. Is supposed
|
|
// to exercise all potential ways two mutations may differ.
|
|
void for_each_mutation_pair(std::function<void(const mutation&, const mutation&, are_equal)>);
|
|
|
|
// Calls the provided function on mutations. Is supposed to exercise as many differences as possible.
|
|
void for_each_mutation(std::function<void(const mutation&)>);
|
|
|
|
// Returns true if mutations in schema s1 can be upgraded to s2.
|
|
inline bool can_upgrade_schema(schema_ptr from, schema_ptr to) {
|
|
return from->is_counter() == to->is_counter();
|
|
}
|
|
|
|
// Merge mutations that have the same key.
|
|
// The returned vector has mutations with unique keys.
|
|
// run_mutation_source_tests() might pass in multiple mutations for the same key.
|
|
// Some tests need these deduplicated, which is what this method does.
|
|
std::vector<mutation> squash_mutations(std::vector<mutation> mutations);
|
|
|
|
class random_mutation_generator {
|
|
class impl;
|
|
std::unique_ptr<impl> _impl;
|
|
public:
|
|
struct generate_counters_tag { };
|
|
using generate_counters = bool_class<generate_counters_tag>;
|
|
using generate_uncompactable = bool_class<class generate_uncompactable_tag>;
|
|
|
|
// With generate_uncompactable::yes, the mutation will be uncompactable, that
|
|
// is no higher level tombstone will cover lower level tombstones and no
|
|
// tombstone will cover data, i.e. compacting the mutation will not result
|
|
// in any changes.
|
|
explicit random_mutation_generator(generate_counters, local_shard_only lso = local_shard_only::yes,
|
|
generate_uncompactable uc = generate_uncompactable::no, std::optional<uint32_t> seed_opt = std::nullopt, const char* ks_name="ks", const char* cf_name="cf");
|
|
random_mutation_generator(generate_counters gc, uint32_t seed)
|
|
: random_mutation_generator(gc, local_shard_only::yes, generate_uncompactable::no, seed) {}
|
|
~random_mutation_generator();
|
|
mutation operator()();
|
|
// Generates n mutations sharing the same schema nad sorted by their decorated keys.
|
|
std::vector<mutation> operator()(size_t n);
|
|
schema_ptr schema() const;
|
|
clustering_key make_random_key();
|
|
range_tombstone make_random_range_tombstone();
|
|
std::vector<dht::decorated_key> make_partition_keys(size_t n);
|
|
std::vector<query::clustering_range> make_random_ranges(unsigned n_ranges);
|
|
// Sets the number of distinct clustering keys which will be used in generated mutations.
|
|
void set_key_cardinality(size_t);
|
|
};
|
|
|
|
bytes make_blob(size_t blob_size);
|
|
|
|
void for_each_schema_change(std::function<void(schema_ptr, const std::vector<mutation>&,
|
|
schema_ptr, const std::vector<mutation>&)>);
|
|
|
|
void compare_readers(const schema&, mutation_reader authority, mutation_reader tested, bool exact = false);
|
|
void compare_readers(const schema&, mutation_reader authority, mutation_reader tested, const std::vector<position_range>& fwd_ranges);
|
|
|
|
// Forward `r` to each range in `fwd_ranges` and consume all fragments produced by `r` in these ranges.
|
|
// Build a mutation out of these fragments.
|
|
//
|
|
// Assumes that for each subsequent `r1`, `r2` in `fwd_ranges`, `r1.end() <= r2.start()`.
|
|
// Must be run in a seastar::thread.
|
|
mutation forwardable_reader_to_mutation(mutation_reader r, const std::vector<position_range>& fwd_ranges);
|