Added catalog functions

Author: poojanilangekar

src/catalog/layout_catalog.cpp

@@ -56,7 +56,7 @@ LayoutCatalog::LayoutCatalog(storage::Database *pg_catalog,
 
 LayoutCatalog::~LayoutCatalog() {}
 
-std::unique_ptr<catalog::Schema> ColumnCatalog::InitializeSchema() {
+std::unique_ptr<catalog::Schema> LayoutCatalog::InitializeSchema() {
   const std::string primary_key_constraint_name = "primary_key";
   const std::string not_null_constraint_name = "not_null";
 
@@ -108,10 +108,10 @@ bool LayoutCatalog::InsertLayout(oid_t table_oid,
   auto val3 = type::ValueFactory::GetVarcharValue(layout->SerializeColumnMap(),
                                                   nullptr);
 
-  tuple->SetValue(ColumnId::TABLE_OID, val0);
-  tuple->SetValue(ColumnId::LAYOUT_OID, val1);
-  tuple->SetValue(ColumnId::NUM_COLUMNS, val2);
-  tuple->SetValue(ColumnId::COLUMN_MAP, val3);
+  tuple->SetValue(ColumnId::TABLE_OID, val0, pool);
+  tuple->SetValue(ColumnId::LAYOUT_OID, val1, pool);
+  tuple->SetValue(ColumnId::NUM_COLUMNS, val2, pool);
+  tuple->SetValue(ColumnId::COLUMN_MAP, val3, pool);
 
   // Insert the tuple
   return InsertTuple(std::move(tuple), txn);
@@ -135,8 +135,8 @@ bool LayoutCatalog::DeleteLayout(oid_t table_oid, oid_t layout_id,
 }
 
 const std::unordered_map<oid_t, std::shared_ptr<const storage::Layout>>
-LayoutCatalog::GetLayouts(oid_t table_oid, oid_t layout_id,
-                                concurrency::TransactionContext *txn) {
+LayoutCatalog::GetLayouts(oid_t table_oid,
+                          concurrency::TransactionContext *txn) {
   // Try to find the layouts in the cache
   auto table_object =
           TableCatalog::GetInstance()->GetTableObject(table_oid, txn);
@@ -175,9 +175,5 @@ LayoutCatalog::GetLayouts(oid_t table_oid, oid_t layout_id,
   return table_object->GetLayouts();
 }
 
-
-
-
-
 }  // namespace catalog
 }  // namespace peloton

src/catalog/table_catalog.cpp

@@ -18,6 +18,7 @@
 #include "catalog/column_catalog.h"
 #include "catalog/database_catalog.h"
 #include "catalog/index_catalog.h"
+#include "catalog/layout_catalog.h"
 #include "catalog/system_catalogs.h"
 #include "concurrency/transaction_context.h"
 #include "storage/data_table.h"
@@ -319,8 +320,8 @@ std::shared_ptr<ColumnCatalogObject> TableCatalogObject::GetColumnObject(
 TableCatalog::TableCatalog(
     storage::Database *database, UNUSED_ATTRIBUTE type::AbstractPool *pool,
     UNUSED_ATTRIBUTE concurrency::TransactionContext *txn)
-    : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME,
-                      InitializeSchema().release(), database) {
+        : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME,
+                          InitializeSchema().release(), database) {
   // Add indexes for pg_namespace
   AddIndex({0}, TABLE_CATALOG_PKEY_OID, TABLE_CATALOG_NAME "_pkey",
            IndexConstraintType::PRIMARY_KEY);
@@ -330,6 +331,95 @@ TableCatalog::TableCatalog(
            IndexConstraintType::DEFAULT);
 }
 
+/* @brief   Insert layout object into the cache.
+ * @param   layout  Layout object to be inserted
+ * @return  false if layout already exists in cache
+ */
+bool TableCatalogObject::InsertLayout(std::shared_ptr<const storage::Layout> layout) {
+
+  // Invalid object
+  if (layout == nullptr) {
+    return false;
+  }
+
+  oid_t  layout_id = layout->GetLayoutId();
+  // layout is already present in the cache.
+  if (layout_objects_.find(layout_id) != layout_objects_.end()) {
+    LOG_DEBUG("Layout %u already exists in cache!", layout_id);
+    return false;
+  }
+
+  valid_layout_objects_ = true;
+  layout_objects_.insert(std::make_pair(layout_id, layout));
+  return true;
+}
+
+/*
+ * @brief   evict all layout objects from cache
+ */
+void TableCatalogObject::EvictAllLayouts() {
+  layout_objects_.clear();
+  valid_layout_objects_ = false;
+}
+
+/* @brief   Get all layout objects of this table.
+ *          Add it to the cache if necessary.
+ * @param   cached_only If set to true, don't fetch the layout objects.
+ * @return  Map from layout_oid to cached layout object.
+ */
+std::unordered_map<oid_t, std::shared_ptr<const storage::Layout>>
+TableCatalogObject::GetLayouts(bool cached_only) {
+  if (!valid_layout_objects_ && !cached_only) {
+    // get column catalog objects from pg_column
+    LayoutCatalog::GetInstance()->GetLayouts(table_oid, txn);
+    valid_column_objects = true;
+  }
+  return layout_objects_;
+}
+
+/* @brief   get the layout object of the given layout_id.
+ * @param   layout_id The id of the layout to be fetched.
+ * @param   cached_only If set to true, don't fetch the layout objects.
+ * @return  Layout object of corresponding to the layout_id if present.
+ */
+std::shared_ptr<const storage::Layout>
+TableCatalogObject::GetLayout(oid_t layout_id, bool cached_entry) {
+  // fetch layout objects in case we have not
+  GetLayouts(cached_entry);
+  auto it = layout_objects_.find(layout_id);
+  if (it != layout_objects_.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+/* @brief   Evict layout from the cache.
+ * @param   layout_id Id of the layout to be deleted.
+ * @return  true if layout_id is found and evicted; false if not found.
+ */
+bool TableCatalogObject::EvictLayout(oid_t layout_id) {
+  if (!valid_layout_objects_) return false;
+
+  // find layout from the cache
+  auto it = layout_objects_.find(layout_id);
+  if (it == layout_objects_.end()) {
+    return false;  // layout_id not found in cache
+  }
+
+  auto layout = it->second;
+  PELOTON_ASSERT(layout);
+  layout_objects_.erase(it);
+  return true;
+}
+
+TableCatalog *TableCatalog::GetInstance(storage::Database *pg_catalog,
+                                        type::AbstractPool *pool,
+                                        concurrency::TransactionContext *txn) {
+  static TableCatalog table_catalog{pg_catalog, pool, txn};
+  return &table_catalog;
+}
+
+
 TableCatalog::~TableCatalog() {}
 
 /*@brief   private function for initialize schema of pg_table

src/include/catalog/layout_catalog.h

@@ -63,8 +63,7 @@ class LayoutCatalog : public AbstractCatalog {
   // Read Related API
   //===--------------------------------------------------------------------===//
   const std::unordered_map<oid_t, std::shared_ptr<const storage::Layout>>
-  GetLayouts(oid_t table_oid, oid_t layout_id,
-                   concurrency::TransactionContext *txn);
+  GetLayouts(oid_t table_oid, concurrency::TransactionContext *txn);
 
 private:
 

src/include/catalog/table_catalog.h

@@ -34,9 +34,13 @@
 
 #include "catalog/abstract_catalog.h"
 #include "executor/logical_tile.h"
-#include "storage/layout.h"
 
 namespace peloton {
+
+namespace storage {
+class Layout;
+}
+
 namespace catalog {
 
 class IndexCatalogObject;
@@ -76,7 +80,7 @@ class TableCatalogObject {
       const std::string &column_name, bool cached_only = false);
 
   // Evict all layouts from the cache
-  void EvictAllLayoutObjects();
+  void EvictAllLayouts();
 
   // Get layouts
   std::unordered_map<oid_t, std::shared_ptr<const storage::Layout>>