TableIterator + SeqScan doneseqscan-franek

20 files changed, 142 insertions, 113 deletions

diff --git a/komfydb/config.h b/komfydb/config.h
index 7ea1f8c..a484677 100644
--- a/komfydb/config.h
+++ b/komfydb/config.h
@@ -2,6 +2,6 @@
 #define __KOMFYDB_CONFIG_H__
 
 #define CONFIG_PAGE_SIZE (1 << 12)
-#define CONFIG_BUFFER_POOL_PAGES_CNT 50
+#define CONFIG_BUFFER_POOL_PAGES_CNT 100
 
 #endif
diff --git a/komfydb/database.cc b/komfydb/database.cc
index 4161a66..361212e 100644
--- a/komfydb/database.cc
+++ b/komfydb/database.cc
@@ -75,7 +75,7 @@ absl::StatusOr<Type> GetType(std::string& type_str) {
 namespace komfydb {
 
 Database::Database(std::shared_ptr<Catalog> catalog)
-    : catalog(std::move(catalog)), buffer_pool(catalog) {}
+    : catalog(catalog), buffer_pool(std::make_shared<BufferPool>(catalog)) {}
 
 absl::StatusOr<Database> Database::LoadSchema(
     absl::string_view catalog_file_path) {
@@ -138,4 +138,8 @@ std::shared_ptr<Catalog> Database::GetCatalog() {
   return catalog;
 }
 
+std::shared_ptr<BufferPool> Database::GetBufferPool() {
+  return buffer_pool;
+}
+
 };  // namespace komfydb
diff --git a/komfydb/database.h b/komfydb/database.h
index 94bc013..c303f87 100644
--- a/komfydb/database.h
+++ b/komfydb/database.h
@@ -18,7 +18,7 @@ namespace komfydb {
 class Database {
  private:
   std::shared_ptr<Catalog> catalog;
-  BufferPool buffer_pool;
+  std::shared_ptr<BufferPool> buffer_pool;
 
   Database(std::shared_ptr<Catalog> catalog);
 
@@ -26,6 +26,8 @@ class Database {
   static absl::StatusOr<Database> LoadSchema(absl::string_view catalog_file);
 
   std::shared_ptr<Catalog> GetCatalog();
+
+  std::shared_ptr<BufferPool> GetBufferPool();
 };
 
 };  // namespace komfydb
diff --git a/komfydb/execution/op_iterator.h b/komfydb/execution/op_iterator.h
index 04ac86f..2f7bbea 100644
--- a/komfydb/execution/op_iterator.h
+++ b/komfydb/execution/op_iterator.h
@@ -18,15 +18,17 @@ namespace komfydb::execution {
 
 class OpIterator {
  public:
-  virtual absl::Status Open();
+  virtual ~OpIterator() {}
 
-  virtual void Close();
+  virtual absl::Status Open() = 0;
 
-  virtual absl::StatusOr<bool> HasNext();
+  virtual void Close() = 0;
 
-  virtual absl::StatusOr<Record> Next();
+  virtual bool HasNext() = 0;
 
-  virtual absl::StatusOr<TupleDesc*> GetTupleDesc();
+  virtual absl::StatusOr<Record> Next() = 0;
+
+  virtual absl::StatusOr<TupleDesc*> GetTupleDesc() = 0;
 };
 
 };  // namespace komfydb::execution
diff --git a/komfydb/execution/seq_scan.cc b/komfydb/execution/seq_scan.cc
index 352824d..0ba0dbe 100644
--- a/komfydb/execution/seq_scan.cc
+++ b/komfydb/execution/seq_scan.cc
@@ -1,48 +1,42 @@
+#include "komfydb/execution/seq_scan.h"
+
+#include <memory>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
-#include "komfydb/execution/seq_scan.h"
+#include "komfydb/storage/table_iterator.h"
+#include "komfydb/utils/utility.h"
 
 namespace komfydb::execution {
 
-SeqScan::SeqScan(TransactionId tid, int table_id,
-                 std::shared_ptr<Catalog> catalog,
-                 std::shared_ptr<BufferPool> bufferpool,
-                 absl::string_view table_alias)
-    : tid(tid),
-      table_id(table_id),
-      catalog(catalog),
-      bufferpool(bufferpool),
-      table_alias(table_alias) {}
-
-SeqScan::SeqScan(TransactionId tid, int table_id,
-                 std::shared_ptr<Catalog> catalog,
-                 std::shared_ptr<BufferPool> bufferpool) {
-  SeqScan(tid, table_id, catalog, bufferpool, common::GenerateUuidV4());
-}
+SeqScan::SeqScan(TableIterator iterator, TransactionId tid,
+                 absl::string_view table_alias, int table_id)
+    : iterator(std::move(iterator)),
+      tid(tid),
+      table_alias(table_alias),
+      table_id(table_id) {}
 
-std::string SeqScan::GetTableName() {
-    ASSIGN_OR_RETURN(std::string table_name, catalog->GetTableName(table_id);
-    return table_name;
-}
-
-std::string SeqScan::GetAlias() {
-  return table_alias;
-}
+SeqScan::SeqScan(TableIterator iterator, TransactionId tid, int table_id)
+    : iterator(std::move(iterator)),
+      tid(tid),
+      table_alias(common::GenerateUuidV4()),
+      table_id(table_id) {}
 
 absl::Status SeqScan::Open() {
-  TableIterator iterator(tid, table_id, );
-  iterator.Open();
-  return absl::OkStatus();
+  return iterator.Open();
 }
 
 void SeqScan::Close() {
-  iterator.Close();
+  return iterator.Close();
+}
+
+std::string SeqScan::GetAlias() {
+  return table_alias;
 }
 
-absl::StatusOr<bool> SeqScan::HasNext() {
+bool SeqScan::HasNext() {
   return iterator.HasNext();
 }
 
@@ -51,7 +45,7 @@ absl::StatusOr<Record> SeqScan::Next() {
 }
 
 absl::StatusOr<TupleDesc*> SeqScan::GetTupleDesc() {
-  return catalog->GetTupleDesc(table_id);
+  return iterator.GetTupleDesc();
 }
 
-};  // namespace komfydb::execution
\ No newline at end of file
+};  // namespace komfydb::execution
diff --git a/komfydb/execution/seq_scan.h b/komfydb/execution/seq_scan.h
index 9e4c375..c2e02ef 100644
--- a/komfydb/execution/seq_scan.h
+++ b/komfydb/execution/seq_scan.h
@@ -16,8 +16,6 @@
 
 namespace {
 
-using komfydb::storage::BufferPool;
-using komfydb::storage::Catalog;
 using komfydb::storage::Record;
 using komfydb::storage::TableIterator;
 using komfydb::transaction::TransactionId;
@@ -26,38 +24,30 @@ using komfydb::transaction::TransactionId;
 
 namespace komfydb::execution {
 
-class SeqScan : OpIterator {
+class SeqScan : public OpIterator {
  public:
-  SeqScan(TransactionId tid, int table_id, std::shared_ptr<Catalog> catalog,
-          std::shared_ptr<BufferPool> bufferpool,
-          absl::string_view table_alias);
+  SeqScan(TableIterator iterator, TransactionId tid,
+          absl::string_view table_alias, int table_id);
 
-  SeqScan(TransactionId tid, int table_id, std::shared_ptr<Catalog> catalog,
-          std::shared_ptr<BufferPool> bufferpool);
-
-  std::string GetTableName();
-
-  std::string GetAlias();
-
-  void Reset(int table_id, std::string table_alias);
+  SeqScan(TableIterator iterator, TransactionId tid, int table_id);
 
   absl::Status Open() override;
 
   void Close() override;
 
-  absl::StatusOr<bool> HasNext() override;
+  std::string GetAlias();
+
+  bool HasNext() override;
 
   absl::StatusOr<Record> Next() override;
 
   absl::StatusOr<TupleDesc*> GetTupleDesc() override;
 
  private:
-  int table_id;
-  std::string table_alias;
-  TransactionId tid;
   TableIterator iterator;
-  std::shared_ptr<Catalog> catalog;
-  std::shared_ptr<BufferPool> bufferpool;
+  TransactionId tid;
+  std::string table_alias;
+  int table_id;
 };
 
 };  // namespace komfydb::execution
diff --git a/komfydb/komfydb.cc b/komfydb/komfydb.cc
index 033734c..82c3b84 100644
--- a/komfydb/komfydb.cc
+++ b/komfydb/komfydb.cc
@@ -2,14 +2,16 @@
 #include <string>
 
 #include "absl/status/statusor.h"
+#include "common/permissions.h"
 #include "glog/logging.h"
 
-#include "common/type.h"
 #include "komfydb/common/td_item.h"
 #include "komfydb/common/type.h"
 #include "komfydb/database.h"
+#include "komfydb/execution/seq_scan.h"
 #include "komfydb/storage/heap_page.h"
-#include "utils/status_macros.h"
+#include "komfydb/storage/table_iterator.h"
+#include "komfydb/utils/status_macros.h"
 
 using namespace komfydb;
 
@@ -26,18 +28,24 @@ int main(int argc, char* argv[]) {
   }
 
   std::shared_ptr<Catalog> catalog = db->GetCatalog();
+  std::shared_ptr<BufferPool> buffer_pool = db->GetBufferPool();
+
+  TransactionId tid;
   std::vector<int> table_ids = catalog->GetTableIds();
+  int table_id = table_ids[0];
+
+  storage::TableIterator table_iterator(tid, table_id, catalog, buffer_pool);
+  execution::SeqScan seq_scan(table_iterator, tid, "test_table", table_id);
+
+  if (!seq_scan.Open().ok()) {
+    LOG(ERROR) << "seq_scan open error? lol";
+  }
+
+  LOG(INFO) << "Opened seq_scan on table "
+            << catalog->GetTableName(table_id).value();
 
-  LOG(INFO) << "Tables:";
-  for (auto table_id : table_ids) {
-    LOG(INFO) << table_id << "->" << catalog->GetTableName(table_id).value();
-    auto file = catalog->GetDatabaseFile(table_id).value();
-    std::unique_ptr<storage::Page> page =
-        file->ReadPage(storage::PageId(table_id, 0)).value();
-    storage::HeapPage* hp = static_cast<storage::HeapPage*>(page.get());
-
-    for (auto& record : hp->GetRecords()) {
-      LOG(INFO) << static_cast<std::string>(record);
-    }
+  while (seq_scan.HasNext()) {
+    Record record = std::move(seq_scan.Next().value());
+    std::cout << static_cast<std::string>(record) << "\n";
   }
 }
diff --git a/komfydb/storage/buffer_pool.cc b/komfydb/storage/buffer_pool.cc
index 8451d0a..9b51a86 100644
--- a/komfydb/storage/buffer_pool.cc
+++ b/komfydb/storage/buffer_pool.cc
@@ -1,7 +1,9 @@
-#include "komfydb/utils/status_macros.h"
-
 #include "komfydb/storage/buffer_pool.h"
+
+#include "glog/logging.h"
+
 #include "komfydb/storage/db_file.h"
+#include "komfydb/utils/status_macros.h"
 
 namespace komfydb::storage {
 
@@ -9,8 +11,11 @@ absl::StatusOr<Page*> BufferPool::GetPage(TransactionId tid, PageId pid,
                                           Permissions perm) {
   if (!page_pool.contains(pid)) {
     if (page_pool.size() == pages_cnt) {
-      return absl::InvalidArgumentError("Cannot read another file to the pool");
+      // return absl::InvalidArgumentError("Cannot read another file to the pool");
+      LOG(ERROR) << "Buffer run out of space\n";
+      assert(false);
     }
+    LOG(INFO) << "Getting page from disk: " << static_cast<std::string>(pid);
     ASSIGN_OR_RETURN(DbFile * file, catalog->GetDatabaseFile(pid.GetTableId()));
     ASSIGN_OR_RETURN(page_pool[pid], file->ReadPage(pid));
   }
diff --git a/komfydb/storage/catalog.cc b/komfydb/storage/catalog.cc
index ce2d92a..34da56d 100644
--- a/komfydb/storage/catalog.cc
+++ b/komfydb/storage/catalog.cc
@@ -52,6 +52,7 @@ absl::StatusOr<std::string> Catalog::GetTableName(int table_id) const {
 }
 
 absl::StatusOr<DbFile*> Catalog::GetDatabaseFile(int table_id) const {
+  LOG(INFO) << "Getting DbFile with tid " << table_id << "\n";
   auto it = db_files.find(table_id);
   if (it == db_files.end()) {
     return absl::InvalidArgumentError(
diff --git a/komfydb/storage/db_file.h b/komfydb/storage/db_file.h
index aa61a75..8d29e01 100644
--- a/komfydb/storage/db_file.h
+++ b/komfydb/storage/db_file.h
@@ -9,14 +9,11 @@
 #include "komfydb/common/tuple_desc.h"
 #include "komfydb/storage/page.h"
 #include "komfydb/storage/page_id.h"
-#include "komfydb/storage/table_iterator.h"
 #include "komfydb/transaction/transaction_id.h"
 
 namespace {
 
-using komfydb::common::Tuple;
 using komfydb::common::TupleDesc;
-using komfydb::transaction::TransactionId;
 
 };  // namespace
 
diff --git a/komfydb/storage/heap_file.cc b/komfydb/storage/heap_file.cc
index 9e062b7..c472fb5 100644
--- a/komfydb/storage/heap_file.cc
+++ b/komfydb/storage/heap_file.cc
@@ -72,7 +72,7 @@ absl::StatusOr<std::unique_ptr<Page>> HeapFile::ReadPage(PageId id) {
   uint32_t file_length = file.tellg();
   uint64_t page_pos = (uint64_t)CONFIG_PAGE_SIZE * (uint64_t)id.GetPageNumber();
   if (page_pos >= file_length) {
-    return absl::InvalidArgumentError(
+    return absl::OutOfRangeError(
         absl::StrCat("Page number out of range: ", id.GetPageNumber(), " (",
                      file_length / CONFIG_PAGE_SIZE, ")"));
   }
diff --git a/komfydb/storage/heap_page.h b/komfydb/storage/heap_page.h
index 46e23f7..0ad3753 100644
--- a/komfydb/storage/heap_page.h
+++ b/komfydb/storage/heap_page.h
@@ -15,9 +15,8 @@
 
 namespace {
 
-using komfydb::common::Record;
 using komfydb::common::TupleDesc;
-using komfydb::transaction::TransactionId;
+using komfydb::storage::Record;
 
 };  //namespace
 
@@ -63,7 +62,7 @@ class HeapPage : public Page {
 
   absl::StatusOr<std::vector<uint8_t>> GetPageData() override;
 
-  std::vector<Record> GetRecords();
+  std::vector<Record> GetRecords() override;
 };
 
 };  // namespace komfydb::storage
diff --git a/komfydb/storage/page.h b/komfydb/storage/page.h
index 13947b8..1c16c63 100644
--- a/komfydb/storage/page.h
+++ b/komfydb/storage/page.h
@@ -3,7 +3,11 @@
 
 #include <vector>
 
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
 #include "komfydb/storage/page_id.h"
+#include "komfydb/storage/record.h"
 #include "komfydb/transaction/transaction_id.h"
 
 namespace {
@@ -31,7 +35,7 @@ class Page {
 
   virtual absl::Status SetBeforeImage() = 0;
 
-  virtual std::vector<Record>* GetRecords() = 0;
+  virtual std::vector<Record> GetRecords() = 0;
 };
 
 };  // namespace komfydb::storage
diff --git a/komfydb/storage/page_id.cc b/komfydb/storage/page_id.cc
index 28e117b..21990e7 100644
--- a/komfydb/storage/page_id.cc
+++ b/komfydb/storage/page_id.cc
@@ -28,4 +28,8 @@ bool PageId::operator==(const PageId& p) const {
   return table_id == p.GetTableId() && page_no == p.GetPageNumber();
 }
 
+PageId::operator std::string() const {
+  return std::to_string(table_id) + ", " + std::to_string(page_no);
+}
+
 };  // namespace komfydb::storage
diff --git a/komfydb/storage/page_id.h b/komfydb/storage/page_id.h
index b2a4571..b0e9ab1 100644
--- a/komfydb/storage/page_id.h
+++ b/komfydb/storage/page_id.h
@@ -27,6 +27,8 @@ class PageId {
 
   bool operator==(const PageId& p) const;
 
+  operator std::string() const;
+
   template <typename H>
   friend H AbslHashValue(H h, const PageId& pid) {
     return H::combine(std::move(h), pid.table_id, pid.page_no);
diff --git a/komfydb/storage/record.cc b/komfydb/storage/record.cc
index 5647072..d469abc 100644
--- a/komfydb/storage/record.cc
+++ b/komfydb/storage/record.cc
@@ -20,4 +20,8 @@ bool Record::operator==(const Record& r) const {
   return Tuple::operator==(r) && r.rid == rid;
 }
 
+Record::operator std::string() const {
+  return Tuple::operator std::string();
+}
+
 };  // namespace komfydb::storage
diff --git a/komfydb/storage/record.h b/komfydb/storage/record.h
index ebd0163..e0128bb 100644
--- a/komfydb/storage/record.h
+++ b/komfydb/storage/record.h
@@ -38,6 +38,8 @@ class Record : public Tuple {
   void SetId(RecordId rid);
 
   bool operator==(const Record& r) const;
+
+  operator std::string() const;
 };
 
 };  // namespace komfydb::storage
diff --git a/komfydb/storage/table_iterator.cc b/komfydb/storage/table_iterator.cc
index 1f9cd28..4d2e5c1 100644
--- a/komfydb/storage/table_iterator.cc
+++ b/komfydb/storage/table_iterator.cc
@@ -1,7 +1,16 @@
+#include "komfydb/storage/table_iterator.h"
+
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
-#include "komfydb/storage/table_iterator.h"
+#include "komfydb/common/permissions.h"
+#include "komfydb/utils/status_macros.h"
+
+namespace {
+
+using komfydb::common::Permissions;
+
+};
 
 namespace komfydb::storage {
 
@@ -10,48 +19,47 @@ TableIterator::TableIterator(TransactionId tid, int table_id,
                              std::shared_ptr<BufferPool> bufferpool)
     : tid(tid), table_id(table_id), catalog(catalog), bufferpool(bufferpool) {}
 
-absl::StatusOr<bool> TableIterator::LoadNextPage() {
-  if (++page_ctr >= num_pages)
-    return false;
-    ASSIGN_OR_RETURN(Page* page, bufferpool->GetPage(PageId(table_id, page_ctr));
-    records = page->GetRecords();
-    current_tuple = records->begin();
-    return true;
-}
-
-absl::Status TableIterator::LoadFirstPage() {
-  page_ctr = -1;
-  ASSIGN_OR_RETURN(bool good, LoadNextPage());
-  if (!good)
-    return absl::OutOfRangeError("No pages in this file/table");
-  return absl::StatusOK();
+absl::Status TableIterator::LoadNextPage() {
+  page_ctr++;
+  ASSIGN_OR_RETURN(Page * page,
+                   bufferpool->GetPage(tid, PageId(table_id, page_ctr),
+                                       Permissions::READ_ONLY));
+  records = page->GetRecords();
+  current_tuple = records.begin();
+  return absl::OkStatus();
 }
 
 absl::Status TableIterator::Open() {
-  ASSIGN_OR_RETURN(DbFile * file, catalog->GetDatabaseFile(table_id));
-  num_pages = file->GetNumPages();
-  RETURN_IF_ERROR(LoadFirstPage());
+  page_ctr = -1;
+  RETURN_IF_ERROR(LoadNextPage());
 
   return absl::OkStatus();
 }
 
 void TableIterator::Close() {}
 
-absl::StatusOr<bool> TableIterator::HasNext() {
-  if (current_tuple != records->end())
+bool TableIterator::HasNext() {
+  if (current_tuple != records.end()) {
     return true;
+  }
 
-  ASSIGN_OR_RETURN(bool good, LoadNextPage());
-  if (!good)
+  absl::Status status = LoadNextPage();
+  if (absl::IsOutOfRange(status)) {
     return false;
+  }
+  assert(status.ok());
   return HasNext();
 }
 
 absl::StatusOr<Record> TableIterator::Next() {
-  ASSIGN_OR_RETURN(bool good, HasNext());
-  if (!good)
+  if (!HasNext()) {
     return absl::OutOfRangeError("No more records in this table");
-  return *current_tuple++;
+  }
+  return std::move(*current_tuple++);
+}
+
+absl::StatusOr<TupleDesc*> TableIterator::GetTupleDesc() {
+  return catalog->GetTupleDesc(table_id);
 }
 
 };  // namespace komfydb::storage
diff --git a/komfydb/storage/table_iterator.h b/komfydb/storage/table_iterator.h
index eb555c1..d10660f 100644
--- a/komfydb/storage/table_iterator.h
+++ b/komfydb/storage/table_iterator.h
@@ -23,12 +23,11 @@ class TableIterator {
   int page_ctr;
   int table_id;
   int num_pages;
-  std::vector<Record>* records;
+  std::vector<Record> records;
   std::vector<Record>::iterator current_tuple;
   std::shared_ptr<Catalog> catalog;
   std::shared_ptr<BufferPool> bufferpool;
-  absl::StatusOr<bool> LoadNextPage();
-  absl::Status LoadFirstPage();
+  absl::Status LoadNextPage();
 
  public:
   TableIterator(TransactionId tid, int table_id,
@@ -39,9 +38,13 @@ class TableIterator {
 
   void Close();
 
-  absl::StatusOr<bool> HasNext();
+  bool HasNext();
 
   absl::StatusOr<Record> Next();
+
+  absl::StatusOr<TupleDesc*> GetTupleDesc();
+
+  std::string GetTableName();
 };
 
 };  // namespace komfydb::storage
diff --git a/simple-db-hw-2022 b/simple-db-hw-2022
-Subproject 9785ed98cf23f543345e971b2b5a4f217b3f4fc
+Subproject ee6793101a4d6c685700566525c2869f5513444