trace_processor: rename Table::size() -> Table::row_count()
Future tables use size as a column inside the table and we get bad name
clashes if we don't rename this method.
Change-Id: I73db86f24901e2fdce2a6b9b063efec702fbbf8b
diff --git a/src/trace_processor/db/table.cc b/src/trace_processor/db/table.cc
index 823f57f..6fa723c 100644
--- a/src/trace_processor/db/table.cc
+++ b/src/trace_processor/db/table.cc
@@ -32,7 +32,7 @@
}
Table& Table::operator=(Table&& other) noexcept {
- size_ = other.size_;
+ row_count_ = other.row_count_;
string_pool_ = other.string_pool_;
row_maps_ = std::move(other.row_maps_);
@@ -53,7 +53,7 @@
Table Table::CopyExceptRowMaps() const {
Table table(string_pool_, nullptr);
- table.size_ = size_;
+ table.row_count_ = row_count_;
for (const Column& col : columns_) {
table.columns_.emplace_back(col, &table, col.index_in_table(),
col.row_map_idx_);
@@ -66,7 +66,7 @@
return Copy();
// Build an index vector with all the indices for the first |size_| rows.
- std::vector<uint32_t> idx(size_);
+ std::vector<uint32_t> idx(row_count_);
std::iota(idx.begin(), idx.end(), 0);
// As our data is columnar, it's always more efficient to sort one column
@@ -108,7 +108,7 @@
RowMap rm(std::move(idx));
for (const RowMap& map : row_maps_) {
table.row_maps_.emplace_back(map.SelectRows(rm));
- PERFETTO_DCHECK(table.row_maps_.back().size() == table.size());
+ PERFETTO_DCHECK(table.row_maps_.back().size() == table.row_count());
}
// Remove the sorted flag from all the columns.
@@ -126,7 +126,7 @@
// The join table will have the same size and RowMaps as the left (this)
// table because the left column is indexing the right table.
Table table(string_pool_, nullptr);
- table.size_ = size_;
+ table.row_count_ = row_count_;
for (const RowMap& rm : row_maps_) {
table.row_maps_.emplace_back(rm.Copy());
}
@@ -146,8 +146,8 @@
// the RowMap of the right column. By getting the index of the row rather
// than the row number itself, we can call |Apply| on the other RowMaps
// in the right table.
- std::vector<uint32_t> indices(size_);
- for (uint32_t i = 0; i < size_; ++i) {
+ std::vector<uint32_t> indices(row_count_);
+ for (uint32_t i = 0; i < row_count_; ++i) {
SqlValue val = left_col.Get(i);
PERFETTO_CHECK(val.type != SqlValue::Type::kNull);
indices[i] = right_col.IndexOf(val).value();
diff --git a/src/trace_processor/db/table.h b/src/trace_processor/db/table.h
index 1b85a26..058dac7 100644
--- a/src/trace_processor/db/table.h
+++ b/src/trace_processor/db/table.h
@@ -84,7 +84,7 @@
// Returns a RowMap which, if applied to the table, would contain the rows
// post filter.
RowMap FilterToRowMap(const std::vector<Constraint>& cs) const {
- RowMap rm(0, size_);
+ RowMap rm(0, row_count_);
for (const Constraint& c : cs) {
columns_[c.col_idx].FilterInto(c.op, c.value, &rm);
}
@@ -97,10 +97,10 @@
// passed RowMap is generated using |FilterToRowMap|.
Table Apply(RowMap rm) const {
Table table = CopyExceptRowMaps();
- table.size_ = rm.size();
+ table.row_count_ = rm.size();
for (const RowMap& map : row_maps_) {
table.row_maps_.emplace_back(map.SelectRows(rm));
- PERFETTO_DCHECK(table.row_maps_.back().size() == table.size());
+ PERFETTO_DCHECK(table.row_maps_.back().size() == table.row_count());
}
return table;
}
@@ -145,7 +145,7 @@
// Returns an iterator into the Table.
Iterator IterateRows() const { return Iterator(this); }
- uint32_t size() const { return size_; }
+ uint32_t row_count() const { return row_count_; }
const std::vector<RowMap>& row_maps() const { return row_maps_; }
protected:
@@ -153,7 +153,7 @@
std::vector<RowMap> row_maps_;
std::vector<Column> columns_;
- uint32_t size_ = 0;
+ uint32_t row_count_ = 0;
StringPool* string_pool_ = nullptr;
diff --git a/src/trace_processor/event_tracker_unittest.cc b/src/trace_processor/event_tracker_unittest.cc
index bebd42d..9fdedac 100644
--- a/src/trace_processor/event_tracker_unittest.cc
+++ b/src/trace_processor/event_tracker_unittest.cc
@@ -125,9 +125,9 @@
context.event_tracker->PushCounter(timestamp + 3, 5000, track);
context.event_tracker->PushCounter(timestamp + 9, 1000, track);
- ASSERT_EQ(context.storage->counter_track_table().size(), 1ul);
+ ASSERT_EQ(context.storage->counter_track_table().row_count(), 1ul);
- ASSERT_EQ(context.storage->counter_table().size(), 4ul);
+ ASSERT_EQ(context.storage->counter_table().row_count(), 4ul);
ASSERT_EQ(context.storage->counter_table().ts()[0], timestamp);
ASSERT_DOUBLE_EQ(context.storage->counter_table().value()[0], 1000);
diff --git a/src/trace_processor/export_json.cc b/src/trace_processor/export_json.cc
index df5f2b5..9ac286e 100644
--- a/src/trace_processor/export_json.cc
+++ b/src/trace_processor/export_json.cc
@@ -458,7 +458,7 @@
const ArgsBuilder& args_builder,
TraceFormatWriter* writer) {
const auto& slices = storage->slice_table();
- for (uint32_t i = 0; i < slices.size(); ++i) {
+ for (uint32_t i = 0; i < slices.row_count(); ++i) {
Json::Value event;
event["ts"] = Json::Int64(slices.ts()[i] / 1000);
event["cat"] = GetNonNullString(storage, slices.category()[i]);
@@ -845,7 +845,7 @@
const auto& callsites = storage->stack_profile_callsite_table();
int64_t maybe_callsite_id = samples.callsite_ids()[i];
PERFETTO_DCHECK(maybe_callsite_id >= 0 &&
- maybe_callsite_id < callsites.size());
+ maybe_callsite_id < callsites.row_count());
while (maybe_callsite_id >= 0) {
uint32_t callsite_id = static_cast<uint32_t>(maybe_callsite_id);
diff --git a/src/trace_processor/export_json_unittest.cc b/src/trace_processor/export_json_unittest.cc
index 02fe44d..4d72fcc 100644
--- a/src/trace_processor/export_json_unittest.cc
+++ b/src/trace_processor/export_json_unittest.cc
@@ -1150,7 +1150,7 @@
uint32_t frame_row_id_1 = storage->mutable_stack_profile_frames()->Insert(
{/*name_id=*/0, module_row_id_1, 0x42});
- uint32_t symbol_set_id = storage->symbol_table().size();
+ uint32_t symbol_set_id = storage->symbol_table().row_count();
storage->mutable_symbol_table()->Insert(
{symbol_set_id, storage->InternString("foo_func"),
storage->InternString("foo_file"), 66});
@@ -1159,7 +1159,7 @@
uint32_t frame_row_id_2 = storage->mutable_stack_profile_frames()->Insert(
{/*name_id=*/0, module_row_id_2, 0x4242});
- symbol_set_id = storage->symbol_table().size();
+ symbol_set_id = storage->symbol_table().row_count();
storage->mutable_symbol_table()->Insert(
{symbol_set_id, storage->InternString("bar_func"),
storage->InternString("bar_file"), 77});
diff --git a/src/trace_processor/heap_profile_tracker_unittest.cc b/src/trace_processor/heap_profile_tracker_unittest.cc
index ce978bf..f7c3734 100644
--- a/src/trace_processor/heap_profile_tracker_unittest.cc
+++ b/src/trace_processor/heap_profile_tracker_unittest.cc
@@ -185,7 +185,7 @@
int64_t parent,
int64_t frame_id) {
const auto& callsites = storage.stack_profile_callsite_table();
- for (uint32_t i = 0; i < callsites.size(); ++i) {
+ for (uint32_t i = 0; i < callsites.row_count(); ++i) {
if (callsites.depth()[i] == depth && callsites.parent_id()[i] == parent &&
callsites.frame_id()[i] == frame_id) {
return static_cast<int64_t>(i);
diff --git a/src/trace_processor/importers/proto/heap_graph_tracker.cc b/src/trace_processor/importers/proto/heap_graph_tracker.cc
index 930528d..03bba5d 100644
--- a/src/trace_processor/importers/proto/heap_graph_tracker.cc
+++ b/src/trace_processor/importers/proto/heap_graph_tracker.cc
@@ -117,7 +117,7 @@
/*reachable=*/0, /*type_name=*/type_name,
/*deobfuscated_type_name=*/base::nullopt,
/*root_type=*/base::nullopt});
- int64_t row = context_->storage->heap_graph_object_table().size() - 1;
+ int64_t row = context_->storage->heap_graph_object_table().row_count() - 1;
sequence_state.object_id_to_row.emplace(obj.object_id, row);
class_to_rows_[type_name].emplace_back(row);
sequence_state.walker.AddNode(row, obj.self_size);
@@ -130,7 +130,7 @@
int64_t owner_row = it->second;
int64_t reference_set_id =
- context_->storage->heap_graph_reference_table().size();
+ context_->storage->heap_graph_reference_table().row_count();
std::set<int64_t> seen_owned;
for (const SourceObject::Reference& ref : obj.references) {
// This is true for unset reference fields.
@@ -161,7 +161,8 @@
context_->storage->mutable_heap_graph_reference_table()->Insert(
{reference_set_id, owner_row, owned_row, field_name,
/*deobfuscated_field_name=*/base::nullopt});
- int64_t row = context_->storage->heap_graph_reference_table().size() - 1;
+ int64_t row =
+ context_->storage->heap_graph_reference_table().row_count() - 1;
field_to_rows_[field_name].emplace_back(row);
}
context_->storage->mutable_heap_graph_object_table()
diff --git a/src/trace_processor/importers/proto/proto_trace_parser.cc b/src/trace_processor/importers/proto/proto_trace_parser.cc
index c08b5e6..01c0156 100644
--- a/src/trace_processor/importers/proto/proto_trace_parser.cc
+++ b/src/trace_processor/importers/proto/proto_trace_parser.cc
@@ -623,7 +623,7 @@
for (auto addr_it = module_symbols.address_symbols(); addr_it; ++addr_it) {
protos::pbzero::AddressSymbols::Decoder address_symbols(*addr_it);
- uint32_t symbol_set_id = context_->storage->symbol_table().size();
+ uint32_t symbol_set_id = context_->storage->symbol_table().row_count();
bool frame_found = false;
for (int64_t mapping_row : mapping_rows) {
std::vector<int64_t> frame_rows =
diff --git a/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc b/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
index 8df34cd..4f76d24 100644
--- a/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
+++ b/src/trace_processor/importers/proto/proto_trace_parser_unittest.cc
@@ -613,7 +613,7 @@
DoubleEq(value * 1024.0), 0u));
Tokenize();
- EXPECT_EQ(context_.storage->track_table().size(), 1u);
+ EXPECT_EQ(context_.storage->track_table().row_count(), 1u);
}
TEST_F(ProtoTraceParserTest, LoadVmStats) {
@@ -630,7 +630,7 @@
PushCounter(static_cast<int64_t>(ts), DoubleEq(value), 0u));
Tokenize();
- EXPECT_EQ(context_.storage->track_table().size(), 1u);
+ EXPECT_EQ(context_.storage->track_table().row_count(), 1u);
}
TEST_F(ProtoTraceParserTest, LoadProcessPacket) {
@@ -1238,12 +1238,12 @@
context_.sorter->ExtractEventsForced();
// First track is for the thread; others are the async event tracks.
- EXPECT_EQ(storage_->track_table().size(), 4u);
+ EXPECT_EQ(storage_->track_table().row_count(), 4u);
EXPECT_EQ(storage_->track_table().name()[1], 2u);
EXPECT_EQ(storage_->track_table().name()[2], 4u);
EXPECT_EQ(storage_->track_table().name()[3], 4u);
- EXPECT_EQ(storage_->process_track_table().size(), 3u);
+ EXPECT_EQ(storage_->process_track_table().row_count(), 3u);
EXPECT_EQ(storage_->process_track_table().upid()[0], 1u);
EXPECT_EQ(storage_->process_track_table().upid()[1], 1u);
EXPECT_EQ(storage_->process_track_table().upid()[2], 1u);
@@ -1403,11 +1403,11 @@
// First track is "Thread track 1"; second is "Async track 1", third is
// "Thread track 2".
- EXPECT_EQ(storage_->track_table().size(), 3u);
+ EXPECT_EQ(storage_->track_table().row_count(), 3u);
EXPECT_EQ(storage_->track_table().name()[0], 10u); // "Thread track 1"
EXPECT_EQ(storage_->track_table().name()[1], 11u); // "Async track 1"
EXPECT_EQ(storage_->track_table().name()[2], 12u); // "Thread track 2"
- EXPECT_EQ(storage_->thread_track_table().size(), 2u);
+ EXPECT_EQ(storage_->thread_track_table().row_count(), 2u);
EXPECT_EQ(storage_->thread_track_table().utid()[0], 1u);
EXPECT_EQ(storage_->thread_track_table().utid()[1], 2u);
@@ -1440,8 +1440,8 @@
context_.sorter->ExtractEventsForced();
// Track tables shouldn't have changed.
- EXPECT_EQ(storage_->track_table().size(), 3u);
- EXPECT_EQ(storage_->thread_track_table().size(), 2u);
+ EXPECT_EQ(storage_->track_table().row_count(), 3u);
+ EXPECT_EQ(storage_->thread_track_table().row_count(), 2u);
EXPECT_EQ(storage_->virtual_track_slices().slice_count(), 1u);
EXPECT_EQ(storage_->virtual_track_slices().slice_ids()[0], 0u);
diff --git a/src/trace_processor/slice_tracker_unittest.cc b/src/trace_processor/slice_tracker_unittest.cc
index f4f3c64..386a15c 100644
--- a/src/trace_processor/slice_tracker_unittest.cc
+++ b/src/trace_processor/slice_tracker_unittest.cc
@@ -44,7 +44,7 @@
std::vector<SliceInfo> ToSliceInfo(const tables::SliceTable& slices) {
std::vector<SliceInfo> infos;
- for (uint32_t i = 0; i < slices.size(); i++) {
+ for (uint32_t i = 0; i < slices.row_count(); i++) {
infos.emplace_back(SliceInfo{slices.ts()[i], slices.dur()[i]});
}
return infos;
@@ -60,7 +60,7 @@
tracker.End(10 /*ts*/, track, 0 /*cat*/, 1 /*name*/);
const auto& slices = context.storage->slice_table();
- EXPECT_EQ(slices.size(), 1u);
+ EXPECT_EQ(slices.row_count(), 1u);
EXPECT_EQ(slices.ts()[0], 2);
EXPECT_EQ(slices.dur()[0], 8);
EXPECT_EQ(slices.track_id()[0], track);
@@ -88,7 +88,7 @@
});
const auto& slices = context.storage->slice_table();
- EXPECT_EQ(slices.size(), 1u);
+ EXPECT_EQ(slices.row_count(), 1u);
EXPECT_EQ(slices.ts()[0], 2);
EXPECT_EQ(slices.dur()[0], 8);
EXPECT_EQ(slices.track_id()[0], track);
@@ -121,7 +121,7 @@
const auto& slices = context.storage->slice_table();
- EXPECT_EQ(slices.size(), 2u);
+ EXPECT_EQ(slices.row_count(), 2u);
uint32_t idx = 0;
EXPECT_EQ(slices.ts()[idx], 2);
diff --git a/src/trace_processor/sqlite/db_sqlite_table.cc b/src/trace_processor/sqlite/db_sqlite_table.cc
index a531b92..6e0df8b 100644
--- a/src/trace_processor/sqlite/db_sqlite_table.cc
+++ b/src/trace_processor/sqlite/db_sqlite_table.cc
@@ -192,7 +192,7 @@
// end of filtering. Note that |current_row_count| should always be at least 1
// unless we are absolutely certain that we will return no rows as otherwise
// SQLite can make some bad choices.
- uint32_t current_row_count = table.size();
+ uint32_t current_row_count = table.row_count();
// If the table is empty, any constraint set only pays the fixed cost. Also we
// can return 0 as the row count as we are certain that we will return no
diff --git a/src/trace_processor/sqlite/db_sqlite_table_unittest.cc b/src/trace_processor/sqlite/db_sqlite_table_unittest.cc
index d88a046..4f39839 100644
--- a/src/trace_processor/sqlite/db_sqlite_table_unittest.cc
+++ b/src/trace_processor/sqlite/db_sqlite_table_unittest.cc
@@ -24,9 +24,9 @@
class TestTable : public Table {
public:
- TestTable(uint32_t size) : Table(&pool_, nullptr) {
- row_maps_.emplace_back(RowMap(0, size));
- size_ = size;
+ TestTable(uint32_t row_count) : Table(&pool_, nullptr) {
+ row_maps_.emplace_back(RowMap(0, row_count));
+ row_count_ = row_count;
columns_.emplace_back(Column::IdColumn(this, 0u, 0u));
columns_.emplace_back(
diff --git a/src/trace_processor/tables/macros_benchmark.cc b/src/trace_processor/tables/macros_benchmark.cc
index 12296fd..2e7bfbb 100644
--- a/src/trace_processor/tables/macros_benchmark.cc
+++ b/src/trace_processor/tables/macros_benchmark.cc
@@ -136,7 +136,7 @@
for (auto _ : state) {
benchmark::DoNotOptimize(root.Filter(
- {root.id().eq(root.size() - 1), root.root_non_null().gt(100)}));
+ {root.id().eq(root.row_count() - 1), root.root_non_null().gt(100)}));
}
}
BENCHMARK(BM_TableFilterRootIdAndOther)->Apply(TableFilterArgs);
diff --git a/src/trace_processor/tables/macros_internal.h b/src/trace_processor/tables/macros_internal.h
index 1f65ec7..ff172e7 100644
--- a/src/trace_processor/tables/macros_internal.h
+++ b/src/trace_processor/tables/macros_internal.h
@@ -76,7 +76,7 @@
}
// Also add the index of the new row to the identity row map and increment
// the size.
- row_maps_.back().Insert(size_++);
+ row_maps_.back().Insert(row_count_++);
}
// Stores the most specific "derived" type of this row in the table.
@@ -267,7 +267,7 @@
uint32_t Insert(const Row& row) { \
uint32_t id; \
if (parent_ == nullptr) { \
- id = size(); \
+ id = row_count(); \
type_.Append(string_pool_->InternString(row.type())); \
} else { \
id = parent_->Insert(row); \
diff --git a/src/trace_processor/tables/macros_unittest.cc b/src/trace_processor/tables/macros_unittest.cc
index 46e03da..c7c7e82 100644
--- a/src/trace_processor/tables/macros_unittest.cc
+++ b/src/trace_processor/tables/macros_unittest.cc
@@ -144,47 +144,47 @@
Table out = slice_.Filter({slice_.dur().is_null()});
const auto* dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(dur->Get(0).type, SqlValue::kNull);
ASSERT_EQ(dur->Get(1).type, SqlValue::kNull);
out = slice_.Filter({slice_.dur().is_not_null()});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 3u);
+ ASSERT_EQ(out.row_count(), 3u);
ASSERT_EQ(dur->Get(0).long_value, 100);
ASSERT_EQ(dur->Get(1).long_value, 101);
ASSERT_EQ(dur->Get(2).long_value, 200);
out = slice_.Filter({slice_.dur().lt(101)});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(dur->Get(0).long_value, 100);
out = slice_.Filter({slice_.dur().eq(101)});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(dur->Get(0).long_value, 101);
out = slice_.Filter({slice_.dur().gt(101)});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(dur->Get(0).long_value, 200);
out = slice_.Filter({slice_.dur().ne(100)});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(dur->Get(0).long_value, 101);
ASSERT_EQ(dur->Get(1).long_value, 200);
out = slice_.Filter({slice_.dur().le(101)});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(dur->Get(0).long_value, 100);
ASSERT_EQ(dur->Get(1).long_value, 101);
out = slice_.Filter({slice_.dur().ge(101)});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(dur->Get(0).long_value, 101);
ASSERT_EQ(dur->Get(1).long_value, 200);
}
@@ -204,24 +204,24 @@
Table out = slice_.Filter({slice_.dur().eq_value(SqlValue::Double(100.0))});
const Column* dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(dur->Get(0).long_value, 100);
out = slice_.Filter({slice_.dur().le_value(SqlValue::Double(99.9999))});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(dur->Get(0).long_value, std::numeric_limits<int64_t>::min());
out = slice_.Filter({slice_.dur().ge_value(SqlValue::Double(99.9999))});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(dur->Get(0).long_value, 100);
ASSERT_EQ(dur->Get(1).long_value, std::numeric_limits<int64_t>::max());
out = slice_.Filter({slice_.dur().eq_value(
SqlValue::Double(std::numeric_limits<int64_t>::min()))});
dur = out.GetColumnByName("dur");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(dur->Get(0).long_value, std::numeric_limits<int64_t>::min());
}
@@ -241,10 +241,10 @@
slice_.Insert({});
Table out = slice_.Filter({slice_.dur().ne_value(SqlValue())});
- ASSERT_EQ(out.size(), 0u);
+ ASSERT_EQ(out.row_count(), 0u);
out = slice_.Filter({slice_.dur().eq_value(SqlValue::String("100"))});
- ASSERT_EQ(out.size(), 0u);
+ ASSERT_EQ(out.row_count(), 0u);
}
TEST_F(TableMacrosUnittest, NullableDoubleComparision) {
@@ -264,47 +264,47 @@
Table out = counter_.Filter({counter_.value().is_null()});
const auto* value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(value->Get(0).type, SqlValue::kNull);
ASSERT_EQ(value->Get(1).type, SqlValue::kNull);
out = counter_.Filter({counter_.value().is_not_null()});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 3u);
+ ASSERT_EQ(out.row_count(), 3u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 100);
ASSERT_DOUBLE_EQ(value->Get(1).double_value, 101);
ASSERT_DOUBLE_EQ(value->Get(2).double_value, 200);
out = counter_.Filter({counter_.value().lt(101)});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 100);
out = counter_.Filter({counter_.value().eq(101)});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 101);
out = counter_.Filter({counter_.value().gt(101)});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 200);
out = counter_.Filter({counter_.value().ne(100)});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 101);
ASSERT_DOUBLE_EQ(value->Get(1).double_value, 200);
out = counter_.Filter({counter_.value().le(101)});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 100);
ASSERT_DOUBLE_EQ(value->Get(1).double_value, 101);
out = counter_.Filter({counter_.value().ge(101)});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 101);
ASSERT_DOUBLE_EQ(value->Get(1).double_value, 200);
}
@@ -324,12 +324,12 @@
Table out = counter_.Filter({counter_.value().eq_value(SqlValue::Long(100))});
const Column* value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 100.0);
out = counter_.Filter({counter_.value().lt_value(SqlValue::Long(100))});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value, 99.9999);
ASSERT_DOUBLE_EQ(value->Get(1).double_value,
std::numeric_limits<int64_t>::min());
@@ -337,7 +337,7 @@
out = counter_.Filter({counter_.value().eq_value(
SqlValue::Long(std::numeric_limits<int64_t>::min()))});
value = out.GetColumnByName("value");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_DOUBLE_EQ(value->Get(0).double_value,
std::numeric_limits<int64_t>::min());
}
@@ -356,45 +356,45 @@
Table out = cpu_slice_.Filter({cpu_slice_.end_state().is_null()});
const auto* end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_EQ(end_state->Get(0).type, SqlValue::kNull);
ASSERT_EQ(end_state->Get(1).type, SqlValue::kNull);
out = cpu_slice_.Filter({cpu_slice_.end_state().is_not_null()});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_STREQ(end_state->Get(0).string_value, "R");
ASSERT_STREQ(end_state->Get(1).string_value, "D");
out = cpu_slice_.Filter({cpu_slice_.end_state().lt("R")});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_STREQ(end_state->Get(0).string_value, "D");
out = cpu_slice_.Filter({cpu_slice_.end_state().eq("D")});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_STREQ(end_state->Get(0).string_value, "D");
out = cpu_slice_.Filter({cpu_slice_.end_state().gt("D")});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_STREQ(end_state->Get(0).string_value, "R");
out = cpu_slice_.Filter({cpu_slice_.end_state().ne("D")});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_STREQ(end_state->Get(0).string_value, "R");
out = cpu_slice_.Filter({cpu_slice_.end_state().le("R")});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_STREQ(end_state->Get(0).string_value, "R");
ASSERT_STREQ(end_state->Get(1).string_value, "D");
out = cpu_slice_.Filter({cpu_slice_.end_state().ge("D")});
end_state = out.GetColumnByName("end_state");
- ASSERT_EQ(out.size(), 2u);
+ ASSERT_EQ(out.row_count(), 2u);
ASSERT_STREQ(end_state->Get(0).string_value, "R");
ASSERT_STREQ(end_state->Get(1).string_value, "D");
}
@@ -414,7 +414,7 @@
const auto* end_state = out.GetColumnByName("end_state");
const auto* cpu = out.GetColumnByName("cpu");
- ASSERT_EQ(out.size(), 1u);
+ ASSERT_EQ(out.row_count(), 1u);
ASSERT_EQ(cpu->Get(0).long_value, 1u);
ASSERT_STREQ(end_state->Get(0).string_value, "D");
}
