Access LayoutCatalog via the global Catalog object

Author: poojanilangekar

src/catalog/catalog.cpp

@@ -463,6 +463,76 @@ ResultType Catalog::CreateIndex(
   return ResultType::SUCCESS;
 }
 
+/*
+ *
+  // Create a new layout
+  ResultType CreateLayout(oid_t database_oid, oid_t table_oid,
+                          const column_map_type &column_map,
+                          concurrency::TransactionContext *txn);
+  // Create a new layout and set it as the default for the table
+  ResultType CreateDefaultLayout(oid_t database_oid, oid_t table_oid,
+                                 const column_map_type &column_map,
+                                 concurrency::TransactionContext *txn);
+ */
+
+/*
+ * @brief   create a new layout for a table
+ * @param   database_oid  database to which the table belongs to
+ * @param   table_oid     table to which the layout has to be added
+ * @param   column_map    column_map of the new layout to be created
+ * @param   txn           TransactionContext
+ * @return  shared_ptr    shared_ptr to the newly created layout in case of
+ *                        success. nullptr in case of failure.
+ */
+std::shared_ptr<const storage::Layout>
+Catalog::CreateLayout(oid_t database_oid, oid_t table_oid,
+                                 const column_map_type &column_map,
+                                 concurrency::TransactionContext *txn) {
+
+  auto storage_manager = storage::StorageManager::GetInstance();
+  auto database = storage_manager->GetDatabaseWithOid(database_oid);
+  auto table = database->GetTableWithOid(table_oid);
+
+  oid_t layout_oid = table->GetNextLayoutOid();
+  // Ensure that the new layout
+  PELOTON_ASSERT(layout_oid < INVALID_OID);
+  auto new_layout = std::shared_ptr<const storage::Layout>(
+          new const storage::Layout(column_map, layout_oid));
+  auto layout_catalog = catalog::LayoutCatalog::GetInstance();
+  bool result = layout_catalog->InsertLayout(table_oid, new_layout,
+                                             pool_.get(), txn);
+  if (!result) {
+    LOG_DEBUG("Failed to create a new layout for table %u", table_oid);
+    return nullptr;
+  }
+  return new_layout;
+}
+
+/*
+ * @brief   create a new layout for a table and make it the deafult if
+ *          if the creating is successsful.
+ * @param   database_oid  database to which the table belongs to
+ * @param   table_oid     table to which the layout has to be added
+ * @param   column_map    column_map of the new layout to be created
+ * @param   txn           TransactionContext
+ * @return  shared_ptr    shared_ptr to the newly created layout in case of
+ *                        success. nullptr in case of failure.
+ */
+std::shared_ptr<const storage::Layout>
+Catalog::CreateDefaultLayout(oid_t database_oid, oid_t table_oid,
+                      const column_map_type &column_map,
+                      concurrency::TransactionContext *txn) {
+  auto new_layout = CreateLayout(database_oid, table_oid, column_map, txn);
+  // If the layout creation was successful, set it as the default
+  if (new_layout != nullptr) {
+    auto storage_manager = storage::StorageManager::GetInstance();
+    auto database = storage_manager->GetDatabaseWithOid(database_oid);
+    auto table = database->GetTableWithOid(table_oid);
+    table->SetDefaultLayout(new_layout);
+  }
+  return new_layout;
+}
+
 //===----------------------------------------------------------------------===//
 // DROP FUNCTIONS
 //===----------------------------------------------------------------------===//
@@ -634,6 +704,39 @@ ResultType Catalog::DropIndex(const std::string &index_name,
     return result;
 }
 
+/*@brief   Drop layout
+ * tile_groups
+ * @param   database_oid    the database to which the table belongs
+ * @param   table_oid       the table to which the layout belongs
+ * @param   layout_oid      the layout to be dropped
+ * @param   txn             TransactionContext
+ * @return  TransactionContext ResultType(SUCCESS or FAILURE)
+ */
+ResultType Catalog::DropLayout(oid_t database_oid, oid_t table_oid,
+                               oid_t layout_oid,
+                               concurrency::TransactionContext *txn) {
+  // Check if the default_layout of the table is the same.
+  // If true reset it to a row store.
+  auto storage_manager = storage::StorageManager::GetInstance();
+  auto database = storage_manager->GetDatabaseWithOid(database_oid);
+  auto table = database->GetTableWithOid(table_oid);
+  auto default_layout = table->GetDefaultLayout();
+
+  if (default_layout.GetOid() == layout_oid) {
+    table->ResetDefaultLayout();
+  }
+
+  auto layout_catalog = LayoutCatalog::GetInstance();
+  if (!layout_catalog->DeleteLayout(table_oid, layout_oid, txn)) {
+    auto layout = table->GetDefaultLayout();
+    LOG_DEBUG("Layout delete failed. Default layout id: %u",
+              layout.GetOid());
+    return ResultType::FAILURE;
+  }
+
+  return ResultType::SUCCESS;
+}
+
 //===--------------------------------------------------------------------===//
 // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION
 //===--------------------------------------------------------------------===//

src/catalog/layout_catalog.cpp

