trace_processor: rename Table -> SqliteTable
This frees up the "Table" name for the upcoming trace processor Table
class which is a pure C++ class with no corresponding SQLite
association.
Change-Id: Icc57d4e75f9df1d8a05558f4db3569025a68ac0d
diff --git a/Android.bp b/Android.bp
index 550e67c..2cd9b6b 100644
--- a/Android.bp
+++ b/Android.bp
@@ -3742,6 +3742,7 @@
"src/trace_processor/span_join_operator_table.cc",
"src/trace_processor/sql_stats_table.cc",
"src/trace_processor/sqlite3_str_split.cc",
+ "src/trace_processor/sqlite_table.cc",
"src/trace_processor/stats_table.cc",
"src/trace_processor/storage_columns.cc",
"src/trace_processor/storage_schema.cc",
@@ -3750,7 +3751,6 @@
"src/trace_processor/syscall_tracker.cc",
"src/trace_processor/systrace_parser.cc",
"src/trace_processor/systrace_trace_parser.cc",
- "src/trace_processor/table.cc",
"src/trace_processor/thread_table.cc",
"src/trace_processor/trace_processor.cc",
"src/trace_processor/trace_processor_context.cc",
@@ -3912,6 +3912,7 @@
"src/trace_processor/span_join_operator_table.cc",
"src/trace_processor/sql_stats_table.cc",
"src/trace_processor/sqlite3_str_split.cc",
+ "src/trace_processor/sqlite_table.cc",
"src/trace_processor/stats_table.cc",
"src/trace_processor/storage_columns.cc",
"src/trace_processor/storage_schema.cc",
@@ -3920,7 +3921,6 @@
"src/trace_processor/syscall_tracker.cc",
"src/trace_processor/systrace_parser.cc",
"src/trace_processor/systrace_trace_parser.cc",
- "src/trace_processor/table.cc",
"src/trace_processor/thread_table.cc",
"src/trace_processor/trace_processor.cc",
"src/trace_processor/trace_processor_context.cc",
diff --git a/BUILD b/BUILD
index 87c0b9a..5e37c39 100644
--- a/BUILD
+++ b/BUILD
@@ -330,6 +330,8 @@
"src/trace_processor/sqlite.h",
"src/trace_processor/sqlite3_str_split.cc",
"src/trace_processor/sqlite3_str_split.h",
+ "src/trace_processor/sqlite_table.cc",
+ "src/trace_processor/sqlite_table.h",
"src/trace_processor/sqlite_utils.h",
"src/trace_processor/stats.h",
"src/trace_processor/stats_table.cc",
@@ -352,8 +354,6 @@
"src/trace_processor/systrace_parser.h",
"src/trace_processor/systrace_trace_parser.cc",
"src/trace_processor/systrace_trace_parser.h",
- "src/trace_processor/table.cc",
- "src/trace_processor/table.h",
"src/trace_processor/thread_table.cc",
"src/trace_processor/thread_table.h",
"src/trace_processor/trace_blob_view.h",
@@ -619,6 +619,8 @@
"src/trace_processor/sqlite.h",
"src/trace_processor/sqlite3_str_split.cc",
"src/trace_processor/sqlite3_str_split.h",
+ "src/trace_processor/sqlite_table.cc",
+ "src/trace_processor/sqlite_table.h",
"src/trace_processor/sqlite_utils.h",
"src/trace_processor/stats.h",
"src/trace_processor/stats_table.cc",
@@ -641,8 +643,6 @@
"src/trace_processor/systrace_parser.h",
"src/trace_processor/systrace_trace_parser.cc",
"src/trace_processor/systrace_trace_parser.h",
- "src/trace_processor/table.cc",
- "src/trace_processor/table.h",
"src/trace_processor/thread_table.cc",
"src/trace_processor/thread_table.h",
"src/trace_processor/trace_blob_view.h",
@@ -861,6 +861,8 @@
"src/trace_processor/sqlite.h",
"src/trace_processor/sqlite3_str_split.cc",
"src/trace_processor/sqlite3_str_split.h",
+ "src/trace_processor/sqlite_table.cc",
+ "src/trace_processor/sqlite_table.h",
"src/trace_processor/sqlite_utils.h",
"src/trace_processor/stats.h",
"src/trace_processor/stats_table.cc",
@@ -883,8 +885,6 @@
"src/trace_processor/systrace_parser.h",
"src/trace_processor/systrace_trace_parser.cc",
"src/trace_processor/systrace_trace_parser.h",
- "src/trace_processor/table.cc",
- "src/trace_processor/table.h",
"src/trace_processor/thread_table.cc",
"src/trace_processor/thread_table.h",
"src/trace_processor/trace_blob_view.h",
diff --git a/src/trace_processor/BUILD.gn b/src/trace_processor/BUILD.gn
index 08ebf91..ef0d92f 100644
--- a/src/trace_processor/BUILD.gn
+++ b/src/trace_processor/BUILD.gn
@@ -121,6 +121,8 @@
"sql_stats_table.h",
"sqlite3_str_split.cc",
"sqlite3_str_split.h",
+ "sqlite_table.cc",
+ "sqlite_table.h",
"sqlite_utils.h",
"stats.h",
"stats_table.cc",
@@ -143,8 +145,6 @@
"systrace_parser.h",
"systrace_trace_parser.cc",
"systrace_trace_parser.h",
- "table.cc",
- "table.h",
"thread_table.cc",
"thread_table.h",
"trace_blob_view.h",
diff --git a/src/trace_processor/android_logs_table.cc b/src/trace_processor/android_logs_table.cc
index ada0da2..b104280 100644
--- a/src/trace_processor/android_logs_table.cc
+++ b/src/trace_processor/android_logs_table.cc
@@ -23,7 +23,7 @@
: storage_(storage) {}
void AndroidLogsTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<AndroidLogsTable>(db, storage, "android_logs");
+ SqliteTable::Register<AndroidLogsTable>(db, storage, "android_logs");
}
StorageSchema AndroidLogsTable::CreateStorageSchema() {
diff --git a/src/trace_processor/args_table.cc b/src/trace_processor/args_table.cc
index 8e2bc4e..58a176b 100644
--- a/src/trace_processor/args_table.cc
+++ b/src/trace_processor/args_table.cc
@@ -60,7 +60,7 @@
: storage_(storage) {}
void ArgsTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<ArgsTable>(db, storage, "args");
+ SqliteTable::Register<ArgsTable>(db, storage, "args");
}
StorageSchema ArgsTable::CreateStorageSchema() {
diff --git a/src/trace_processor/args_table.h b/src/trace_processor/args_table.h
index 3327e57..e1a534c 100644
--- a/src/trace_processor/args_table.h
+++ b/src/trace_processor/args_table.h
@@ -52,22 +52,22 @@
bool HasOrdering() const override { return false; }
- Table::ColumnType GetType() const override {
+ SqliteTable::ColumnType GetType() const override {
switch (type_) {
case Variadic::Type::kInt:
- return Table::ColumnType::kLong;
+ return SqliteTable::ColumnType::kLong;
case Variadic::Type::kUint:
- return Table::ColumnType::kLong;
+ return SqliteTable::ColumnType::kLong;
case Variadic::Type::kString:
- return Table::ColumnType::kString;
+ return SqliteTable::ColumnType::kString;
case Variadic::Type::kReal:
- return Table::ColumnType::kDouble;
+ return SqliteTable::ColumnType::kDouble;
case Variadic::Type::kPointer:
- return Table::ColumnType::kLong;
+ return SqliteTable::ColumnType::kLong;
case Variadic::Type::kBool:
- return Table::ColumnType::kBool;
+ return SqliteTable::ColumnType::kBool;
case Variadic::Type::kJson:
- return Table::ColumnType::kString;
+ return SqliteTable::ColumnType::kString;
}
PERFETTO_FATAL("Not reached"); // For gcc
}
diff --git a/src/trace_processor/counter_definitions_table.cc b/src/trace_processor/counter_definitions_table.cc
index 4c4add8..fdde537 100644
--- a/src/trace_processor/counter_definitions_table.cc
+++ b/src/trace_processor/counter_definitions_table.cc
@@ -29,7 +29,8 @@
void CounterDefinitionsTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<CounterDefinitionsTable>(db, storage, "counter_definitions");
+ SqliteTable::Register<CounterDefinitionsTable>(db, storage,
+ "counter_definitions");
}
StorageSchema CounterDefinitionsTable::CreateStorageSchema() {
diff --git a/src/trace_processor/counter_values_table.cc b/src/trace_processor/counter_values_table.cc
index 0d1254c..cda1705 100644
--- a/src/trace_processor/counter_values_table.cc
+++ b/src/trace_processor/counter_values_table.cc
@@ -24,7 +24,7 @@
void CounterValuesTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<CounterValuesTable>(db, storage, "counter_values");
+ SqliteTable::Register<CounterValuesTable>(db, storage, "counter_values");
}
StorageSchema CounterValuesTable::CreateStorageSchema() {
diff --git a/src/trace_processor/heap_profile_allocation_table.cc b/src/trace_processor/heap_profile_allocation_table.cc
index cadba7a..8bd050e 100644
--- a/src/trace_processor/heap_profile_allocation_table.cc
+++ b/src/trace_processor/heap_profile_allocation_table.cc
@@ -26,8 +26,8 @@
void HeapProfileAllocationTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<HeapProfileAllocationTable>(db, storage,
- "heap_profile_allocation");
+ SqliteTable::Register<HeapProfileAllocationTable>(db, storage,
+ "heap_profile_allocation");
}
StorageSchema HeapProfileAllocationTable::CreateStorageSchema() {
diff --git a/src/trace_processor/heap_profile_callsite_table.cc b/src/trace_processor/heap_profile_callsite_table.cc
index 38efe72..3587cda 100644
--- a/src/trace_processor/heap_profile_callsite_table.cc
+++ b/src/trace_processor/heap_profile_callsite_table.cc
@@ -25,8 +25,8 @@
void HeapProfileCallsiteTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<HeapProfileCallsiteTable>(db, storage,
- "heap_profile_callsite");
+ SqliteTable::Register<HeapProfileCallsiteTable>(db, storage,
+ "heap_profile_callsite");
}
StorageSchema HeapProfileCallsiteTable::CreateStorageSchema() {
diff --git a/src/trace_processor/heap_profile_frame_table.cc b/src/trace_processor/heap_profile_frame_table.cc
index 2acf957..49cd3c3 100644
--- a/src/trace_processor/heap_profile_frame_table.cc
+++ b/src/trace_processor/heap_profile_frame_table.cc
@@ -25,7 +25,8 @@
void HeapProfileFrameTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<HeapProfileFrameTable>(db, storage, "heap_profile_frame");
+ SqliteTable::Register<HeapProfileFrameTable>(db, storage,
+ "heap_profile_frame");
}
StorageSchema HeapProfileFrameTable::CreateStorageSchema() {
diff --git a/src/trace_processor/heap_profile_mapping_table.cc b/src/trace_processor/heap_profile_mapping_table.cc
index c47d619..44cafdd 100644
--- a/src/trace_processor/heap_profile_mapping_table.cc
+++ b/src/trace_processor/heap_profile_mapping_table.cc
@@ -25,7 +25,8 @@
void HeapProfileMappingTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<HeapProfileMappingTable>(db, storage, "heap_profile_mapping");
+ SqliteTable::Register<HeapProfileMappingTable>(db, storage,
+ "heap_profile_mapping");
}
StorageSchema HeapProfileMappingTable::CreateStorageSchema() {
diff --git a/src/trace_processor/instants_table.cc b/src/trace_processor/instants_table.cc
index f5d368f..279e36c 100644
--- a/src/trace_processor/instants_table.cc
+++ b/src/trace_processor/instants_table.cc
@@ -27,7 +27,7 @@
: storage_(storage) {}
void InstantsTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<InstantsTable>(db, storage, "instants");
+ SqliteTable::Register<InstantsTable>(db, storage, "instants");
}
StorageSchema InstantsTable::CreateStorageSchema() {
diff --git a/src/trace_processor/metadata_table.cc b/src/trace_processor/metadata_table.cc
index 77c9fdf..2b9c888 100644
--- a/src/trace_processor/metadata_table.cc
+++ b/src/trace_processor/metadata_table.cc
@@ -26,7 +26,7 @@
: storage_(storage) {}
void MetadataTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<MetadataTable>(db, storage, "metadata");
+ SqliteTable::Register<MetadataTable>(db, storage, "metadata");
}
StorageSchema MetadataTable::CreateStorageSchema() {
diff --git a/src/trace_processor/metadata_table.h b/src/trace_processor/metadata_table.h
index 55a0694..2cc0846 100644
--- a/src/trace_processor/metadata_table.h
+++ b/src/trace_processor/metadata_table.h
@@ -98,11 +98,11 @@
bool HasOrdering() const override { return false; }
- Table::ColumnType GetType() const override {
+ SqliteTable::ColumnType GetType() const override {
if (type_ == Variadic::Type::kInt)
- return Table::ColumnType::kLong;
+ return SqliteTable::ColumnType::kLong;
if (type_ == Variadic::Type::kString)
- return Table::ColumnType::kString;
+ return SqliteTable::ColumnType::kString;
PERFETTO_FATAL("Unimplemented metadata value type.");
}
diff --git a/src/trace_processor/process_table.cc b/src/trace_processor/process_table.cc
index cba6f99..c409989 100644
--- a/src/trace_processor/process_table.cc
+++ b/src/trace_processor/process_table.cc
@@ -33,25 +33,26 @@
: storage_(storage) {}
void ProcessTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<ProcessTable>(db, storage, "process");
+ SqliteTable::Register<ProcessTable>(db, storage, "process");
}
util::Status ProcessTable::Init(int, const char* const*, Schema* schema) {
*schema = Schema(
{
- Table::Column(Column::kUpid, "upid", ColumnType::kInt),
- Table::Column(Column::kName, "name", ColumnType::kString),
- Table::Column(Column::kPid, "pid", ColumnType::kUint),
- Table::Column(Column::kStartTs, "start_ts", ColumnType::kLong),
- Table::Column(Column::kEndTs, "end_ts", ColumnType::kLong),
- Table::Column(Column::kParentUpid, "parent_upid", ColumnType::kInt),
+ SqliteTable::Column(Column::kUpid, "upid", ColumnType::kInt),
+ SqliteTable::Column(Column::kName, "name", ColumnType::kString),
+ SqliteTable::Column(Column::kPid, "pid", ColumnType::kUint),
+ SqliteTable::Column(Column::kStartTs, "start_ts", ColumnType::kLong),
+ SqliteTable::Column(Column::kEndTs, "end_ts", ColumnType::kLong),
+ SqliteTable::Column(Column::kParentUpid, "parent_upid",
+ ColumnType::kInt),
},
{Column::kUpid});
return util::OkStatus();
}
-std::unique_ptr<Table::Cursor> ProcessTable::CreateCursor() {
- return std::unique_ptr<Table::Cursor>(new Cursor(this));
+std::unique_ptr<SqliteTable::Cursor> ProcessTable::CreateCursor() {
+ return std::unique_ptr<SqliteTable::Cursor>(new Cursor(this));
}
int ProcessTable::BestIndex(const QueryConstraints& qc, BestIndexInfo* info) {
@@ -68,7 +69,7 @@
}
ProcessTable::Cursor::Cursor(ProcessTable* table)
- : Table::Cursor(table), storage_(table->storage_) {}
+ : SqliteTable::Cursor(table), storage_(table->storage_) {}
int ProcessTable::Cursor::Filter(const QueryConstraints& qc,
sqlite3_value** argv) {
diff --git a/src/trace_processor/process_table.h b/src/trace_processor/process_table.h
index 2b3ea6c..95fcf6c 100644
--- a/src/trace_processor/process_table.h
+++ b/src/trace_processor/process_table.h
@@ -20,7 +20,7 @@
#include <limits>
#include <memory>
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/trace_storage.h"
namespace perfetto {
@@ -28,7 +28,7 @@
// The implementation of the SQLite table containing each unique process with
// their details.
-class ProcessTable : public Table {
+class ProcessTable : public SqliteTable {
public:
enum Column {
kUpid = 0,
@@ -38,7 +38,7 @@
kEndTs = 4,
kParentUpid = 5
};
- class Cursor : public Table::Cursor {
+ class Cursor : public SqliteTable::Cursor {
public:
Cursor(ProcessTable*);
@@ -61,8 +61,8 @@
ProcessTable(sqlite3*, const TraceStorage*);
// Table implementation.
- util::Status Init(int, const char* const*, Table::Schema*) override;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ util::Status Init(int, const char* const*, SqliteTable::Schema*) override;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
int BestIndex(const QueryConstraints&, BestIndexInfo*) override;
private:
diff --git a/src/trace_processor/raw_table.cc b/src/trace_processor/raw_table.cc
index 501eee4..054d4d0 100644
--- a/src/trace_processor/raw_table.cc
+++ b/src/trace_processor/raw_table.cc
@@ -45,7 +45,7 @@
}
void RawTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<RawTable>(db, storage, "raw");
+ SqliteTable::Register<RawTable>(db, storage, "raw");
}
StorageSchema RawTable::CreateStorageSchema() {
diff --git a/src/trace_processor/sched_slice_table.cc b/src/trace_processor/sched_slice_table.cc
index 551f3b7..53d69db 100644
--- a/src/trace_processor/sched_slice_table.cc
+++ b/src/trace_processor/sched_slice_table.cc
@@ -23,7 +23,7 @@
: storage_(storage) {}
void SchedSliceTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<SchedSliceTable>(db, storage, "sched");
+ SqliteTable::Register<SchedSliceTable>(db, storage, "sched");
}
StorageSchema SchedSliceTable::CreateStorageSchema() {
@@ -202,8 +202,8 @@
};
}
-Table::ColumnType SchedSliceTable::EndStateColumn::GetType() const {
- return Table::ColumnType::kString;
+SqliteTable::ColumnType SchedSliceTable::EndStateColumn::GetType() const {
+ return SqliteTable::ColumnType::kString;
}
} // namespace trace_processor
diff --git a/src/trace_processor/sched_slice_table.h b/src/trace_processor/sched_slice_table.h
index e30e742..7166bf8 100644
--- a/src/trace_processor/sched_slice_table.h
+++ b/src/trace_processor/sched_slice_table.h
@@ -51,7 +51,7 @@
Comparator Sort(const QueryConstraints::OrderBy&) const override;
- Table::ColumnType GetType() const override;
+ SqliteTable::ColumnType GetType() const override;
private:
static constexpr uint16_t kNumStateStrings =
diff --git a/src/trace_processor/slice_table.cc b/src/trace_processor/slice_table.cc
index b3ce725..95d8b7b 100644
--- a/src/trace_processor/slice_table.cc
+++ b/src/trace_processor/slice_table.cc
@@ -25,7 +25,7 @@
: storage_(storage) {}
void SliceTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<SliceTable>(db, storage, "internal_slice");
+ SqliteTable::Register<SliceTable>(db, storage, "internal_slice");
}
StorageSchema SliceTable::CreateStorageSchema() {
diff --git a/src/trace_processor/span_join_operator_table.cc b/src/trace_processor/span_join_operator_table.cc
index a1475f1..eed3511 100644
--- a/src/trace_processor/span_join_operator_table.cc
+++ b/src/trace_processor/span_join_operator_table.cc
@@ -41,7 +41,7 @@
}
base::Optional<std::string> HasDuplicateColumns(
- const std::vector<Table::Column>& cols) {
+ const std::vector<SqliteTable::Column>& cols) {
std::set<std::string> names;
for (const auto& col : cols) {
if (names.count(col.name()) > 0)
@@ -58,17 +58,17 @@
void SpanJoinOperatorTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<SpanJoinOperatorTable>(db, storage, "span_join",
- /* read_write */ false,
- /* requires_args */ true);
+ SqliteTable::Register<SpanJoinOperatorTable>(db, storage, "span_join",
+ /* read_write */ false,
+ /* requires_args */ true);
- Table::Register<SpanJoinOperatorTable>(db, storage, "span_left_join",
- /* read_write */ false,
- /* requires_args */ true);
+ SqliteTable::Register<SpanJoinOperatorTable>(db, storage, "span_left_join",
+ /* read_write */ false,
+ /* requires_args */ true);
- Table::Register<SpanJoinOperatorTable>(db, storage, "span_outer_join",
- /* read_write */ false,
- /* requires_args */ true);
+ SqliteTable::Register<SpanJoinOperatorTable>(db, storage, "span_outer_join",
+ /* read_write */ false,
+ /* requires_args */ true);
}
util::Status SpanJoinOperatorTable::Init(int argc,
@@ -122,7 +122,7 @@
if (!status.ok())
return status;
- std::vector<Table::Column> cols;
+ std::vector<SqliteTable::Column> cols;
// Ensure the shared columns are consistently ordered and are not
// present twice in the final schema
cols.emplace_back(Column::kTimestamp, kTsColumnName, ColumnType::kLong);
@@ -149,7 +149,7 @@
void SpanJoinOperatorTable::CreateSchemaColsForDefn(
const TableDefinition& defn,
- std::vector<Table::Column>* cols) {
+ std::vector<SqliteTable::Column>* cols) {
for (size_t i = 0; i < defn.columns().size(); i++) {
const auto& n = defn.columns()[i].name();
if (IsRequiredColumn(n) || n == defn.partition_col())
@@ -163,7 +163,7 @@
}
}
-std::unique_ptr<Table::Cursor> SpanJoinOperatorTable::CreateCursor() {
+std::unique_ptr<SqliteTable::Cursor> SpanJoinOperatorTable::CreateCursor() {
return std::unique_ptr<SpanJoinOperatorTable::Cursor>(new Cursor(this, db_));
}
@@ -218,8 +218,8 @@
auto col = cols[i];
if (IsRequiredColumn(col.name())) {
++required_columns_found;
- if (col.type() != Table::ColumnType::kLong &&
- col.type() != Table::ColumnType::kUnknown) {
+ if (col.type() != SqliteTable::ColumnType::kLong &&
+ col.type() != SqliteTable::ColumnType::kUnknown) {
return util::ErrStatus(
"SPAN_JOIN: Invalid type for column %s in table %s",
col.name().c_str(), desc.name.c_str());
@@ -270,7 +270,7 @@
}
SpanJoinOperatorTable::Cursor::Cursor(SpanJoinOperatorTable* table, sqlite3* db)
- : Table::Cursor(table),
+ : SqliteTable::Cursor(table),
t1_(table, &table->t1_defn_, db),
t2_(table, &table->t2_defn_, db),
table_(table) {}
@@ -616,7 +616,7 @@
std::string SpanJoinOperatorTable::Query::CreateSqlQuery(
const std::vector<std::string>& cs) const {
std::vector<std::string> col_names;
- for (const Table::Column& c : defn_->columns()) {
+ for (const SqliteTable::Column& c : defn_->columns()) {
col_names.push_back("`" + c.name() + "`");
}
@@ -682,7 +682,7 @@
SpanJoinOperatorTable::TableDefinition::TableDefinition(
std::string name,
std::string partition_col,
- std::vector<Table::Column> cols,
+ std::vector<SqliteTable::Column> cols,
bool emit_shadow_slices,
uint32_t ts_idx,
uint32_t dur_idx,
diff --git a/src/trace_processor/span_join_operator_table.h b/src/trace_processor/span_join_operator_table.h
index 6228ad3..a130b9d 100644
--- a/src/trace_processor/span_join_operator_table.h
+++ b/src/trace_processor/span_join_operator_table.h
@@ -30,7 +30,7 @@
#include "perfetto/trace_processor/status.h"
#include "src/trace_processor/scoped_db.h"
#include "src/trace_processor/sqlite.h"
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
namespace perfetto {
namespace trace_processor {
@@ -67,7 +67,7 @@
//
// All other columns apart from timestamp (ts), duration (dur) and the join key
// are passed through unchanged.
-class SpanJoinOperatorTable : public Table {
+class SpanJoinOperatorTable : public SqliteTable {
public:
// Columns of the span operator table.
enum Column {
@@ -101,7 +101,7 @@
TableDefinition(std::string name,
std::string partition_col,
- std::vector<Table::Column> cols,
+ std::vector<SqliteTable::Column> cols,
bool emit_shadow_slices,
uint32_t ts_idx,
uint32_t dur_idx,
@@ -109,7 +109,7 @@
const std::string& name() const { return name_; }
const std::string& partition_col() const { return partition_col_; }
- const std::vector<Table::Column>& columns() const { return cols_; }
+ const std::vector<SqliteTable::Column>& columns() const { return cols_; }
bool emit_shadow_slices() const { return emit_shadow_slices_; }
uint32_t ts_idx() const { return ts_idx_; }
@@ -121,7 +121,7 @@
private:
std::string name_;
std::string partition_col_;
- std::vector<Table::Column> cols_;
+ std::vector<SqliteTable::Column> cols_;
bool emit_shadow_slices_;
uint32_t ts_idx_ = std::numeric_limits<uint32_t>::max();
uint32_t dur_idx_ = std::numeric_limits<uint32_t>::max();
@@ -221,7 +221,7 @@
};
// Base class for a cursor on the span table.
- class Cursor : public Table::Cursor {
+ class Cursor : public SqliteTable::Cursor {
public:
Cursor(SpanJoinOperatorTable*, sqlite3* db);
~Cursor() override = default;
@@ -253,8 +253,8 @@
static void RegisterTable(sqlite3* db, const TraceStorage* storage);
// Table implementation.
- util::Status Init(int, const char* const*, Table::Schema*) override;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ util::Status Init(int, const char* const*, SqliteTable::Schema*) override;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
int BestIndex(const QueryConstraints& qc, BestIndexInfo* info) override;
private:
@@ -286,7 +286,7 @@
int global_column);
void CreateSchemaColsForDefn(const TableDefinition& defn,
- std::vector<Table::Column>* cols);
+ std::vector<SqliteTable::Column>* cols);
TableDefinition t1_defn_;
TableDefinition t2_defn_;
diff --git a/src/trace_processor/sql_stats_table.cc b/src/trace_processor/sql_stats_table.cc
index fdd2467..b7a3e7b 100644
--- a/src/trace_processor/sql_stats_table.cc
+++ b/src/trace_processor/sql_stats_table.cc
@@ -31,25 +31,26 @@
: storage_(storage) {}
void SqlStatsTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<SqlStatsTable>(db, storage, "sqlstats");
+ SqliteTable::Register<SqlStatsTable>(db, storage, "sqlstats");
}
util::Status SqlStatsTable::Init(int, const char* const*, Schema* schema) {
*schema = Schema(
{
- Table::Column(Column::kQuery, "query", ColumnType::kString),
- Table::Column(Column::kTimeQueued, "queued", ColumnType::kLong),
- Table::Column(Column::kTimeStarted, "started", ColumnType::kLong),
- Table::Column(Column::kTimeFirstNext, "first_next",
- ColumnType::kLong),
- Table::Column(Column::kTimeEnded, "ended", ColumnType::kLong),
+ SqliteTable::Column(Column::kQuery, "query", ColumnType::kString),
+ SqliteTable::Column(Column::kTimeQueued, "queued", ColumnType::kLong),
+ SqliteTable::Column(Column::kTimeStarted, "started",
+ ColumnType::kLong),
+ SqliteTable::Column(Column::kTimeFirstNext, "first_next",
+ ColumnType::kLong),
+ SqliteTable::Column(Column::kTimeEnded, "ended", ColumnType::kLong),
},
{Column::kTimeQueued});
return util::OkStatus();
}
-std::unique_ptr<Table::Cursor> SqlStatsTable::CreateCursor() {
- return std::unique_ptr<Table::Cursor>(new Cursor(this));
+std::unique_ptr<SqliteTable::Cursor> SqlStatsTable::CreateCursor() {
+ return std::unique_ptr<SqliteTable::Cursor>(new Cursor(this));
}
int SqlStatsTable::BestIndex(const QueryConstraints&, BestIndexInfo* info) {
@@ -58,7 +59,7 @@
}
SqlStatsTable::Cursor::Cursor(SqlStatsTable* table)
- : Table::Cursor(table), storage_(table->storage_), table_(table) {}
+ : SqliteTable::Cursor(table), storage_(table->storage_), table_(table) {}
SqlStatsTable::Cursor::~Cursor() = default;
diff --git a/src/trace_processor/sql_stats_table.h b/src/trace_processor/sql_stats_table.h
index 4774a10..ae58477 100644
--- a/src/trace_processor/sql_stats_table.h
+++ b/src/trace_processor/sql_stats_table.h
@@ -20,7 +20,7 @@
#include <limits>
#include <memory>
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
namespace perfetto {
namespace trace_processor {
@@ -30,7 +30,7 @@
// A virtual table that allows to introspect performances of the SQL engine
// for the kMaxLogEntries queries.
-class SqlStatsTable : public Table {
+class SqlStatsTable : public SqliteTable {
public:
enum Column {
kQuery = 0,
@@ -41,12 +41,12 @@
};
// Implementation of the SQLite cursor interface.
- class Cursor : public Table::Cursor {
+ class Cursor : public SqliteTable::Cursor {
public:
Cursor(SqlStatsTable* storage);
~Cursor() override;
- // Implementation of Table::Cursor.
+ // Implementation of SqliteTable::Cursor.
int Filter(const QueryConstraints&, sqlite3_value**) override;
int Next() override;
int Eof() override;
@@ -71,7 +71,7 @@
// Table implementation.
util::Status Init(int, const char* const*, Schema*) override;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
int BestIndex(const QueryConstraints&, BestIndexInfo*) override;
private:
diff --git a/src/trace_processor/table.cc b/src/trace_processor/sqlite_table.cc
similarity index 71%
rename from src/trace_processor/table.cc
rename to src/trace_processor/sqlite_table.cc
index 1110d6f..1d52ddc 100644
--- a/src/trace_processor/table.cc
+++ b/src/trace_processor/sqlite_table.cc
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
#include <ctype.h>
#include <string.h>
@@ -27,21 +27,21 @@
namespace {
-std::string TypeToString(Table::ColumnType type) {
+std::string TypeToString(SqliteTable::ColumnType type) {
switch (type) {
- case Table::ColumnType::kString:
+ case SqliteTable::ColumnType::kString:
return "STRING";
- case Table::ColumnType::kUint:
+ case SqliteTable::ColumnType::kUint:
return "UNSIGNED INT";
- case Table::ColumnType::kLong:
+ case SqliteTable::ColumnType::kLong:
return "BIG INT";
- case Table::ColumnType::kInt:
+ case SqliteTable::ColumnType::kInt:
return "INT";
- case Table::ColumnType::kDouble:
+ case SqliteTable::ColumnType::kDouble:
return "DOUBLE";
- case Table::ColumnType::kBool:
+ case SqliteTable::ColumnType::kBool:
return "BOOLEAN";
- case Table::ColumnType::kUnknown:
+ case SqliteTable::ColumnType::kUnknown:
PERFETTO_FATAL("Cannot map unknown column type");
}
PERFETTO_FATAL("Not reached"); // For gcc
@@ -50,18 +50,18 @@
} // namespace
// static
-bool Table::debug = false;
+bool SqliteTable::debug = false;
-Table::Table() = default;
-Table::~Table() = default;
+SqliteTable::SqliteTable() = default;
+SqliteTable::~SqliteTable() = default;
-int Table::OpenInternal(sqlite3_vtab_cursor** ppCursor) {
+int SqliteTable::OpenInternal(sqlite3_vtab_cursor** ppCursor) {
// Freed in xClose().
*ppCursor = static_cast<sqlite3_vtab_cursor*>(CreateCursor().release());
return SQLITE_OK;
}
-int Table::BestIndexInternal(sqlite3_index_info* idx) {
+int SqliteTable::BestIndexInternal(sqlite3_index_info* idx) {
QueryConstraints query_constraints;
for (int i = 0; i < idx->nOrderBy; i++) {
@@ -86,7 +86,7 @@
int ret = BestIndex(query_constraints, &info);
- if (Table::debug) {
+ if (SqliteTable::debug) {
PERFETTO_LOG(
"[%s::BestIndex] constraints=%s orderByConsumed=%d estimatedCost=%d",
name_.c_str(), query_constraints.ToNewSqlite3String().get(),
@@ -116,49 +116,49 @@
return SQLITE_OK;
}
-int Table::FindFunction(const char*, FindFunctionFn, void**) {
+int SqliteTable::FindFunction(const char*, FindFunctionFn, void**) {
return 0;
}
-int Table::Update(int, sqlite3_value**, sqlite3_int64*) {
+int SqliteTable::Update(int, sqlite3_value**, sqlite3_int64*) {
return SQLITE_READONLY;
}
-const QueryConstraints& Table::ParseConstraints(int idxNum,
- const char* idxStr,
- int argc) {
+const QueryConstraints& SqliteTable::ParseConstraints(int idxNum,
+ const char* idxStr,
+ int argc) {
bool cache_hit = true;
if (idxNum != qc_hash_) {
qc_cache_ = QueryConstraints::FromString(idxStr);
qc_hash_ = idxNum;
cache_hit = false;
}
- if (Table::debug) {
+ if (SqliteTable::debug) {
PERFETTO_LOG("[%s::ParseConstraints] constraints=%s argc=%d cache_hit=%d",
name_.c_str(), idxStr, argc, cache_hit);
}
return qc_cache_;
}
-Table::Cursor::Cursor(Table* table) : table_(table) {
+SqliteTable::Cursor::Cursor(SqliteTable* table) : table_(table) {
// This is required to prevent us from leaving this field uninitialised if
// we ever move construct the Cursor.
pVtab = table;
}
-Table::Cursor::~Cursor() = default;
+SqliteTable::Cursor::~Cursor() = default;
-int Table::Cursor::RowId(sqlite3_int64*) {
+int SqliteTable::Cursor::RowId(sqlite3_int64*) {
return SQLITE_ERROR;
}
-Table::Column::Column(size_t index,
- std::string name,
- ColumnType type,
- bool hidden)
+SqliteTable::Column::Column(size_t index,
+ std::string name,
+ ColumnType type,
+ bool hidden)
: index_(index), name_(name), type_(type), hidden_(hidden) {}
-Table::Schema::Schema(std::vector<Column> columns,
- std::vector<size_t> primary_keys)
+SqliteTable::Schema::Schema(std::vector<Column> columns,
+ std::vector<size_t> primary_keys)
: columns_(std::move(columns)), primary_keys_(std::move(primary_keys)) {
for (size_t i = 0; i < columns_.size(); i++) {
PERFETTO_CHECK(columns_[i].index() == i);
@@ -168,11 +168,11 @@
}
}
-Table::Schema::Schema() = default;
-Table::Schema::Schema(const Schema&) = default;
-Table::Schema& Table::Schema::operator=(const Schema&) = default;
+SqliteTable::Schema::Schema() = default;
+SqliteTable::Schema::Schema(const Schema&) = default;
+SqliteTable::Schema& SqliteTable::Schema::operator=(const Schema&) = default;
-std::string Table::Schema::ToCreateTableStmt() const {
+std::string SqliteTable::Schema::ToCreateTableStmt() const {
std::string stmt = "CREATE TABLE x(";
for (size_t i = 0; i < columns_.size(); ++i) {
const Column& col = columns_[i];
diff --git a/src/trace_processor/table.h b/src/trace_processor/sqlite_table.h
similarity index 93%
rename from src/trace_processor/table.h
rename to src/trace_processor/sqlite_table.h
index c89f002..5dc9cab 100644
--- a/src/trace_processor/table.h
+++ b/src/trace_processor/sqlite_table.h
@@ -14,8 +14,8 @@
* limitations under the License.
*/
-#ifndef SRC_TRACE_PROCESSOR_TABLE_H_
-#define SRC_TRACE_PROCESSOR_TABLE_H_
+#ifndef SRC_TRACE_PROCESSOR_SQLITE_TABLE_H_
+#define SRC_TRACE_PROCESSOR_SQLITE_TABLE_H_
#include <functional>
#include <memory>
@@ -37,10 +37,11 @@
// Abstract base class representing a SQLite virtual table. Implements the
// common bookeeping required across all tables and allows subclasses to
// implement a friendlier API than that required by SQLite.
-class Table : public sqlite3_vtab {
+class SqliteTable : public sqlite3_vtab {
public:
using Factory =
- std::function<std::unique_ptr<Table>(sqlite3*, const TraceStorage*)>;
+ std::function<std::unique_ptr<SqliteTable>(sqlite3*,
+ const TraceStorage*)>;
// Allowed types for columns in a table.
enum ColumnType {
@@ -74,13 +75,13 @@
static bool debug;
// Public for unique_ptr destructor calls.
- virtual ~Table();
+ virtual ~SqliteTable();
// Abstract base class representing an SQLite Cursor. Presents a friendlier
// API for subclasses to implement.
class Cursor : public sqlite3_vtab_cursor {
public:
- Cursor(Table* table);
+ Cursor(SqliteTable* table);
virtual ~Cursor();
// Methods to be implemented by derived table classes.
@@ -109,9 +110,9 @@
Cursor& operator=(Cursor&&) = default;
private:
- friend class Table;
+ friend class SqliteTable;
- Table* table_ = nullptr;
+ SqliteTable* table_ = nullptr;
};
// The schema of the table. Created by subclasses to allow the table class to
@@ -148,13 +149,13 @@
};
struct TableDescriptor {
- Table::Factory factory;
+ SqliteTable::Factory factory;
const TraceStorage* storage = nullptr;
std::string name;
sqlite3_module module = {};
};
- Table();
+ SqliteTable();
// Called by derived classes to register themselves with the SQLite db.
// |read_write| specifies whether the table can also be written to.
@@ -300,7 +301,7 @@
template <typename TableType>
static Factory GetFactory() {
return [](sqlite3* db, const TraceStorage* storage) {
- return std::unique_ptr<Table>(new TableType(db, storage));
+ return std::unique_ptr<SqliteTable>(new TableType(db, storage));
};
}
@@ -319,8 +320,8 @@
int OpenInternal(sqlite3_vtab_cursor**);
int BestIndexInternal(sqlite3_index_info*);
- Table(const Table&) = delete;
- Table& operator=(const Table&) = delete;
+ SqliteTable(const SqliteTable&) = delete;
+ SqliteTable& operator=(const SqliteTable&) = delete;
std::string name_;
Schema schema_;
@@ -333,4 +334,4 @@
} // namespace trace_processor
} // namespace perfetto
-#endif // SRC_TRACE_PROCESSOR_TABLE_H_
+#endif // SRC_TRACE_PROCESSOR_SQLITE_TABLE_H_
diff --git a/src/trace_processor/sqlite_utils.h b/src/trace_processor/sqlite_utils.h
index 64ad4fb..30fc2c4 100644
--- a/src/trace_processor/sqlite_utils.h
+++ b/src/trace_processor/sqlite_utils.h
@@ -27,7 +27,7 @@
#include "perfetto/ext/base/optional.h"
#include "src/trace_processor/scoped_db.h"
#include "src/trace_processor/sqlite.h"
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
namespace perfetto {
namespace trace_processor {
@@ -394,7 +394,7 @@
}
}
-inline std::vector<Table::Column> GetColumnsForTable(
+inline std::vector<SqliteTable::Column> GetColumnsForTable(
sqlite3* db,
const std::string& raw_table_name) {
char sql[1024];
@@ -411,7 +411,7 @@
ScopedStmt stmt(raw_stmt);
PERFETTO_DCHECK(sqlite3_column_count(*stmt) == 2);
- std::vector<Table::Column> columns;
+ std::vector<SqliteTable::Column> columns;
for (;;) {
err = sqlite3_step(raw_stmt);
if (err == SQLITE_DONE)
@@ -431,23 +431,23 @@
raw_table_name.c_str());
}
- Table::ColumnType type;
+ SqliteTable::ColumnType type;
if (strcmp(raw_type, "UNSIGNED INT") == 0) {
- type = Table::ColumnType::kUint;
+ type = SqliteTable::ColumnType::kUint;
} else if (strcmp(raw_type, "BIG INT") == 0) {
- type = Table::ColumnType::kLong;
+ type = SqliteTable::ColumnType::kLong;
} else if (strcmp(raw_type, "INT") == 0) {
- type = Table::ColumnType::kInt;
+ type = SqliteTable::ColumnType::kInt;
} else if (strcmp(raw_type, "STRING") == 0) {
- type = Table::ColumnType::kString;
+ type = SqliteTable::ColumnType::kString;
} else if (strcmp(raw_type, "DOUBLE") == 0) {
- type = Table::ColumnType::kDouble;
+ type = SqliteTable::ColumnType::kDouble;
} else if (strcmp(raw_type, "BOOLEAN") == 0) {
- type = Table::ColumnType::kBool;
+ type = SqliteTable::ColumnType::kBool;
} else if (!*raw_type) {
PERFETTO_DLOG("Unknown column type for %s %s", raw_table_name.c_str(),
name);
- type = Table::ColumnType::kUnknown;
+ type = SqliteTable::ColumnType::kUnknown;
} else {
PERFETTO_FATAL("Unknown column type '%s' on table %s", raw_type,
raw_table_name.c_str());
diff --git a/src/trace_processor/stats_table.cc b/src/trace_processor/stats_table.cc
index 7b5cb79..da3cdcc 100644
--- a/src/trace_processor/stats_table.cc
+++ b/src/trace_processor/stats_table.cc
@@ -25,25 +25,26 @@
: storage_(storage) {}
void StatsTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<StatsTable>(db, storage, "stats");
+ SqliteTable::Register<StatsTable>(db, storage, "stats");
}
util::Status StatsTable::Init(int, const char* const*, Schema* schema) {
*schema = Schema(
{
- Table::Column(Column::kName, "name", ColumnType::kString),
+ SqliteTable::Column(Column::kName, "name", ColumnType::kString),
// Calling a column "index" causes sqlite to silently fail, hence idx.
- Table::Column(Column::kIndex, "idx", ColumnType::kUint),
- Table::Column(Column::kSeverity, "severity", ColumnType::kString),
- Table::Column(Column::kSource, "source", ColumnType::kString),
- Table::Column(Column::kValue, "value", ColumnType::kLong),
+ SqliteTable::Column(Column::kIndex, "idx", ColumnType::kUint),
+ SqliteTable::Column(Column::kSeverity, "severity",
+ ColumnType::kString),
+ SqliteTable::Column(Column::kSource, "source", ColumnType::kString),
+ SqliteTable::Column(Column::kValue, "value", ColumnType::kLong),
},
{Column::kName});
return util::OkStatus();
}
-std::unique_ptr<Table::Cursor> StatsTable::CreateCursor() {
- return std::unique_ptr<Table::Cursor>(new Cursor(this));
+std::unique_ptr<SqliteTable::Cursor> StatsTable::CreateCursor() {
+ return std::unique_ptr<SqliteTable::Cursor>(new Cursor(this));
}
int StatsTable::BestIndex(const QueryConstraints&, BestIndexInfo*) {
@@ -51,7 +52,7 @@
}
StatsTable::Cursor::Cursor(StatsTable* table)
- : Table::Cursor(table), table_(table), storage_(table->storage_) {}
+ : SqliteTable::Cursor(table), table_(table), storage_(table->storage_) {}
int StatsTable::Cursor::Filter(const QueryConstraints&, sqlite3_value**) {
*this = Cursor(table_);
diff --git a/src/trace_processor/stats_table.h b/src/trace_processor/stats_table.h
index 83f46ff..167c616 100644
--- a/src/trace_processor/stats_table.h
+++ b/src/trace_processor/stats_table.h
@@ -20,8 +20,8 @@
#include <limits>
#include <memory>
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/stats.h"
-#include "src/trace_processor/table.h"
#include "src/trace_processor/trace_storage.h"
namespace perfetto {
@@ -30,14 +30,14 @@
// The stats table contains diagnostic info and errors that are either:
// - Collected at trace time (e.g., ftrace buffer overruns).
// - Generated at parsing time (e.g., clock events out-of-order).
-class StatsTable : public Table {
+class StatsTable : public SqliteTable {
public:
enum Column { kName = 0, kIndex, kSeverity, kSource, kValue };
- class Cursor : public Table::Cursor {
+ class Cursor : public SqliteTable::Cursor {
public:
Cursor(StatsTable*);
- // Implementation of Table::Cursor.
+ // Implementation of SqliteTable::Cursor.
int Filter(const QueryConstraints&, sqlite3_value**) override;
int Next() override;
int Eof() override;
@@ -61,8 +61,8 @@
StatsTable(sqlite3*, const TraceStorage*);
// Table implementation.
- util::Status Init(int, const char* const*, Table::Schema*) override;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ util::Status Init(int, const char* const*, SqliteTable::Schema*) override;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
int BestIndex(const QueryConstraints&, BestIndexInfo*) override;
private:
diff --git a/src/trace_processor/storage_columns.h b/src/trace_processor/storage_columns.h
index 6dca96a..39f0fd9 100644
--- a/src/trace_processor/storage_columns.h
+++ b/src/trace_processor/storage_columns.h
@@ -55,7 +55,7 @@
virtual Comparator Sort(const QueryConstraints::OrderBy& ob) const = 0;
// Returns the type of this column.
- virtual Table::ColumnType GetType() const = 0;
+ virtual SqliteTable::ColumnType GetType() const = 0;
// Bounds a filter on this column between a minimum and maximum index.
// Generally this is only possible if the column is sorted.
@@ -113,8 +113,8 @@
};
}
- Table::ColumnType GetType() const override {
- return Table::ColumnType::kString;
+ SqliteTable::ColumnType GetType() const override {
+ return SqliteTable::ColumnType::kString;
}
bool HasOrdering() const override { return accessor_.HasOrdering(); }
@@ -211,16 +211,16 @@
bool HasOrdering() const override { return accessor_.HasOrdering(); }
- Table::ColumnType GetType() const override {
+ SqliteTable::ColumnType GetType() const override {
if (std::is_same<NumericType, int32_t>::value) {
- return Table::ColumnType::kInt;
+ return SqliteTable::ColumnType::kInt;
} else if (std::is_same<NumericType, uint8_t>::value ||
std::is_same<NumericType, uint32_t>::value) {
- return Table::ColumnType::kUint;
+ return SqliteTable::ColumnType::kUint;
} else if (std::is_same<NumericType, int64_t>::value) {
- return Table::ColumnType::kLong;
+ return SqliteTable::ColumnType::kLong;
} else if (std::is_same<NumericType, double>::value) {
- return Table::ColumnType::kDouble;
+ return SqliteTable::ColumnType::kDouble;
}
PERFETTO_FATAL("Unexpected column type");
}
diff --git a/src/trace_processor/storage_schema.cc b/src/trace_processor/storage_schema.cc
index 2dd726c..7c43ea7 100644
--- a/src/trace_processor/storage_schema.cc
+++ b/src/trace_processor/storage_schema.cc
@@ -26,8 +26,8 @@
std::vector<std::string> primary_keys)
: columns_(std::move(columns)), primary_keys_(std::move(primary_keys)) {}
-Table::Schema StorageSchema::ToTableSchema() {
- std::vector<Table::Column> columns;
+SqliteTable::Schema StorageSchema::ToTableSchema() {
+ std::vector<SqliteTable::Column> columns;
size_t i = 0;
for (const auto& col : columns_)
columns.emplace_back(i++, col->name(), col->GetType(), col->hidden());
@@ -35,7 +35,7 @@
std::vector<size_t> primary_keys;
for (const auto& p_key : primary_keys_)
primary_keys.emplace_back(ColumnIndexFromName(p_key));
- return Table::Schema(std::move(columns), std::move(primary_keys));
+ return SqliteTable::Schema(std::move(columns), std::move(primary_keys));
}
size_t StorageSchema::ColumnIndexFromName(const std::string& name) const {
diff --git a/src/trace_processor/storage_schema.h b/src/trace_processor/storage_schema.h
index 86895ce..3420a10 100644
--- a/src/trace_processor/storage_schema.h
+++ b/src/trace_processor/storage_schema.h
@@ -23,9 +23,9 @@
#include <vector>
#include "src/trace_processor/filtered_row_index.h"
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/sqlite_utils.h"
#include "src/trace_processor/storage_columns.h"
-#include "src/trace_processor/table.h"
#include "src/trace_processor/trace_storage.h"
namespace perfetto {
@@ -103,7 +103,7 @@
StorageSchema();
StorageSchema(Columns columns, std::vector<std::string> primary_keys);
- Table::Schema ToTableSchema();
+ SqliteTable::Schema ToTableSchema();
size_t ColumnIndexFromName(const std::string& name) const;
diff --git a/src/trace_processor/storage_table.cc b/src/trace_processor/storage_table.cc
index 821a394..8cac8b2 100644
--- a/src/trace_processor/storage_table.cc
+++ b/src/trace_processor/storage_table.cc
@@ -28,7 +28,7 @@
return util::OkStatus();
}
-std::unique_ptr<Table::Cursor> StorageTable::CreateCursor() {
+std::unique_ptr<SqliteTable::Cursor> StorageTable::CreateCursor() {
return std::unique_ptr<Cursor>(new Cursor(this));
}
@@ -167,7 +167,7 @@
}
StorageTable::Cursor::Cursor(StorageTable* table)
- : Table::Cursor(table), table_(table) {}
+ : SqliteTable::Cursor(table), table_(table) {}
int StorageTable::Cursor::Filter(const QueryConstraints& qc,
sqlite3_value** argv) {
diff --git a/src/trace_processor/storage_table.h b/src/trace_processor/storage_table.h
index 6474748..d996ac1 100644
--- a/src/trace_processor/storage_table.h
+++ b/src/trace_processor/storage_table.h
@@ -18,25 +18,25 @@
#include <set>
#include "src/trace_processor/row_iterators.h"
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/storage_columns.h"
#include "src/trace_processor/storage_schema.h"
-#include "src/trace_processor/table.h"
namespace perfetto {
namespace trace_processor {
// Base class for all table implementations which are backed by some data
// storage.
-class StorageTable : public Table {
+class StorageTable : public SqliteTable {
public:
// A cursor which abstracts common patterns found in storage backed tables. It
// takes a strategy to iterate through rows and a column reporter for each
// column to implement the Cursor interface.
- class Cursor final : public Table::Cursor {
+ class Cursor final : public SqliteTable::Cursor {
public:
Cursor(StorageTable* table);
- // Implementation of Table::Cursor.
+ // Implementation of SqliteTable::Cursor.
int Filter(const QueryConstraints& qc, sqlite3_value** argv) override;
int Next() override;
int Eof() override;
@@ -52,8 +52,10 @@
virtual ~StorageTable() override;
// Table implementation.
- util::Status Init(int, const char* const*, Table::Schema*) override final;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ util::Status Init(int,
+ const char* const*,
+ SqliteTable::Schema*) override final;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
// Required methods for subclasses to implement.
virtual StorageSchema CreateStorageSchema() = 0;
diff --git a/src/trace_processor/thread_table.cc b/src/trace_processor/thread_table.cc
index d1d5041..58a3fd5 100644
--- a/src/trace_processor/thread_table.cc
+++ b/src/trace_processor/thread_table.cc
@@ -33,25 +33,25 @@
: storage_(storage) {}
void ThreadTable::RegisterTable(sqlite3* db, const TraceStorage* storage) {
- Table::Register<ThreadTable>(db, storage, "thread");
+ SqliteTable::Register<ThreadTable>(db, storage, "thread");
}
util::Status ThreadTable::Init(int, const char* const*, Schema* schema) {
*schema = Schema(
{
- Table::Column(Column::kUtid, "utid", ColumnType::kInt),
- Table::Column(Column::kUpid, "upid", ColumnType::kInt),
- Table::Column(Column::kName, "name", ColumnType::kString),
- Table::Column(Column::kTid, "tid", ColumnType::kInt),
- Table::Column(Column::kStartTs, "start_ts", ColumnType::kLong),
- Table::Column(Column::kEndTs, "end_ts", ColumnType::kLong),
+ SqliteTable::Column(Column::kUtid, "utid", ColumnType::kInt),
+ SqliteTable::Column(Column::kUpid, "upid", ColumnType::kInt),
+ SqliteTable::Column(Column::kName, "name", ColumnType::kString),
+ SqliteTable::Column(Column::kTid, "tid", ColumnType::kInt),
+ SqliteTable::Column(Column::kStartTs, "start_ts", ColumnType::kLong),
+ SqliteTable::Column(Column::kEndTs, "end_ts", ColumnType::kLong),
},
{Column::kUtid});
return util::OkStatus();
}
-std::unique_ptr<Table::Cursor> ThreadTable::CreateCursor() {
- return std::unique_ptr<Table::Cursor>(new Cursor(this));
+std::unique_ptr<SqliteTable::Cursor> ThreadTable::CreateCursor() {
+ return std::unique_ptr<SqliteTable::Cursor>(new Cursor(this));
}
int ThreadTable::BestIndex(const QueryConstraints& qc, BestIndexInfo* info) {
@@ -69,7 +69,7 @@
}
ThreadTable::Cursor::Cursor(ThreadTable* table)
- : Table::Cursor(table), storage_(table->storage_), table_(table) {}
+ : SqliteTable::Cursor(table), storage_(table->storage_), table_(table) {}
int ThreadTable::Cursor::Filter(const QueryConstraints& qc,
sqlite3_value** argv) {
diff --git a/src/trace_processor/thread_table.h b/src/trace_processor/thread_table.h
index b140db9..705a9e3 100644
--- a/src/trace_processor/thread_table.h
+++ b/src/trace_processor/thread_table.h
@@ -20,7 +20,7 @@
#include <limits>
#include <memory>
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/trace_storage.h"
namespace perfetto {
@@ -28,7 +28,7 @@
// The implementation of the SQLite table containing each unique process with
// the metadata for those processes.
-class ThreadTable : public Table {
+class ThreadTable : public SqliteTable {
public:
enum Column {
kUtid = 0,
@@ -38,7 +38,7 @@
kStartTs = 4,
kEndTs = 5,
};
- class Cursor : public Table::Cursor {
+ class Cursor : public SqliteTable::Cursor {
public:
Cursor(ThreadTable* table);
@@ -69,8 +69,8 @@
ThreadTable(sqlite3*, const TraceStorage*);
// Table implementation.
- util::Status Init(int, const char* const*, Table::Schema*) override;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ util::Status Init(int, const char* const*, SqliteTable::Schema*) override;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
int BestIndex(const QueryConstraints&, BestIndexInfo*) override;
private:
diff --git a/src/trace_processor/trace_processor.cc b/src/trace_processor/trace_processor.cc
index ac1b7c4..b4de729 100644
--- a/src/trace_processor/trace_processor.cc
+++ b/src/trace_processor/trace_processor.cc
@@ -15,7 +15,8 @@
*/
#include "perfetto/trace_processor/trace_processor.h"
-#include "src/trace_processor/table.h"
+
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/trace_processor_impl.h"
namespace perfetto {
@@ -62,7 +63,7 @@
void EnableSQLiteVtableDebugging() {
// This level of indirection is required to avoid clients to depend on table.h
// which in turn requires sqlite headers.
- Table::debug = true;
+ SqliteTable::debug = true;
}
} // namespace trace_processor
} // namespace perfetto
diff --git a/src/trace_processor/trace_processor_impl.cc b/src/trace_processor/trace_processor_impl.cc
index 79154c7..710c770 100644
--- a/src/trace_processor/trace_processor_impl.cc
+++ b/src/trace_processor/trace_processor_impl.cc
@@ -58,11 +58,11 @@
#include "src/trace_processor/span_join_operator_table.h"
#include "src/trace_processor/sql_stats_table.h"
#include "src/trace_processor/sqlite3_str_split.h"
+#include "src/trace_processor/sqlite_table.h"
#include "src/trace_processor/stats_table.h"
#include "src/trace_processor/syscall_tracker.h"
#include "src/trace_processor/systrace_parser.h"
#include "src/trace_processor/systrace_trace_parser.h"
-#include "src/trace_processor/table.h"
#include "src/trace_processor/thread_table.h"
#include "src/trace_processor/trace_blob_view.h"
#include "src/trace_processor/trace_sorter.h"
diff --git a/src/trace_processor/window_operator_table.cc b/src/trace_processor/window_operator_table.cc
index b2ce9ef..03f3109 100644
--- a/src/trace_processor/window_operator_table.cc
+++ b/src/trace_processor/window_operator_table.cc
@@ -29,7 +29,7 @@
void WindowOperatorTable::RegisterTable(sqlite3* db,
const TraceStorage* storage) {
- Table::Register<WindowOperatorTable>(db, storage, "window", true);
+ SqliteTable::Register<WindowOperatorTable>(db, storage, "window", true);
}
util::Status WindowOperatorTable::Init(int,
@@ -39,24 +39,26 @@
*schema = Schema(
{
// These are the operator columns:
- Table::Column(Column::kRowId, "rowid", ColumnType::kLong, kHidden),
- Table::Column(Column::kQuantum, "quantum", ColumnType::kLong,
- kHidden),
- Table::Column(Column::kWindowStart, "window_start", ColumnType::kLong,
- kHidden),
- Table::Column(Column::kWindowDur, "window_dur", ColumnType::kLong,
- kHidden),
+ SqliteTable::Column(Column::kRowId, "rowid", ColumnType::kLong,
+ kHidden),
+ SqliteTable::Column(Column::kQuantum, "quantum", ColumnType::kLong,
+ kHidden),
+ SqliteTable::Column(Column::kWindowStart, "window_start",
+ ColumnType::kLong, kHidden),
+ SqliteTable::Column(Column::kWindowDur, "window_dur",
+ ColumnType::kLong, kHidden),
// These are the ouput columns:
- Table::Column(Column::kTs, "ts", ColumnType::kLong),
- Table::Column(Column::kDuration, "dur", ColumnType::kLong),
- Table::Column(Column::kQuantumTs, "quantum_ts", ColumnType::kLong),
+ SqliteTable::Column(Column::kTs, "ts", ColumnType::kLong),
+ SqliteTable::Column(Column::kDuration, "dur", ColumnType::kLong),
+ SqliteTable::Column(Column::kQuantumTs, "quantum_ts",
+ ColumnType::kLong),
},
{Column::kRowId});
return util::OkStatus();
}
-std::unique_ptr<Table::Cursor> WindowOperatorTable::CreateCursor() {
- return std::unique_ptr<Table::Cursor>(new Cursor(this));
+std::unique_ptr<SqliteTable::Cursor> WindowOperatorTable::CreateCursor() {
+ return std::unique_ptr<SqliteTable::Cursor>(new Cursor(this));
}
int WindowOperatorTable::BestIndex(const QueryConstraints& qc,
@@ -95,7 +97,7 @@
}
WindowOperatorTable::Cursor::Cursor(WindowOperatorTable* table)
- : Table::Cursor(table), table_(table) {}
+ : SqliteTable::Cursor(table), table_(table) {}
int WindowOperatorTable::Cursor::Filter(const QueryConstraints& qc,
sqlite3_value** argv) {
diff --git a/src/trace_processor/window_operator_table.h b/src/trace_processor/window_operator_table.h
index e719c1e..8dc1e5a 100644
--- a/src/trace_processor/window_operator_table.h
+++ b/src/trace_processor/window_operator_table.h
@@ -20,14 +20,14 @@
#include <limits>
#include <memory>
-#include "src/trace_processor/table.h"
+#include "src/trace_processor/sqlite_table.h"
namespace perfetto {
namespace trace_processor {
class TraceStorage;
-class WindowOperatorTable : public Table {
+class WindowOperatorTable : public SqliteTable {
public:
enum Column {
kRowId = 0,
@@ -38,11 +38,11 @@
kDuration = 5,
kQuantumTs = 6
};
- class Cursor : public Table::Cursor {
+ class Cursor : public SqliteTable::Cursor {
public:
Cursor(WindowOperatorTable*);
- // Implementation of Table::Cursor.
+ // Implementation of SqliteTable::Cursor.
int Filter(const QueryConstraints& qc, sqlite3_value**) override;
int Next() override;
int Eof() override;
@@ -76,7 +76,7 @@
// Table implementation.
util::Status Init(int, const char* const*, Schema* schema) override;
- std::unique_ptr<Table::Cursor> CreateCursor() override;
+ std::unique_ptr<SqliteTable::Cursor> CreateCursor() override;
int BestIndex(const QueryConstraints&, BestIndexInfo*) override;
int Update(int, sqlite3_value**, sqlite3_int64*) override;