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);