@@ -103,7 +103,7 @@ bool LayoutCatalog::InsertLayout(oid_t table_oid,
           new storage::Tuple(catalog_table_->GetSchema(), true));
 
   auto val0 = type::ValueFactory::GetIntegerValue(table_oid);
-  auto val1 = type::ValueFactory::GetIntegerValue(layout->GetLayoutId());
+  auto val1 = type::ValueFactory::GetIntegerValue(layout->GetOid());
   auto val2 = type::ValueFactory::GetIntegerValue(layout->GetColumnCount());
   auto val3 = type::ValueFactory::GetVarcharValue(layout->SerializeColumnMap(),
                                                   nullptr);

src/catalog/table_catalog.cpp

@@ -315,7 +315,7 @@ bool TableCatalogObject::InsertLayout(std::shared_ptr<const storage::Layout> lay
     return false;
   }
 
-  oid_t  layout_id = layout->GetLayoutId();
+  oid_t  layout_id = layout->GetOid();
   // 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);

src/include/catalog/catalog.h

@@ -37,6 +37,7 @@ class Index;
 namespace storage {
 class Database;
 class DataTable;
+class Layout;
 class TableFactory;
 class Tuple;
 }  // namespace storage
@@ -115,6 +116,18 @@ class Catalog {
                          concurrency::TransactionContext *txn,
                          bool is_catalog = false);
 
+  // Create a new layout
+  std::shared_ptr<const storage::Layout>
+  CreateLayout(oid_t database_oid, oid_t table_oid,
+               const column_map_type &column_map,
+               concurrency::TransactionContext *txn);
+
+  // Create a new layout and set it as the default for the table
+  std::shared_ptr<const storage::Layout>
+  CreateDefaultLayout(oid_t database_oid, oid_t table_oid,
+                      const column_map_type &column_map,
+                      concurrency::TransactionContext *txn);
+
   //===--------------------------------------------------------------------===//
   // DROP FUNCTIONS
   //===--------------------------------------------------------------------===//
