/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#ifndef SRC_TRACE_PROCESSOR_TABLE_H_
|
#define SRC_TRACE_PROCESSOR_TABLE_H_
|
|
#include <sqlite3.h>
|
|
#include <functional>
|
#include <memory>
|
#include <string>
|
#include <vector>
|
|
#include "perfetto/base/optional.h"
|
#include "src/trace_processor/query_constraints.h"
|
|
namespace perfetto {
|
namespace trace_processor {
|
|
class TraceStorage;
|
|
// 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 {
|
public:
|
using Factory =
|
std::function<std::unique_ptr<Table>(sqlite3*, const TraceStorage*)>;
|
|
// Allowed types for columns in a table.
|
enum ColumnType {
|
kString = 1,
|
kUint = 2,
|
kLong = 3,
|
kInt = 4,
|
kDouble = 5,
|
kUnknown = 6,
|
};
|
|
// Describes a column of this table.
|
class Column {
|
public:
|
Column(size_t idx, std::string name, ColumnType type, bool hidden = false);
|
|
size_t index() const { return index_; }
|
const std::string& name() const { return name_; }
|
ColumnType type() const { return type_; }
|
bool hidden() const { return hidden_; }
|
|
private:
|
size_t index_ = 0;
|
std::string name_;
|
ColumnType type_ = ColumnType::kString;
|
bool hidden_ = false;
|
};
|
|
// When set it logs all BestIndex and Filter actions on the console.
|
static bool debug;
|
|
// Public for unique_ptr destructor calls.
|
virtual ~Table();
|
|
// 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);
|
virtual ~Cursor();
|
|
// Methods to be implemented by derived table classes.
|
|
// Called to intialise the cursor with the constraints of the query.
|
virtual int Filter(const QueryConstraints& qc, sqlite3_value**) = 0;
|
|
// Called to forward the cursor to the next row in the table.
|
virtual int Next() = 0;
|
|
// Called to check if the cursor has reached eof. Column will be called iff
|
// this method returns true.
|
virtual int Eof() = 0;
|
|
// Used to extract the value from the column at index |N|.
|
virtual int Column(sqlite3_context* context, int N) = 0;
|
|
// Optional methods to implement.
|
virtual int RowId(sqlite3_int64*);
|
|
protected:
|
Cursor(Cursor&) = delete;
|
Cursor& operator=(const Cursor&) = delete;
|
|
Cursor(Cursor&&) noexcept = default;
|
Cursor& operator=(Cursor&&) = default;
|
|
private:
|
friend class Table;
|
|
Table* table_ = nullptr;
|
};
|
|
// The schema of the table. Created by subclasses to allow the table class to
|
// do filtering and inform SQLite about the CREATE table statement.
|
class Schema {
|
public:
|
Schema();
|
Schema(std::vector<Column>, std::vector<size_t> primary_keys);
|
|
// This class is explicitly copiable.
|
Schema(const Schema&);
|
Schema& operator=(const Schema& t);
|
|
std::string ToCreateTableStmt() const;
|
|
const std::vector<Column>& columns() const { return columns_; }
|
const std::vector<size_t> primary_keys() { return primary_keys_; }
|
|
private:
|
// The names and types of the columns of the table.
|
std::vector<Column> columns_;
|
|
// The primary keys of the table given by an offset into |columns|.
|
std::vector<size_t> primary_keys_;
|
};
|
|
protected:
|
// Populated by a BestIndex call to allow subclasses to tweak SQLite's
|
// handling of sets of constraints.
|
struct BestIndexInfo {
|
bool order_by_consumed = false;
|
uint32_t estimated_cost = 0;
|
std::vector<bool> omit;
|
};
|
|
struct TableDescriptor {
|
Table::Factory factory;
|
const TraceStorage* storage = nullptr;
|
std::string name;
|
sqlite3_module module = {};
|
};
|
|
Table();
|
|
// Called by derived classes to register themselves with the SQLite db.
|
// |read_write| specifies whether the table can also be written to.
|
// |requires_args| should be true if the table requires arguments in order to
|
// be instantiated.
|
// Note: this function is inlined here because we use the TTable template to
|
// devirtualise the function calls.
|
template <typename TTable>
|
static void Register(sqlite3* db,
|
const TraceStorage* storage,
|
const std::string& table_name,
|
bool read_write = false,
|
bool requires_args = false) {
|
using TCursor = typename TTable::Cursor;
|
|
std::unique_ptr<TableDescriptor> desc(new TableDescriptor());
|
desc->storage = storage;
|
desc->factory = GetFactory<TTable>();
|
desc->name = table_name;
|
sqlite3_module* module = &desc->module;
|
memset(module, 0, sizeof(*module));
|
|
auto create_fn = [](sqlite3* xdb, void* arg, int argc,
|
const char* const* argv, sqlite3_vtab** tab, char**) {
|
const TableDescriptor* xdesc = static_cast<const TableDescriptor*>(arg);
|
auto table = xdesc->factory(xdb, xdesc->storage);
|
table->name_ = xdesc->name;
|
|
auto opt_schema = table->Init(argc, argv);
|
if (!opt_schema.has_value()) {
|
PERFETTO_ELOG("Failed to create schema (table %s)",
|
xdesc->name.c_str());
|
return SQLITE_ERROR;
|
}
|
|
const auto& schema = opt_schema.value();
|
auto create_stmt = schema.ToCreateTableStmt();
|
PERFETTO_DLOG("Create table statement: %s", create_stmt.c_str());
|
|
int res = sqlite3_declare_vtab(xdb, create_stmt.c_str());
|
if (res != SQLITE_OK)
|
return res;
|
|
// Freed in xDisconnect().
|
table->schema_ = std::move(schema);
|
*tab = table.release();
|
|
return SQLITE_OK;
|
};
|
auto destroy_fn = [](sqlite3_vtab* t) {
|
delete static_cast<TTable*>(t);
|
return SQLITE_OK;
|
};
|
|
module->xCreate = create_fn;
|
module->xConnect = create_fn;
|
module->xDisconnect = destroy_fn;
|
module->xDestroy = destroy_fn;
|
module->xOpen = [](sqlite3_vtab* t, sqlite3_vtab_cursor** c) {
|
return static_cast<TTable*>(t)->OpenInternal(c);
|
};
|
module->xClose = [](sqlite3_vtab_cursor* c) {
|
delete static_cast<TCursor*>(c);
|
return SQLITE_OK;
|
};
|
module->xBestIndex = [](sqlite3_vtab* t, sqlite3_index_info* i) {
|
return static_cast<TTable*>(t)->BestIndexInternal(i);
|
};
|
module->xFilter = [](sqlite3_vtab_cursor* c, int i, const char* s, int a,
|
sqlite3_value** v) {
|
const auto& qc =
|
static_cast<Cursor*>(c)->table_->ParseConstraints(i, s, a);
|
return static_cast<TCursor*>(c)->Filter(qc, v);
|
};
|
module->xNext = [](sqlite3_vtab_cursor* c) {
|
return static_cast<TCursor*>(c)->Next();
|
};
|
module->xEof = [](sqlite3_vtab_cursor* c) {
|
return static_cast<TCursor*>(c)->Eof();
|
};
|
module->xColumn = [](sqlite3_vtab_cursor* c, sqlite3_context* a, int b) {
|
return static_cast<TCursor*>(c)->Column(a, b);
|
};
|
module->xRowid = [](sqlite3_vtab_cursor* c, sqlite3_int64* r) {
|
return static_cast<TCursor*>(c)->RowId(r);
|
};
|
module->xFindFunction =
|
[](sqlite3_vtab* t, int, const char* name,
|
void (**fn)(sqlite3_context*, int, sqlite3_value**), void** args) {
|
return static_cast<TTable*>(t)->FindFunction(name, fn, args);
|
};
|
|
if (read_write) {
|
module->xUpdate = [](sqlite3_vtab* t, int a, sqlite3_value** v,
|
sqlite3_int64* r) {
|
return static_cast<TTable*>(t)->Update(a, v, r);
|
};
|
}
|
|
int res = sqlite3_create_module_v2(
|
db, table_name.c_str(), module, desc.release(),
|
[](void* arg) { delete static_cast<TableDescriptor*>(arg); });
|
PERFETTO_CHECK(res == SQLITE_OK);
|
|
// Register virtual tables into an internal 'perfetto_tables' table. This is
|
// used for iterating through all the tables during a database export. Note
|
// that virtual tables requiring arguments aren't registered because they
|
// can't be automatically instantiated for exporting.
|
if (!requires_args) {
|
char* insert_sql = sqlite3_mprintf(
|
"INSERT INTO perfetto_tables(name) VALUES('%q')", table_name.c_str());
|
char* error = nullptr;
|
sqlite3_exec(db, insert_sql, 0, 0, &error);
|
sqlite3_free(insert_sql);
|
if (error) {
|
PERFETTO_ELOG("Error registering table: %s", error);
|
sqlite3_free(error);
|
}
|
}
|
}
|
|
// Methods to be implemented by derived table classes.
|
virtual base::Optional<Schema> Init(int argc, const char* const* argv) = 0;
|
virtual std::unique_ptr<Cursor> CreateCursor() = 0;
|
virtual int BestIndex(const QueryConstraints& qc, BestIndexInfo* info) = 0;
|
|
// Optional metods to implement.
|
using FindFunctionFn = void (**)(sqlite3_context*, int, sqlite3_value**);
|
virtual int FindFunction(const char* name, FindFunctionFn fn, void** args);
|
|
// At registration time, the function should also pass true for |read_write|.
|
virtual int Update(int, sqlite3_value**, sqlite3_int64*);
|
|
void SetErrorMessage(char* error) {
|
sqlite3_free(zErrMsg);
|
zErrMsg = error;
|
}
|
|
const Schema& schema() const { return schema_; }
|
const std::string& name() const { return name_; }
|
|
private:
|
template <typename TableType>
|
static Factory GetFactory() {
|
return [](sqlite3* db, const TraceStorage* storage) {
|
return std::unique_ptr<Table>(new TableType(db, storage));
|
};
|
}
|
|
static void RegisterInternal(sqlite3* db,
|
const TraceStorage*,
|
const std::string& name,
|
bool read_write,
|
bool requires_args,
|
Factory);
|
|
const QueryConstraints& ParseConstraints(int idxNum,
|
const char* idxStr,
|
int argc);
|
|
// Overriden functions from sqlite3_vtab.
|
int OpenInternal(sqlite3_vtab_cursor**);
|
int BestIndexInternal(sqlite3_index_info*);
|
|
Table(const Table&) = delete;
|
Table& operator=(const Table&) = delete;
|
|
std::string name_;
|
Schema schema_;
|
|
QueryConstraints qc_cache_;
|
int qc_hash_ = 0;
|
int best_index_num_ = 0;
|
};
|
|
} // namespace trace_processor
|
} // namespace perfetto
|
|
#endif // SRC_TRACE_PROCESSOR_TABLE_H_
|
