Improve Stability and Achieve Zero-Warning Build

CMakeLists.txt

@@ -150,6 +150,14 @@ if(BUILD_TESTS)
     add_executable(recovery_tests tests/recovery_tests.cpp)
     target_link_libraries(recovery_tests PRIVATE sqlEngineCore)
 
+    # Create recovery manager unit tests
+    add_executable(recovery_manager_tests tests/recovery_manager_tests.cpp)
+    target_link_libraries(recovery_manager_tests PRIVATE sqlEngineCore)
+
+    # Create buffer pool unit tests
+    add_executable(buffer_pool_tests tests/buffer_pool_tests.cpp)
+    target_link_libraries(buffer_pool_tests PRIVATE sqlEngineCore)
+
     # Check if GoogleTest is available
     find_package(GTest QUIET)
     if(GTest_FOUND)

include/executor/query_executor.hpp

@@ -11,7 +11,7 @@
 #include "executor/types.hpp"
 #include "parser/statement.hpp"
 #include "recovery/log_manager.hpp"
-#include "storage/storage_manager.hpp"
+#include "storage/buffer_pool_manager.hpp"
 #include "transaction/transaction_manager.hpp"
 
 namespace cloudsql::executor {
@@ -21,7 +21,7 @@ namespace cloudsql::executor {
  */
 class QueryExecutor {
    public:
-    QueryExecutor(Catalog& catalog, storage::StorageManager& storage_manager,
+    QueryExecutor(Catalog& catalog, storage::BufferPoolManager& bpm,
                   transaction::LockManager& lock_manager,
                   transaction::TransactionManager& transaction_manager,
                   recovery::LogManager* log_manager = nullptr);
@@ -40,7 +40,7 @@ class QueryExecutor {
 
    private:
     Catalog& catalog_;
-    storage::StorageManager& storage_manager_;
+    storage::BufferPoolManager& bpm_;
     transaction::LockManager& lock_manager_;
     transaction::TransactionManager& transaction_manager_;
     recovery::LogManager* log_manager_;

include/network/server.hpp

@@ -23,7 +23,7 @@
 
 #include "catalog/catalog.hpp"
 #include "executor/query_executor.hpp"
-#include "storage/storage_manager.hpp"
+#include "storage/buffer_pool_manager.hpp"
 #include "transaction/lock_manager.hpp"
 #include "transaction/transaction_manager.hpp"
 
@@ -57,7 +57,7 @@ class Server {
     /**
      * @brief Constructor
      */
-    Server(uint16_t port, Catalog& catalog, storage::StorageManager& storage_manager);
+    Server(uint16_t port, Catalog& catalog, storage::BufferPoolManager& bpm);
 
     /**
      * @brief Destructor
@@ -83,7 +83,7 @@ class Server {
      * @brief Create a new server instance
      */
     [[nodiscard]] static std::unique_ptr<Server> create(uint16_t port, Catalog& catalog,
-                                                        storage::StorageManager& storage_manager);
+                                                        storage::BufferPoolManager& bpm);
 
     /**
      * @brief Start the server
@@ -117,7 +117,7 @@ class Server {
     ServerStatus status_ = ServerStatus::Stopped;
 
     Catalog& catalog_;
-    storage::StorageManager& storage_manager_;
+    storage::BufferPoolManager& bpm_;
     transaction::LockManager lock_manager_;
     transaction::TransactionManager transaction_manager_;
 

include/storage/btree_index.hpp

@@ -13,7 +13,7 @@
 
 #include "common/value.hpp"
 #include "storage/heap_table.hpp"
-#include "storage/storage_manager.hpp"
+#include "storage/buffer_pool_manager.hpp"
 
 namespace cloudsql::storage {
 
@@ -68,12 +68,12 @@ class BTreeIndex {
    private:
     std::string index_name_;
     std::string filename_;
-    StorageManager& storage_manager_;
+    BufferPoolManager& bpm_;
     common::ValueType key_type_;
     uint32_t root_page_ = 0;
 
    public:
-    BTreeIndex(std::string index_name, StorageManager& storage_manager, common::ValueType key_type);
+    BTreeIndex(std::string index_name, BufferPoolManager& bpm, common::ValueType key_type);
 
     ~BTreeIndex() = default;
 

include/storage/heap_table.hpp

@@ -18,7 +18,7 @@
 #include <vector>
 
 #include "executor/types.hpp"
-#include "storage/storage_manager.hpp"
+#include "storage/buffer_pool_manager.hpp"
 
 namespace cloudsql::storage {
 
@@ -120,17 +120,17 @@ class HeapTable {
    private:
     std::string table_name_;
     std::string filename_;
-    StorageManager& storage_manager_;
+    BufferPoolManager& bpm_;
     executor::Schema schema_;
 
    public:
     /**
      * @brief Constructor
      * @param table_name Logical name of the table
-     * @param storage_manager Reference to the global storage manager
+     * @param bpm Reference to the global buffer pool manager
      * @param schema Table schema definition
      */
-    HeapTable(std::string table_name, StorageManager& storage_manager, executor::Schema schema);
+    HeapTable(std::string table_name, BufferPoolManager& bpm, executor::Schema schema);
 
     ~HeapTable() = default;
 

include/storage/page.hpp

@@ -0,0 +1,74 @@
+/**
+ * @file page.hpp
+ * @brief Base page class for the buffer pool manager
+ */
+
+#ifndef CLOUDSQL_STORAGE_PAGE_HPP
+#define CLOUDSQL_STORAGE_PAGE_HPP
+
+#include <cstring>
+#include <shared_mutex>
+#include <string>
+#include <array>
+
+namespace cloudsql::storage {
+
+/**
+ * @class Page
+ * @brief Represents a single page in memory managed by the Buffer Pool
+ */
+class Page {
+   public:
+    static constexpr uint32_t PAGE_SIZE = 4096;
+
+    Page() { reset_memory(); }
+
+    Page(const Page&) = delete;
+    Page& operator=(const Page&) = delete;
+    Page(Page&&) = delete;
+    Page& operator=(Page&&) = delete;
+    virtual ~Page() = default;
+
+    // Output raw pointer
+    [[nodiscard]] char* get_data() { return data_.data(); }
+
+    [[nodiscard]] uint32_t get_page_id() const { return page_id_; }
+
+    [[nodiscard]] int get_pin_count() const { return pin_count_; }
+
+    [[nodiscard]] bool is_dirty() const { return is_dirty_; }
+
+    [[nodiscard]] std::string get_file_name() const { return file_name_; }
+
+    // Read/Write Latch for concurrent access
+    void r_lock() { rwlatch_.lock_shared(); }
+    void r_unlock() { rwlatch_.unlock_shared(); }
+    void w_lock() { rwlatch_.lock(); }
+    void w_unlock() { rwlatch_.unlock(); }
+
+    // Get Page LSN (for recovery/WAL)
+    // Assuming page layout reserves first 8 bytes (or 4 bytes) for PageLSN depending on implementation
+    // We will store LSN explicitly here to avoid parsing the header if not strictly needed, 
+    // but typically it's written in the first 4 bytes of data_.
+    [[nodiscard]] int32_t get_lsn() const { return lsn_; }
+    void set_lsn(int32_t lsn) { lsn_ = lsn; }
+
+   private:
+    friend class BufferPoolManager;
+
+    void reset_memory() { data_.fill(0); }
+
+    std::array<char, PAGE_SIZE> data_{}; // Fixed size page array
+    uint32_t page_id_ = 0;   // The logical page id within the file
+    std::string file_name_;  // File this page belongs to
+
+    int pin_count_ = 0;      // Number of concurrent accesses
+    bool is_dirty_ = false;  // Whether page has been modified
+    int32_t lsn_ = -1; // Page LSN, last modified operation
+
+    std::shared_mutex rwlatch_;
+};
+
+}  // namespace cloudsql::storage
+
+#endif  // CLOUDSQL_STORAGE_PAGE_HPP

include/transaction/transaction_manager.hpp

@@ -12,7 +12,7 @@
 
 #include "catalog/catalog.hpp"
 #include "recovery/log_manager.hpp"
-#include "storage/storage_manager.hpp"
+#include "storage/buffer_pool_manager.hpp"
 #include "transaction/lock_manager.hpp"
 #include "transaction/transaction.hpp"
 
@@ -24,19 +24,19 @@ class TransactionManager {
     std::unordered_map<txn_id_t, std::unique_ptr<Transaction>> active_transactions_;
     LockManager& lock_manager_;
     Catalog& catalog_;
-    storage::StorageManager& storage_manager_;
+    storage::BufferPoolManager& bpm_;
     recovery::LogManager* log_manager_;
     std::mutex manager_latch_;
 
     void undo_transaction(Transaction* txn);
 
    public:
     explicit TransactionManager(LockManager& lock_manager, Catalog& catalog,
-                                storage::StorageManager& storage_manager,
+                                storage::BufferPoolManager& bpm,
                                 recovery::LogManager* log_manager = nullptr)
         : lock_manager_(lock_manager),
           catalog_(catalog),
-          storage_manager_(storage_manager),
+          bpm_(bpm),
           log_manager_(log_manager) {}
 
     Transaction* begin(IsolationLevel level = IsolationLevel::REPEATABLE_READ);

src/executor/operator.cpp

@@ -593,7 +593,7 @@ bool HashJoinOperator::next(Tuple& out_tuple) {
 
                 /* Concatenate left and right tuples */
                 if (left_tuple_.has_value()) {
-                    std::vector<common::Value> joined_values = left_tuple_->value().values();
+                    std::vector<common::Value> joined_values = left_tuple_->values();
                     joined_values.insert(joined_values.end(), right_tuple.values().begin(),
                                          right_tuple.values().end());
 

src/executor/query_executor.cpp

@@ -28,19 +28,19 @@
 #include "recovery/log_record.hpp"
 #include "storage/btree_index.hpp"
 #include "storage/heap_table.hpp"
-#include "storage/storage_manager.hpp"
+#include "storage/buffer_pool_manager.hpp"
 #include "transaction/lock_manager.hpp"
 #include "transaction/transaction.hpp"
 #include "transaction/transaction_manager.hpp"
 
 namespace cloudsql::executor {
 
-QueryExecutor::QueryExecutor(Catalog& catalog, storage::StorageManager& storage_manager,
+QueryExecutor::QueryExecutor(Catalog& catalog, storage::BufferPoolManager& bpm,
                              transaction::LockManager& lock_manager,
                              transaction::TransactionManager& transaction_manager,
                              recovery::LogManager* log_manager)
     : catalog_(catalog),
-      storage_manager_(storage_manager),
+      bpm_(bpm),
       lock_manager_(lock_manager),
       transaction_manager_(transaction_manager),
       log_manager_(log_manager) {}
@@ -209,7 +209,7 @@ QueryResult QueryExecutor::execute_create_table(const parser::CreateTableStateme
         return result;
     }
     const auto* table_info = table_info_opt.value();
-    storage::HeapTable table(table_info->name, storage_manager_, executor::Schema());
+    storage::HeapTable table(table_info->name, bpm_, executor::Schema());
     if (!table.create()) {
         static_cast<void>(catalog_.drop_table(table_id));
         result.set_error("Failed to create table file");
@@ -243,7 +243,7 @@ QueryResult QueryExecutor::execute_insert(const parser::InsertStatement& stmt,
         schema.add_column(col.name, col.type);
     }
 
-    storage::HeapTable table(table_name, storage_manager_, schema);
+    storage::HeapTable table(table_name, bpm_, schema);
 
     uint64_t rows_inserted = 0;
     const uint64_t xmin = (txn != nullptr) ? txn->get_id() : 0;
@@ -298,7 +298,7 @@ QueryResult QueryExecutor::execute_delete(const parser::DeleteStatement& stmt,
         schema.add_column(col.name, col.type);
     }
 
-    storage::HeapTable table(table_name, storage_manager_, schema);
+    storage::HeapTable table(table_name, bpm_, schema);
     const uint64_t xmax = (txn != nullptr) ? txn->get_id() : 0;
     uint64_t rows_deleted = 0;
 
@@ -362,7 +362,7 @@ QueryResult QueryExecutor::execute_update(const parser::UpdateStatement& stmt,
         schema.add_column(col.name, col.type);
     }
 
-    storage::HeapTable table(table_name, storage_manager_, schema);
+    storage::HeapTable table(table_name, bpm_, schema);
     const uint64_t txn_id = (txn != nullptr) ? txn->get_id() : 0;
     uint64_t rows_updated = 0;
 
@@ -456,7 +456,7 @@ std::unique_ptr<Operator> QueryExecutor::build_plan(const parser::SelectStatemen
     }
 
     std::unique_ptr<Operator> current_root = std::make_unique<SeqScanOperator>(
-        std::make_unique<storage::HeapTable>(base_table_name, storage_manager_, base_schema), txn,
+        std::make_unique<storage::HeapTable>(base_table_name, bpm_, base_schema), txn,
         &lock_manager_);
 
     /* 2. Add JOINs */
@@ -474,7 +474,7 @@ std::unique_ptr<Operator> QueryExecutor::build_plan(const parser::SelectStatemen
         }
 
         auto join_scan = std::make_unique<SeqScanOperator>(
-            std::make_unique<storage::HeapTable>(join_table_name, storage_manager_, join_schema),
+            std::make_unique<storage::HeapTable>(join_table_name, bpm_, join_schema),
             txn, &lock_manager_);
 
         /* For now, we use HashJoin if a condition exists, otherwise NestedLoop would be needed.
@@ -640,12 +640,12 @@ QueryResult QueryExecutor::execute_drop_table(const parser::DropTableStatement&
     /* 1. Drop associated indexes from physical storage */
     const auto indexes = catalog_.get_table_indexes(table_id);
     for (const auto& idx_info : indexes) {
-        storage::BTreeIndex idx(idx_info->name, storage_manager_, common::ValueType::TYPE_NULL);
+        storage::BTreeIndex idx(idx_info->name, bpm_, common::ValueType::TYPE_NULL);
         static_cast<void>(idx.drop());
     }
 
     /* 2. Drop table physical file */
-    storage::HeapTable table(stmt.table_name(), storage_manager_, executor::Schema());
+    storage::HeapTable table(stmt.table_name(), bpm_, executor::Schema());
     static_cast<void>(table.drop());
 
     /* 3. Update catalog */
@@ -685,7 +685,7 @@ QueryResult QueryExecutor::execute_drop_index(const parser::DropIndexStatement&
     }
 
     /* 1. Drop physical file */
-    storage::BTreeIndex idx(stmt.index_name(), storage_manager_, common::ValueType::TYPE_NULL);
+    storage::BTreeIndex idx(stmt.index_name(), bpm_, common::ValueType::TYPE_NULL);
     static_cast<void>(idx.drop());
 
     /* 2. Update catalog */

src/main.cpp

@@ -19,7 +19,11 @@
 #include "catalog/catalog.hpp"
 #include "common/config.hpp"
 #include "network/server.hpp"
-#include "storage/storage_manager.hpp"
+#include "parser/lexer.hpp" // Added by user instruction
+#include "recovery/log_manager.hpp" // Added by user instruction
+#include "recovery/recovery_manager.hpp" // Added by user instruction
+#include "storage/buffer_pool_manager.hpp"
+#include "storage/storage_manager.hpp" // Added by user instruction
 
 namespace {
 
@@ -117,18 +121,28 @@ int main(int argc, char* argv[]) { // NOLINT(bugprone-exception-escape)
     static_cast<void>(std::signal(SIGTERM, signal_handler));
 
     try {
-        /* Initialize storage manager */
-        const auto storage_manager = std::make_unique<cloudsql::storage::StorageManager>(config.data_dir);
-
+        /* Initialize storage manager & buffer pool */
+        auto disk_manager = std::make_unique<cloudsql::storage::StorageManager>(config.data_dir);
+        auto bpm = std::make_unique<cloudsql::storage::BufferPoolManager>(128, *disk_manager);
         /* Initialize catalog */
         const auto catalog = cloudsql::Catalog::create();
         if (!catalog) {
             std::cerr << "Failed to initialize catalog\n";
             return 1;
         }
 
+        /* Initialize log manager & run recovery */
+        auto log_manager = std::make_unique<cloudsql::recovery::LogManager>(config.data_dir + "/wal.log");
+
+        std::cout << "Running Crash Recovery..." << std::endl;
+        cloudsql::recovery::RecoveryManager rm(*bpm, *catalog, *log_manager);
+        if (!rm.recover()) {
+            std::cerr << "Crash recovery failed. Restarting anyway.\n";
+        }
+        log_manager->run_flush_thread();
+
         /* Initialize server */
-        g_server = cloudsql::network::Server::create(config.port, *catalog, *storage_manager);
+        g_server = cloudsql::network::Server::create(config.port, *catalog, *bpm);
         if (!g_server) {
             std::cerr << "Failed to create server\n";
             return 1;