mirror of
https://github.com/scylladb/scylladb.git
synced 2026-04-23 01:50:35 +00:00
9031294ea9
This reverts commit 2ebd1463b2.
The test introduced by that commit was wrong, and in fact depended on
a bug in operator== for data_value. A followup patch fixes operator==,
so this reverts the broken commit first.
The reason it was broken was that it created a live cell with a null
data_value. In reality, null values are represented with dead cells.
For example, the sstable produced by
CREATE TABLE my_table (key int PRIMARY KEY, v1 int, v2 int) with compression = {'sstable_compression': ''};
INSERT INTO my_table (key, v1, v2) VALUES (1, 42, null);
Is
00 04 key_length
00 00 00 01 key
7f ff ff ff local_deletion_time
80 00 00 00 00 00 00 00 marked_for_delete_at
24 HAS_ALL_COLUMNS | HAS_TIMESTAMP
09 row_body_size
12 prev_unfiltered_size
00 delta_timestamp
08 USE_ROW_TIMESTAMP_MASK
00 00 00 2a value
0d USE_ROW_TIMESTAMP_MASK | HAS_EMPTY_VALUE_MASK | IS_DELETED_MASK
00 deletion time
01 END_OF_PARTITION
Signed-off-by: Rafael Ávila de Espíndola <espindola@scylladb.com>
112 lines
3.3 KiB
C++
112 lines
3.3 KiB
C++
/*
|
|
* 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/>.
|
|
*/
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include "test/lib/result_set_assertions.hh"
|
|
#include "to_string.hh"
|
|
|
|
static inline
|
|
sstring to_sstring(const bytes& b) {
|
|
return sstring(b.begin(), b.end());
|
|
}
|
|
|
|
bool
|
|
row_assertion::matches(const query::result_set_row& row) const {
|
|
for (auto&& column_and_value : _expected_values) {
|
|
auto&& name = column_and_value.first;
|
|
auto&& value = column_and_value.second;
|
|
|
|
// FIXME: result_set_row works on sstring column names instead of more general "bytes".
|
|
auto ss_name = to_sstring(name);
|
|
|
|
const data_value* val = row.get_data_value(ss_name);
|
|
if (val == nullptr) {
|
|
if (!value.is_null()) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (*val != value) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (_only_that) {
|
|
for (auto&& e : row.cells()) {
|
|
auto name = to_bytes(e.first);
|
|
if (!_expected_values.count(name)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
sstring
|
|
row_assertion::describe(schema_ptr schema) const {
|
|
return "{" + ::join(", ", _expected_values | boost::adaptors::transformed([&schema] (auto&& e) {
|
|
auto&& name = e.first;
|
|
auto&& value = e.second;
|
|
const column_definition* def = schema->get_column_definition(name);
|
|
if (!def) {
|
|
BOOST_FAIL(format("Schema is missing column definition for '{}'", name));
|
|
}
|
|
if (value.is_null()) {
|
|
return format("{}=null", to_sstring(name));
|
|
} else {
|
|
return format("{}=\"{}\"", to_sstring(name), def->type->to_string(def->type->decompose(value)));
|
|
}
|
|
})) + "}";
|
|
}
|
|
|
|
const result_set_assertions&
|
|
result_set_assertions::has(const row_assertion& ra) const {
|
|
for (auto&& row : _rs.rows()) {
|
|
if (ra.matches(row)) {
|
|
return *this;
|
|
}
|
|
}
|
|
BOOST_FAIL(format("Row {} not found in {}", ra.describe(_rs.schema()), _rs));
|
|
return *this;
|
|
}
|
|
|
|
const result_set_assertions&
|
|
result_set_assertions::has_only(const row_assertion& ra) const {
|
|
BOOST_REQUIRE(_rs.rows().size() == 1);
|
|
auto& row = _rs.rows()[0];
|
|
if (!ra.matches(row)) {
|
|
BOOST_FAIL(format("Expected {} but got {}", ra.describe(_rs.schema()), row));
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
const result_set_assertions&
|
|
result_set_assertions::is_empty() const {
|
|
BOOST_REQUIRE_EQUAL(_rs.rows().size(), 0);
|
|
return *this;
|
|
}
|
|
|
|
const result_set_assertions&
|
|
result_set_assertions::has_size(int row_count) const {
|
|
BOOST_REQUIRE_EQUAL(_rs.rows().size(), row_count);
|
|
return *this;
|
|
}
|