tp: Rename Column to ColumnLegacy to prepare for deprecation
Change-Id: I539f7451e4a86d64ce8dfc93c082e79ffc30870b
diff --git a/python/generators/trace_processor_table/serialize.py b/python/generators/trace_processor_table/serialize.py
index e9629d7..cecaf4d 100644
--- a/python/generators/trace_processor_table/serialize.py
+++ b/python/generators/trace_processor_table/serialize.py
@@ -216,7 +216,7 @@
return None
return f'''
static_assert(
- Column::IsFlagsAndTypeValid<ColumnType::{self.name}::stored_type>(
+ ColumnLegacy::IsFlagsAndTypeValid<ColumnType::{self.name}::stored_type>(
ColumnFlag::{self.name}),
"Column type and flag combination is not valid");
'''
@@ -633,11 +633,11 @@
assert raw_flag != ColumnFlag.NONE
flags = []
if ColumnFlag.SORTED in raw_flag:
- flags.append('Column::Flag::kSorted')
+ flags.append('ColumnLegacy::Flag::kSorted')
if ColumnFlag.HIDDEN in raw_flag:
- flags.append('Column::Flag::kHidden')
+ flags.append('ColumnLegacy::Flag::kHidden')
if ColumnFlag.DENSE in raw_flag:
- flags.append('Column::Flag::kDense')
+ flags.append('ColumnLegacy::Flag::kDense')
if ColumnFlag.SET_ID in raw_flag:
- flags.append('Column::Flag::kSetId')
+ flags.append('ColumnLegacy::Flag::kSetId')
return ' | '.join(flags)
diff --git a/src/trace_processor/db/column.cc b/src/trace_processor/db/column.cc
index 847a721..7d108e1 100644
--- a/src/trace_processor/db/column.cc
+++ b/src/trace_processor/db/column.cc
@@ -25,26 +25,26 @@
namespace perfetto {
namespace trace_processor {
-Column::Column(const Column& column,
- Table* table,
- uint32_t col_idx,
- uint32_t overlay_idx,
- const char* name)
- : Column(name ? name : column.name_,
- column.type_,
- column.flags_ & ~kNoCrossTableInheritFlags,
- table,
- col_idx,
- overlay_idx,
- column.storage_) {}
+ColumnLegacy::ColumnLegacy(const ColumnLegacy& column,
+ Table* table,
+ uint32_t col_idx,
+ uint32_t overlay_idx,
+ const char* name)
+ : ColumnLegacy(name ? name : column.name_,
+ column.type_,
+ column.flags_ & ~kNoCrossTableInheritFlags,
+ table,
+ col_idx,
+ overlay_idx,
+ column.storage_) {}
-Column::Column(const char* name,
- ColumnType type,
- uint32_t flags,
- Table* table,
- uint32_t index_in_table,
- uint32_t overlay_index,
- ColumnStorageBase* st)
+ColumnLegacy::ColumnLegacy(const char* name,
+ ColumnType type,
+ uint32_t flags,
+ Table* table,
+ uint32_t index_in_table,
+ uint32_t overlay_index,
+ ColumnStorageBase* st)
: type_(type),
storage_(st),
name_(name),
@@ -81,24 +81,24 @@
PERFETTO_DCHECK(IsFlagsAndTypeValid(flags_, type_));
}
-Column Column::DummyColumn(const char* name,
- Table* table,
- uint32_t col_idx_in_table) {
- return Column(name, ColumnType::kDummy, Flag::kNoFlag, table,
- col_idx_in_table, std::numeric_limits<uint32_t>::max(),
- nullptr);
+ColumnLegacy ColumnLegacy::DummyColumn(const char* name,
+ Table* table,
+ uint32_t col_idx_in_table) {
+ return ColumnLegacy(name, ColumnType::kDummy, Flag::kNoFlag, table,
+ col_idx_in_table, std::numeric_limits<uint32_t>::max(),
+ nullptr);
}
-Column Column::IdColumn(Table* table,
- uint32_t col_idx,
- uint32_t overlay_idx,
- const char* name,
- uint32_t flags) {
- return Column(name, ColumnType::kId, flags, table, col_idx, overlay_idx,
- nullptr);
+ColumnLegacy ColumnLegacy::IdColumn(Table* table,
+ uint32_t col_idx,
+ uint32_t overlay_idx,
+ const char* name,
+ uint32_t flags) {
+ return ColumnLegacy(name, ColumnType::kId, flags, table, col_idx, overlay_idx,
+ nullptr);
}
-void Column::StableSort(bool desc, std::vector<uint32_t>* idx) const {
+void ColumnLegacy::StableSort(bool desc, std::vector<uint32_t>* idx) const {
if (desc) {
StableSort<true /* desc */>(idx);
} else {
@@ -106,7 +106,9 @@
}
}
-void Column::FilterIntoSlow(FilterOp op, SqlValue value, RowMap* rm) const {
+void ColumnLegacy::FilterIntoSlow(FilterOp op,
+ SqlValue value,
+ RowMap* rm) const {
switch (type_) {
case ColumnType::kInt32: {
if (IsNullable()) {
@@ -154,9 +156,9 @@
}
template <typename T, bool is_nullable>
-void Column::FilterIntoNumericSlow(FilterOp op,
- SqlValue value,
- RowMap* rm) const {
+void ColumnLegacy::FilterIntoNumericSlow(FilterOp op,
+ SqlValue value,
+ RowMap* rm) const {
PERFETTO_DCHECK(IsNullable() == is_nullable);
PERFETTO_DCHECK(type_ == ColumnTypeHelper<T>::ToColumnType());
PERFETTO_DCHECK(std::is_arithmetic<T>::value);
@@ -226,9 +228,9 @@
}
template <typename T, bool is_nullable, typename Comparator>
-void Column::FilterIntoNumericWithComparatorSlow(FilterOp op,
- RowMap* rm,
- Comparator cmp) const {
+void ColumnLegacy::FilterIntoNumericWithComparatorSlow(FilterOp op,
+ RowMap* rm,
+ Comparator cmp) const {
switch (op) {
case FilterOp::kLt:
overlay().FilterInto(rm, [this, &cmp](uint32_t idx) {
@@ -294,9 +296,9 @@
}
}
-void Column::FilterIntoStringSlow(FilterOp op,
- SqlValue value,
- RowMap* rm) const {
+void ColumnLegacy::FilterIntoStringSlow(FilterOp op,
+ SqlValue value,
+ RowMap* rm) const {
PERFETTO_DCHECK(type_ == ColumnType::kString);
if (op == FilterOp::kIsNull) {
@@ -388,7 +390,9 @@
}
}
-void Column::FilterIntoIdSlow(FilterOp op, SqlValue value, RowMap* rm) const {
+void ColumnLegacy::FilterIntoIdSlow(FilterOp op,
+ SqlValue value,
+ RowMap* rm) const {
PERFETTO_DCHECK(type_ == ColumnType::kId);
if (op == FilterOp::kIsNull) {
@@ -448,7 +452,7 @@
}
template <bool desc>
-void Column::StableSort(std::vector<uint32_t>* out) const {
+void ColumnLegacy::StableSort(std::vector<uint32_t>* out) const {
switch (type_) {
case ColumnType::kInt32: {
if (IsNullable()) {
@@ -504,7 +508,7 @@
}
template <bool desc, typename T, bool is_nullable>
-void Column::StableSortNumeric(std::vector<uint32_t>* out) const {
+void ColumnLegacy::StableSortNumeric(std::vector<uint32_t>* out) const {
PERFETTO_DCHECK(IsNullable() == is_nullable);
PERFETTO_DCHECK(ColumnTypeHelper<T>::ToColumnType() == type_);
@@ -524,7 +528,7 @@
});
}
-const ColumnStorageOverlay& Column::overlay() const {
+const ColumnStorageOverlay& ColumnLegacy::overlay() const {
PERFETTO_DCHECK(type_ != ColumnType::kDummy);
return table_->overlays_[overlay_index()];
}
diff --git a/src/trace_processor/db/column.h b/src/trace_processor/db/column.h
index e660046..87752f3 100644
--- a/src/trace_processor/db/column.h
+++ b/src/trace_processor/db/column.h
@@ -62,7 +62,7 @@
class Table;
// Represents a named, strongly typed list of data.
-class Column {
+class ColumnLegacy {
public:
// Flags which indicate properties of the data in the column. These features
// are used to speed up column methods like filtering/sorting.
@@ -134,7 +134,7 @@
using pointer = uint32_t*;
using reference = uint32_t&;
- Iterator(const Column* col, uint32_t row) : col_(col), row_(row) {}
+ Iterator(const ColumnLegacy* col, uint32_t row) : col_(col), row_(row) {}
Iterator(const Iterator&) = default;
Iterator& operator=(const Iterator&) = default;
@@ -167,7 +167,7 @@
uint32_t row() const { return row_; }
private:
- const Column* col_ = nullptr;
+ const ColumnLegacy* col_ = nullptr;
uint32_t row_ = 0;
};
@@ -176,46 +176,47 @@
// Flags which should *not* be inherited implicitly when a column is
// assocaited to another table.
- static constexpr uint32_t kNoCrossTableInheritFlags = Column::Flag::kSetId;
+ static constexpr uint32_t kNoCrossTableInheritFlags =
+ ColumnLegacy::Flag::kSetId;
template <typename T>
- Column(const char* name,
- ColumnStorage<T>* storage,
- /* Flag */ uint32_t flags,
- Table* table,
- uint32_t col_idx_in_table,
- uint32_t row_map_idx)
- : Column(name,
- ColumnTypeHelper<stored_type<T>>::ToColumnType(),
- flags,
- table,
- col_idx_in_table,
- row_map_idx,
- storage) {}
+ ColumnLegacy(const char* name,
+ ColumnStorage<T>* storage,
+ /* Flag */ uint32_t flags,
+ Table* table,
+ uint32_t col_idx_in_table,
+ uint32_t row_map_idx)
+ : ColumnLegacy(name,
+ ColumnTypeHelper<stored_type<T>>::ToColumnType(),
+ flags,
+ table,
+ col_idx_in_table,
+ row_map_idx,
+ storage) {}
// Create a Column backed by the same data as |column| but is associated to a
// different table and, optionally, having a different name.
- Column(const Column& column,
- Table* table,
- uint32_t col_idx_in_table,
- uint32_t row_map_idx,
- const char* name = nullptr);
+ ColumnLegacy(const ColumnLegacy& column,
+ Table* table,
+ uint32_t col_idx_in_table,
+ uint32_t row_map_idx,
+ const char* name = nullptr);
// Columns are movable but not copyable.
- Column(Column&&) noexcept = default;
- Column& operator=(Column&&) = default;
+ ColumnLegacy(ColumnLegacy&&) noexcept = default;
+ ColumnLegacy& operator=(ColumnLegacy&&) = default;
// Creates a Column which does not have any data backing it.
- static Column DummyColumn(const char* name,
- Table* table,
- uint32_t col_idx_in_table);
+ static ColumnLegacy DummyColumn(const char* name,
+ Table* table,
+ uint32_t col_idx_in_table);
// Creates a Column which returns the index as the value of the row.
- static Column IdColumn(Table* table,
- uint32_t col_idx_in_table,
- uint32_t row_map_idx,
- const char* name = "id",
- uint32_t flags = kIdFlags);
+ static ColumnLegacy IdColumn(Table* table,
+ uint32_t col_idx_in_table,
+ uint32_t row_map_idx,
+ const char* name = "id",
+ uint32_t flags = kIdFlags);
// Gets the value of the Column at the given |row|.
SqlValue Get(uint32_t row) const { return GetAtIdx(overlay().Get(row)); }
@@ -459,16 +460,16 @@
friend class View;
// Base constructor for this class which all other constructors call into.
- Column(const char* name,
- ColumnType type,
- uint32_t flags,
- Table* table,
- uint32_t col_idx_in_table,
- uint32_t overlay_index,
- ColumnStorageBase* nullable_vector);
+ ColumnLegacy(const char* name,
+ ColumnType type,
+ uint32_t flags,
+ Table* table,
+ uint32_t col_idx_in_table,
+ uint32_t overlay_index,
+ ColumnStorageBase* nullable_vector);
- Column(const Column&) = delete;
- Column& operator=(const Column&) = delete;
+ ColumnLegacy(const ColumnLegacy&) = delete;
+ ColumnLegacy& operator=(const ColumnLegacy&) = delete;
// Gets the value of the Column at the given |idx|.
SqlValue GetAtIdx(uint32_t idx) const {
diff --git a/src/trace_processor/db/query_executor.cc b/src/trace_processor/db/query_executor.cc
index c0c6501..46b02d1 100644
--- a/src/trace_processor/db/query_executor.cc
+++ b/src/trace_processor/db/query_executor.cc
@@ -162,7 +162,7 @@
if (rm.empty()) {
return rm;
}
- const Column& col = table->columns()[c.col_idx];
+ const ColumnLegacy& col = table->columns()[c.col_idx];
uint32_t column_size =
col.IsId() ? col.overlay().row_map().Max() : col.storage_base().size();
diff --git a/src/trace_processor/db/runtime_table.cc b/src/trace_processor/db/runtime_table.cc
index 0cca70f..6f3cd54 100644
--- a/src/trace_processor/db/runtime_table.cc
+++ b/src/trace_processor/db/runtime_table.cc
@@ -162,20 +162,22 @@
auto* non_null_ints = std::get_if<IntStorage>(col);
bool is_sorted = std::is_sorted(non_null_ints->vector().begin(),
non_null_ints->vector().end());
- uint32_t flags = is_sorted
- ? Column::Flag::kNonNull | Column::Flag::kSorted
- : Column::Flag::kNonNull;
- columns_.push_back(
- Column(col_names_[i].c_str(), non_null_ints, flags, this, i, 0));
+ uint32_t flags = is_sorted ? ColumnLegacy::Flag::kNonNull |
+ ColumnLegacy::Flag::kSorted
+ : ColumnLegacy::Flag::kNonNull;
+ columns_.push_back(ColumnLegacy(col_names_[i].c_str(), non_null_ints,
+ flags, this, i, 0));
} else {
- columns_.push_back(Column(col_names_[i].c_str(), ints,
- Column::Flag::kNoFlag, this, i, 0));
+ columns_.push_back(ColumnLegacy(col_names_[i].c_str(), ints,
+ ColumnLegacy::Flag::kNoFlag, this, i,
+ 0));
}
} else if (auto* strings = std::get_if<StringStorage>(col)) {
PERFETTO_CHECK(strings->size() == rows);
- columns_.push_back(Column(col_names_[i].c_str(), strings,
- Column::Flag::kNonNull, this, i, 0));
+ columns_.push_back(ColumnLegacy(col_names_[i].c_str(), strings,
+ ColumnLegacy::Flag::kNonNull, this, i,
+ 0));
} else if (auto* doubles = std::get_if<NullDoubleStorage>(col)) {
PERFETTO_CHECK(doubles->size() == rows);
// Check if the column is nullable.
@@ -185,23 +187,24 @@
auto* non_null_doubles = std::get_if<DoubleStorage>(col);
bool is_sorted = std::is_sorted(non_null_doubles->vector().begin(),
non_null_doubles->vector().end());
- uint32_t flags = is_sorted
- ? Column::Flag::kNonNull | Column::Flag::kSorted
- : Column::Flag::kNonNull;
+ uint32_t flags = is_sorted ? ColumnLegacy::Flag::kNonNull |
+ ColumnLegacy::Flag::kSorted
+ : ColumnLegacy::Flag::kNonNull;
- columns_.push_back(
- Column(col_names_[i].c_str(), non_null_doubles, flags, this, i, 0));
+ columns_.push_back(ColumnLegacy(col_names_[i].c_str(), non_null_doubles,
+ flags, this, i, 0));
} else {
- columns_.push_back(Column(col_names_[i].c_str(), doubles,
- Column::Flag::kNoFlag, this, i, 0));
+ columns_.push_back(ColumnLegacy(col_names_[i].c_str(), doubles,
+ ColumnLegacy::Flag::kNoFlag, this, i,
+ 0));
}
} else {
PERFETTO_FATAL("Unexpected column type");
}
}
- columns_.push_back(
- Column::IdColumn(this, static_cast<uint32_t>(col_names_.size()), 0,
- "_auto_id", Column::kIdFlags | Column::Flag::kHidden));
+ columns_.push_back(ColumnLegacy::IdColumn(
+ this, static_cast<uint32_t>(col_names_.size()), 0, "_auto_id",
+ ColumnLegacy::kIdFlags | ColumnLegacy::Flag::kHidden));
row_count_ = rows;
return base::OkStatus();
}
diff --git a/src/trace_processor/db/table.cc b/src/trace_processor/db/table.cc
index 0fbc23f..5177199 100644
--- a/src/trace_processor/db/table.cc
+++ b/src/trace_processor/db/table.cc
@@ -32,7 +32,7 @@
overlays_ = std::move(other.overlays_);
columns_ = std::move(other.columns_);
- for (Column& col : columns_) {
+ for (ColumnLegacy& col : columns_) {
col.table_ = this;
}
return *this;
@@ -49,7 +49,7 @@
Table Table::CopyExceptOverlays() const {
Table table(string_pool_);
table.row_count_ = row_count_;
- for (const Column& col : columns_) {
+ for (const ColumnLegacy& col : columns_) {
table.columns_.emplace_back(col, &table, col.index_in_table(),
col.overlay_index());
}
@@ -124,14 +124,14 @@
// Remove the sorted and row set flags from all the columns.
for (auto& col : table.columns_) {
- col.flags_ &= ~Column::Flag::kSorted;
- col.flags_ &= ~Column::Flag::kSetId;
+ col.flags_ &= ~ColumnLegacy::Flag::kSorted;
+ col.flags_ &= ~ColumnLegacy::Flag::kSetId;
}
// For the first order by, make the column flag itself as sorted but
// only if the sort was in ascending order.
if (!od.front().desc) {
- table.columns_[od.front().col_idx].flags_ |= Column::Flag::kSorted;
+ table.columns_[od.front().col_idx].flags_ |= ColumnLegacy::Flag::kSorted;
}
return table;
diff --git a/src/trace_processor/db/table.h b/src/trace_processor/db/table.h
index e9b83a5..2f0c91c 100644
--- a/src/trace_processor/db/table.h
+++ b/src/trace_processor/db/table.h
@@ -152,7 +152,7 @@
// Pretty much any application of a RowMap will break the requirements on
// kSetId so remove it.
for (auto& col : table.columns_) {
- col.flags_ &= ~Column::Flag::kSetId;
+ col.flags_ &= ~ColumnLegacy::Flag::kSetId;
}
return table;
}
@@ -161,20 +161,21 @@
Table Sort(const std::vector<Order>& od) const;
// Returns the column at index |idx| in the Table.
- const Column& GetColumn(uint32_t idx) const { return columns_[idx]; }
+ const ColumnLegacy& GetColumn(uint32_t idx) const { return columns_[idx]; }
// Returns the column index with the given name or std::nullopt otherwise.
std::optional<uint32_t> GetColumnIndexByName(const char* name) const {
- auto it = std::find_if(
- columns_.begin(), columns_.end(),
- [name](const Column& col) { return strcmp(col.name(), name) == 0; });
+ auto it = std::find_if(columns_.begin(), columns_.end(),
+ [name](const ColumnLegacy& col) {
+ return strcmp(col.name(), name) == 0;
+ });
if (it == columns_.end())
return std::nullopt;
return static_cast<uint32_t>(std::distance(columns_.begin(), it));
}
// Returns the column with the given name or nullptr otherwise.
- const Column* GetColumnByName(const char* name) const {
+ const ColumnLegacy* GetColumnByName(const char* name) const {
std::optional<uint32_t> opt_idx = GetColumnIndexByName(name);
if (!opt_idx)
return nullptr;
@@ -219,7 +220,7 @@
const std::vector<ColumnStorageOverlay>& overlays() const {
return overlays_;
}
- const std::vector<Column>& columns() const { return columns_; }
+ const std::vector<ColumnLegacy>& columns() const { return columns_; }
protected:
explicit Table(StringPool* pool);
@@ -233,13 +234,13 @@
}
std::vector<ColumnStorageOverlay> overlays_;
- std::vector<Column> columns_;
+ std::vector<ColumnLegacy> columns_;
uint32_t row_count_ = 0;
StringPool* string_pool_ = nullptr;
private:
- friend class Column;
+ friend class ColumnLegacy;
friend class View;
Table CopyExceptOverlays() const;
diff --git a/src/trace_processor/db/typed_column.h b/src/trace_processor/db/typed_column.h
index d0bc19b..3afcc38 100644
--- a/src/trace_processor/db/typed_column.h
+++ b/src/trace_processor/db/typed_column.h
@@ -48,7 +48,7 @@
// different based on T. See their class documentation and below for details
// on their purpose.
template <typename T>
-class TypedColumn : public Column {
+class TypedColumn : public ColumnLegacy {
private:
using TH = tc_internal::TypeHandler<T>;
@@ -92,7 +92,7 @@
// Returns the row containing the given value in the Column.
std::optional<uint32_t> IndexOf(sql_value_type v) const {
- return Column::IndexOf(ToSqlValue(v));
+ return ColumnLegacy::IndexOf(ToSqlValue(v));
}
std::vector<T> ToVectorForTesting() const {
@@ -124,16 +124,16 @@
// Converts the static type T into the dynamic SqlValue type of this column.
static SqlValue::Type SqlValueType() {
- return Column::ToSqlValueType<stored_type>();
+ return ColumnLegacy::ToSqlValueType<stored_type>();
}
// Cast a Column to TypedColumn or crash if that is unsafe.
- static TypedColumn<T>* FromColumn(Column* column) {
+ static TypedColumn<T>* FromColumn(ColumnLegacy* column) {
return FromColumnInternal<TypedColumn<T>>(column);
}
// Cast a Column to TypedColumn or crash if that is unsafe.
- static const TypedColumn<T>* FromColumn(const Column* column) {
+ static const TypedColumn<T>* FromColumn(const ColumnLegacy* column) {
return FromColumnInternal<const TypedColumn<T>>(column);
}
@@ -162,7 +162,7 @@
// While casting from a base to derived without constructing as a derived is
// technically UB, in practice, this is at the heart of protozero (see
// Message::BeginNestedMessage) so we use it here.
- static_assert(sizeof(TypedColumn<T>) == sizeof(Column),
+ static_assert(sizeof(TypedColumn<T>) == sizeof(ColumnLegacy),
"TypedColumn cannot introduce extra state.");
if (column->template IsColumnType<stored_type>() &&
@@ -175,16 +175,16 @@
}
const ColumnStorage<stored_type>& storage() const {
- return Column::storage<stored_type>();
+ return ColumnLegacy::storage<stored_type>();
}
ColumnStorage<stored_type>* mutable_storage() {
- return Column::mutable_storage<stored_type>();
+ return ColumnLegacy::mutable_storage<stored_type>();
}
};
// Represents a column containing ids.
template <typename Id>
-class IdColumn : public Column {
+class IdColumn : public ColumnLegacy {
public:
// The type of the data in this column.
using type = Id;
@@ -203,11 +203,11 @@
// Static cast a Column to IdColumn or crash if that is likely to be
// unsafe.
- static const IdColumn<Id>* FromColumn(const Column* column) {
+ static const IdColumn<Id>* FromColumn(const ColumnLegacy* column) {
// While casting from a base to derived without constructing as a derived is
// technically UB, in practice, this is at the heart of protozero (see
// Message::BeginNestedMessage) so we use it here.
- static_assert(sizeof(IdColumn<Id>) == sizeof(Column),
+ static_assert(sizeof(IdColumn<Id>) == sizeof(ColumnLegacy),
"TypedColumn cannot introduce extra state.");
if (column->IsId()) {
diff --git a/src/trace_processor/db/view.cc b/src/trace_processor/db/view.cc
index 5b462c7..ba05104 100644
--- a/src/trace_processor/db/view.cc
+++ b/src/trace_processor/db/view.cc
@@ -148,7 +148,7 @@
uint32_t table_col_idx =
*node->table->GetColumnIndexByName(col.source_col_name);
- const Column& table_col = node->table->GetColumn(table_col_idx);
+ const ColumnLegacy& table_col = node->table->GetColumn(table_col_idx);
PERFETTO_DCHECK(!table_col.IsHidden());
// TODO(lalitm): if the view specifies the right hand side table as
@@ -418,14 +418,14 @@
const char* col_name = schema.columns[it.index()].name.c_str();
if (!it.IsSet()) {
output.columns_.emplace_back(
- Column::DummyColumn(col_name, &output, it.index()));
+ ColumnLegacy::DummyColumn(col_name, &output, it.index()));
continue;
}
const auto& source_col = source_col_by_output_idx[it.index()];
Table& node_table = state_.Find(source_col.first)->output;
- const Column& table_col = node_table.GetColumn(source_col.second);
+ const ColumnLegacy& table_col = node_table.GetColumn(source_col.second);
auto it_and_inserted = cached_rm.emplace(
std::make_pair(source_col.first, table_col.overlay_index()),
@@ -437,7 +437,7 @@
uint32_t rm_idx = it_and_inserted.first->second;
output.columns_.emplace_back(
- Column(table_col, &output, it.index(), rm_idx, col_name));
+ ColumnLegacy(table_col, &output, it.index(), rm_idx, col_name));
}
return output;
}
diff --git a/src/trace_processor/importers/common/args_tracker.cc b/src/trace_processor/importers/common/args_tracker.cc
index 69eca73..1ead9d3 100644
--- a/src/trace_processor/importers/common/args_tracker.cc
+++ b/src/trace_processor/importers/common/args_tracker.cc
@@ -29,7 +29,7 @@
Flush();
}
-void ArgsTracker::AddArg(Column* arg_set_id,
+void ArgsTracker::AddArg(ColumnLegacy* arg_set_id,
uint32_t row,
StringId flat_key,
StringId key,
@@ -93,7 +93,7 @@
}
ArgsTracker::CompactArgSet ArgsTracker::ToCompactArgSet(
- const Column& column,
+ const ColumnLegacy& column,
uint32_t row_number) && {
CompactArgSet compact_args;
for (const auto& arg : args_) {
@@ -113,7 +113,7 @@
}
ArgsTracker::BoundInserter::BoundInserter(ArgsTracker* args_tracker,
- Column* arg_set_id_column,
+ ColumnLegacy* arg_set_id_column,
uint32_t row)
: args_tracker_(args_tracker),
arg_set_id_column_(arg_set_id_column),
diff --git a/src/trace_processor/importers/common/args_tracker.h b/src/trace_processor/importers/common/args_tracker.h
index 2a3a8b5..a83e5ef 100644
--- a/src/trace_processor/importers/common/args_tracker.h
+++ b/src/trace_processor/importers/common/args_tracker.h
@@ -82,14 +82,14 @@
protected:
BoundInserter(ArgsTracker* args_tracker,
- Column* arg_set_id_column,
+ ColumnLegacy* arg_set_id_column,
uint32_t row);
private:
friend class ArgsTracker;
ArgsTracker* args_tracker_ = nullptr;
- Column* arg_set_id_column_ = nullptr;
+ ColumnLegacy* arg_set_id_column_ = nullptr;
uint32_t row_ = 0;
};
@@ -180,7 +180,8 @@
// Note that this means the args stored in this tracker will *not* be flushed
// into the tables: it is the callers responsibility to ensure this happens if
// necessary.
- CompactArgSet ToCompactArgSet(const Column& column, uint32_t row_number) &&;
+ CompactArgSet ToCompactArgSet(const ColumnLegacy& column,
+ uint32_t row_number) &&;
// Returns whether this ArgsTracker contains any arg which require translation
// according to the provided |table|.
@@ -197,7 +198,7 @@
return BoundInserter(this, table->mutable_arg_set_id(), row);
}
- void AddArg(Column* arg_set_id,
+ void AddArg(ColumnLegacy* arg_set_id,
uint32_t row,
StringId flat_key,
StringId key,
@@ -207,8 +208,8 @@
base::SmallVector<GlobalArgsTracker::Arg, 16> args_;
TraceProcessorContext* context_ = nullptr;
- using ArrayKeyTuple =
- std::tuple<Column* /*arg_set_id*/, uint32_t /*row*/, StringId /*key*/>;
+ using ArrayKeyTuple = std::
+ tuple<ColumnLegacy* /*arg_set_id*/, uint32_t /*row*/, StringId /*key*/>;
std::map<ArrayKeyTuple, size_t /*next_index*/> array_indexes_;
};
diff --git a/src/trace_processor/importers/common/global_args_tracker.h b/src/trace_processor/importers/common/global_args_tracker.h
index 3f04105..47e3bbd 100644
--- a/src/trace_processor/importers/common/global_args_tracker.h
+++ b/src/trace_processor/importers/common/global_args_tracker.h
@@ -48,7 +48,7 @@
"Args must be trivially destructible");
struct Arg : public CompactArg {
- Column* column;
+ ColumnLegacy* column;
uint32_t row;
// Object slices this Arg to become a CompactArg.
diff --git a/src/trace_processor/perfetto_sql/intrinsics/table_functions/experimental_slice_layout_unittest.cc b/src/trace_processor/perfetto_sql/intrinsics/table_functions/experimental_slice_layout_unittest.cc
index 73fd6b5..d6cd197 100644
--- a/src/trace_processor/perfetto_sql/intrinsics/table_functions/experimental_slice_layout_unittest.cc
+++ b/src/trace_processor/perfetto_sql/intrinsics/table_functions/experimental_slice_layout_unittest.cc
@@ -30,10 +30,11 @@
tables::ExperimentalSliceLayoutTable::ColumnIndex::filter_track_ids;
std::string ToVis(const Table& table) {
- const Column* layout_depth_column = table.GetColumnByName("layout_depth");
- const Column* ts_column = table.GetColumnByName("ts");
- const Column* dur_column = table.GetColumnByName("dur");
- const Column* filter_track_ids_column =
+ const ColumnLegacy* layout_depth_column =
+ table.GetColumnByName("layout_depth");
+ const ColumnLegacy* ts_column = table.GetColumnByName("ts");
+ const ColumnLegacy* dur_column = table.GetColumnByName("dur");
+ const ColumnLegacy* filter_track_ids_column =
table.GetColumnByName("filter_track_ids");
std::vector<std::string> lines;
diff --git a/src/trace_processor/perfetto_sql/intrinsics/table_functions/table_info.cc b/src/trace_processor/perfetto_sql/intrinsics/table_functions/table_info.cc
index fe17ac7..aba8832 100644
--- a/src/trace_processor/perfetto_sql/intrinsics/table_functions/table_info.cc
+++ b/src/trace_processor/perfetto_sql/intrinsics/table_functions/table_info.cc
@@ -40,10 +40,11 @@
using TableInfoTable = tables::PerfettoTableInfoTable;
-std::vector<TableInfoTable::Row> GetColInfoRows(const std::vector<Column>& cols,
- StringPool* pool) {
+std::vector<TableInfoTable::Row> GetColInfoRows(
+ const std::vector<ColumnLegacy>& cols,
+ StringPool* pool) {
std::vector<TableInfoTable::Row> rows;
- for (const Column& col : cols) {
+ for (const ColumnLegacy& col : cols) {
if (col.IsHidden()) {
continue;
}
diff --git a/src/trace_processor/tables/macros_internal.h b/src/trace_processor/tables/macros_internal.h
index b2f1f15..22085f2 100644
--- a/src/trace_processor/tables/macros_internal.h
+++ b/src/trace_processor/tables/macros_internal.h
@@ -67,14 +67,14 @@
: Table(pool), allow_inserts_(true), parent_(parent) {
if (!parent) {
overlays_.emplace_back();
- columns_.emplace_back(Column::IdColumn(this, 0, 0));
+ columns_.emplace_back(ColumnLegacy::IdColumn(this, 0, 0));
columns_.emplace_back(
- Column("type", &type_, Column::kNonNull, this, 1, 0));
+ ColumnLegacy("type", &type_, ColumnLegacy::kNonNull, this, 1, 0));
return;
}
overlays_.resize(parent->overlays().size() + 1);
- for (const Column& col : parent->columns()) {
+ for (const ColumnLegacy& col : parent->columns()) {
columns_.emplace_back(col, this, col.index_in_table(),
col.overlay_index());
}
@@ -92,7 +92,7 @@
}
overlays_.emplace_back(ColumnStorageOverlay(row_count_));
- for (const Column& col : parent.columns()) {
+ for (const ColumnLegacy& col : parent.columns()) {
columns_.emplace_back(col, this, col.index_in_table(),
col.overlay_index());
}
diff --git a/src/trace_processor/tables/py_tables_unittest.cc b/src/trace_processor/tables/py_tables_unittest.cc
index 36facd6..502e372 100644
--- a/src/trace_processor/tables/py_tables_unittest.cc
+++ b/src/trace_processor/tables/py_tables_unittest.cc
@@ -50,8 +50,9 @@
ASSERT_EQ(TestEventTable::ColumnIndex::arg_set_id, 3u);
ASSERT_EQ(TestEventTable::ColumnFlag::ts,
- Column::Flag::kSorted | Column::Flag::kNonNull);
- ASSERT_EQ(TestEventTable::ColumnFlag::arg_set_id, Column::Flag::kNonNull);
+ ColumnLegacy::Flag::kSorted | ColumnLegacy::Flag::kNonNull);
+ ASSERT_EQ(TestEventTable::ColumnFlag::arg_set_id,
+ ColumnLegacy::Flag::kNonNull);
}
TEST_F(PyTablesUnittest, ArgsTableProprties) {
@@ -61,9 +62,9 @@
ASSERT_EQ(TestArgsTable::ColumnIndex::type, 1u);
ASSERT_EQ(TestArgsTable::ColumnIndex::arg_set_id, 2u);
- ASSERT_EQ(TestArgsTable::ColumnFlag::arg_set_id, Column::Flag::kSorted |
- Column::Flag::kSetId |
- Column::Flag::kNonNull);
+ ASSERT_EQ(TestArgsTable::ColumnFlag::arg_set_id,
+ ColumnLegacy::Flag::kSorted | ColumnLegacy::Flag::kSetId |
+ ColumnLegacy::Flag::kNonNull);
}
TEST_F(PyTablesUnittest, InsertEvent) {
@@ -123,7 +124,7 @@
ASSERT_EQ(row_ref->dur(), 10u);
}
TEST_F(PyTablesUnittest, ChildTableStatics) {
- ASSERT_EQ(TestSliceTable::ColumnFlag::dur, Column::Flag::kNonNull);
+ ASSERT_EQ(TestSliceTable::ColumnFlag::dur, ColumnLegacy::Flag::kNonNull);
ASSERT_EQ(TestSliceTable::ColumnIndex::id, 0u);
ASSERT_EQ(TestSliceTable::ColumnIndex::type, 1u);
ASSERT_EQ(TestSliceTable::ColumnIndex::ts, 2u);