@@ -139,6 +152,10 @@ class Catalog {
   // Drop an index, using its index name
   ResultType DropIndex(const std::string &index_name,
                        concurrency::TransactionContext *txn);
+
+  // Delete a layout using its database_oid, table_oid and layout_oid
+  ResultType DropLayout(oid_t database_oid, oid_t table_oid, oid_t layout_oid,
+                        concurrency::TransactionContext *txn);
   //===--------------------------------------------------------------------===//
   // GET WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION
   //===--------------------------------------------------------------------===//

src/include/catalog/layout_catalog.h

@@ -61,13 +61,15 @@ class LayoutCatalog : public AbstractCatalog {
                     concurrency::TransactionContext *txn);
 
   bool DeleteLayouts(oid_t table_oid, concurrency::TransactionContext *txn);
+
+private:
+
   //===--------------------------------------------------------------------===//
   // Read Related API
   //===--------------------------------------------------------------------===//
   const std::unordered_map<oid_t, std::shared_ptr<const storage::Layout>>
   GetLayouts(oid_t table_oid, concurrency::TransactionContext *txn);
 
-private:
 
   LayoutCatalog(storage::Database *pg_catalog, type::AbstractPool *pool,
                 concurrency::TransactionContext *txn);

src/include/storage/data_table.h

@@ -40,6 +40,7 @@ class Sample;
 
 namespace catalog {
 class ForeignKey;
+class Catalog;
 }  // namespace catalog
 
 namespace index {
@@ -77,6 +78,7 @@ class DataTable : public AbstractTable {
   friend class TileGroup;
   friend class TileGroupFactory;
   friend class TableFactory;
+  friend class catalog::Catalog;
   friend class logging::LogManager;
 
   DataTable() = delete;
@@ -190,7 +192,6 @@ class DataTable : public AbstractTable {
   const std::vector<std::set<oid_t>> &GetIndexColumns() const {
     return indexes_columns_;
   }
-
   //===--------------------------------------------------------------------===//
   // FOREIGN KEYS
   //===--------------------------------------------------------------------===//
@@ -248,10 +249,14 @@ class DataTable : public AbstractTable {
 
   void ClearLayoutSamples();
 
-  bool SetDefaultLayout(const column_map_type &column_map,
-                        type::AbstractPool *pool,
-                        concurrency::TransactionContext *txn);
+  inline void SetDefaultLayout(std::shared_ptr<const Layout> new_layout) {
+    default_layout_ = new_layout;
+  }
 
+  inline void ResetDefaultLayout() {
+    default_layout_ = std::shared_ptr<const Layout>(
+            new const Layout(schema->GetColumnCount()));
+  }
   const Layout& GetDefaultLayout() const;
 
   //===--------------------------------------------------------------------===//

src/include/storage/layout.h

@@ -43,7 +43,7 @@ class Layout : public Printable {
   // Check whether the Layout is ColumnStore.
   inline bool IsColumnStore() const { return (layout_type_ == LayoutType::COLUMN); }
 
-  oid_t  GetLayoutId() const { return layout_id_; }
+  oid_t  GetOid() const { return layout_oid_; }
 
   // Sets the tile id and column id w.r.t that tile corresponding to
   // the specified tile group column id.
@@ -78,7 +78,7 @@ class Layout : public Printable {
  private:
 
   // Layout Id of the tile
-  oid_t layout_id_;
+  oid_t layout_oid_;
 
   // Number of columns in the layout 
   oid_t num_columns_; 

src/include/tuning/layout_tuner.h

@@ -27,10 +27,6 @@ namespace storage {
 class DataTable;
 }
 
-namespace type {
-class AbstractPool;
-}
-
 namespace tuning {
 
 //===--------------------------------------------------------------------===//
@@ -138,9 +134,6 @@ class LayoutTuner {
   /** Desired layout tile count */
   oid_t tile_count = 2;
 
-  /** Pool to add new layouts in the pg_layout table */
-  std::unique_ptr<type::AbstractPool> pool_;
-
 };
 
 }  // namespace indextuner

src/storage/data_table.cpp

@@ -1368,20 +1368,6 @@ void DataTable::ClearIndexSamples() {
   }
 }
 
-bool DataTable::SetDefaultLayout(const column_map_type &column_map,
-                                 type::AbstractPool *pool,
-                                 concurrency::TransactionContext *txn) {
-  oid_t layout_id = GetNextLayoutOid();
-  auto new_layout = std::shared_ptr<const Layout>(
-          new const Layout(column_map, layout_id));
-  auto layout_catalog = catalog::LayoutCatalog::GetInstance();
-  bool result = layout_catalog->InsertLayout(table_oid, new_layout, pool, txn);
-  if (result) {
-    default_layout_ = new_layout;
-  }
-  return result;
-}
-
 const Layout& DataTable::GetDefaultLayout() const {
   return *default_layout_;
 }

src/storage/layout.cpp

@@ -46,16 +46,16 @@ Layout::Layout(const column_map_type& column_map)
   // If a table has one column, it would be LayoutType::Row
   if (row_layout) {
     layout_type_ = LayoutType::ROW;
-    layout_id_ = ROW_STORE_OID;
+    layout_oid_ = ROW_STORE_OID;
   } else if (column_layout) {
     layout_type_  = LayoutType::COLUMN;
-    layout_id_ = COLUMN_STORE_OID;
+    layout_oid_ = COLUMN_STORE_OID;
   } else {
-    // layout_id_ is set to INVALID_OID, indicating that this
+    // layout_oid_ is set to INVALID_OID, indicating that this
     // layout is not stored in the catalog and thus not persistent.
     // To be used only in TempTable or Tests. 
     layout_type_ = LayoutType::HYBRID;
-    layout_id_ = INVALID_OID;
+    layout_oid_ = INVALID_OID;
   }
 
   if (layout_type_ != LayoutType::HYBRID) {
@@ -64,15 +64,15 @@ Layout::Layout(const column_map_type& column_map)
   }
 }
 
-// Constructor for Layout class with predefined layout_id
+// Constructor for Layout class with predefined layout_oid
 Layout::Layout(const column_map_type &column_map, oid_t layout_id)
-        : layout_id_(layout_id),
+        : layout_oid_(layout_id),
           num_columns_(column_map.size()),
           column_layout_(column_map) {
 
-  if (layout_id_ == ROW_STORE_OID) {
+  if (layout_oid_ == ROW_STORE_OID) {
     layout_type_ = LayoutType::ROW;
-  } else if (layout_id == COLUMN_STORE_OID) {
+  } else if (layout_oid_ == COLUMN_STORE_OID) {
     layout_type_ = LayoutType::COLUMN;
   } else {
     layout_type_ = LayoutType::HYBRID;
@@ -124,7 +124,7 @@ double Layout::GetLayoutDifference(const storage::Layout &other) const {
   // Check the schema before invoking this function.
   PELOTON_ASSERT(this->num_columns_ == other.num_columns_);
 
-  if ((this->layout_id_ != other.layout_id_)) {
+  if ((this->layout_oid_ != other.layout_oid_)) {
 
     for (oid_t col_itr = 0; col_itr < num_columns_; col_itr++) {
 
@@ -289,7 +289,7 @@ std::string Layout::GetColumnMapInfo() const {
 const std::string Layout::GetInfo() const {
   std::ostringstream os;
 
-  os << peloton::GETINFO_DOUBLE_STAR << " Layout[#" << layout_id_ << "] "
+  os << peloton::GETINFO_DOUBLE_STAR << " Layout[#" << layout_oid_ << "] "
      << peloton::GETINFO_DOUBLE_STAR << std::endl;
   os << "Number of columns[" << num_columns_ << "] " << std::endl;
   os << "LayoutType[" << LayoutTypeToString(layout_type_) << std::endl;
@@ -307,7 +307,7 @@ bool operator==(const Layout& lhs, const Layout& rhs) {
   }
 
   // Check the equality of layout_oid_
-  if (lhs.GetLayoutId() != rhs.GetLayoutId()) {
+  if (lhs.GetOid() != rhs.GetOid()) {
     return false;
   }
   // Check the equality of column_count_