blob: 409d12cf8c213484bd2e06e21a53d137bbf4f198 [file] [log] [blame]
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <atomic>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/check_op.h"
#include "base/optional.h"
#include "sql/recover_module/parsing.h"
#include "third_party/sqlite/sqlite3.h"
namespace sql {
namespace recover {
class VirtualCursor;
// Represents a virtual table created by CREATE VIRTUAL TABLE recover(...).
// Instances are allocated on the heap using the C++ new operator, and passed to
// SQLite via pointers to the sqlite_vtab members. SQLite is responsible for
// managing the instances' lifetimes. SQLite will call xDisconnect() for every
// successful xConnect(), and xDestroy() for every successful xCreate().
// Instances are thread-safe.
class VirtualTable {
// Returns a SQLite status and a VirtualTable instance.
// The VirtualTable is non-null iff the status is SQLITE_OK.
// SQLite is trusted to keep |sqlite_db| alive for as long as this instance
// lives.
static std::pair<int, std::unique_ptr<VirtualTable>> Create(
sqlite3* sqlite_db,
TargetTableSpec backing_table_spec,
std::vector<RecoveredColumnSpec> column_specs);
// Use Create() instead of calling the constructor directly.
explicit VirtualTable(sqlite3* sqlite_db,
sqlite3_file* sqlite_file,
int root_page,
int page_size,
std::vector<RecoveredColumnSpec> column_specs);
VirtualTable(const VirtualTable&) = delete;
VirtualTable& operator=(const VirtualTable&) = delete;
// Returns the embedded SQLite virtual table.
// This getter is not const because SQLite wants a non-const pointer to the
// structure.
sqlite3_vtab* SqliteTable() { return &sqlite_table_; }
// Returns SQLite VFS file used to access the backing table's database.
// This getter is not const because it must return a non-const pointer.
sqlite3_file* SqliteFile() { return sqlite_file_; }
// Returns the page number of the root page for the table's B-tree.
int root_page_id() const { return root_page_id_; }
// Returns the page size used by the backing table's database.
int page_size() const { return page_size_; }
// Returns the schema of the corrupted table being recovered.
const std::vector<RecoveredColumnSpec> column_specs() const {
return column_specs_;
// Returns a SQL statement describing the virtual table's schema.
// The return value is suitable to be passed to sqlite3_declare_vtab().
std::string ToCreateTableSql() const;
// The VirtualTable instance that embeds a given SQLite virtual table.
// |sqlite_table| must have been returned by VirtualTable::SqliteTable().
static inline VirtualTable* FromSqliteTable(sqlite3_vtab* sqlite_table) {
"needed for the reinterpret_cast below");
static_assert(offsetof(VirtualTable, sqlite_table_) == 0,
"sqlite_table_ must be the first member of the class");
VirtualTable* const result = reinterpret_cast<VirtualTable*>(sqlite_table);
DCHECK_EQ(sqlite_table, &result->sqlite_table_);
return result;
// Creates a new cursor for iterating over this table.
VirtualCursor* CreateCursor();
// Called right before a cursor belonging to this table will be destroyed.
void WillDeleteCursor(VirtualCursor* cursor);
// SQLite handle for this table. The struct is populated and used by SQLite.
sqlite3_vtab sqlite_table_;
// See the corresponding getters for these members' purpose.
sqlite3_file* const sqlite_file_;
const int root_page_id_;
const int page_size_;
const std::vector<RecoveredColumnSpec> column_specs_;
// Number of cursors that are still opened.
std::atomic<int> open_cursor_count_{0};
#endif // DCHECK_IS_ON()
} // namespace recover
} // namespace sql