Checkpointing

src/catalog/catalog.cpp

@@ -958,7 +958,8 @@ ResultType Catalog::AddUniqueConstraint(concurrency::TransactionContext *txn,
                     ->GetSchema();
 
   // Create index
-  std::stringstream index_name(table_object->GetTableName());
+  std::stringstream index_name;
+  index_name << table_object->GetTableName();
   for (auto column_id : column_ids)
     index_name << "_" + schema->GetColumn(column_id).GetName();
   index_name << "_UNIQ";
@@ -1033,7 +1034,8 @@ ResultType Catalog::AddForeignKeyConstraint(concurrency::TransactionContext *txn
                                 ->GetTableCatalogEntry(txn, src_table_oid);
   auto src_schema = src_table->GetSchema();
 
-  std::stringstream index_name(src_table_object->GetTableName());
+  std::stringstream index_name;
+  index_name << src_table_object->GetTableName();
   for (auto col_id : src_col_ids)
     index_name << "_" << src_schema->GetColumn(col_id).GetName();
   index_name << "_fkey";
@@ -1660,6 +1662,26 @@ std::shared_ptr<DatabaseCatalogEntry> Catalog::GetDatabaseCatalogEntry(
   return database_object;
 }
 
+/* Get database catalog object from cache (cached_only == true),
+ * or all the way from storage (cached_only == false)
+ * throw exception and abort txn if not exists/invisible
+ * */
+std::unordered_map<oid_t, std::shared_ptr<DatabaseCatalogEntry>>
+Catalog::GetDatabaseCatalogEntries(concurrency::TransactionContext *txn,
+                                   bool cached_only) {
+  if (txn == nullptr) {
+    throw CatalogException("Do not have transaction to get database objects");
+  }
+
+  if (!cached_only && !txn->catalog_cache.valid_database_catalog_entry_) {
+    // cache miss get from pg_table
+    return DatabaseCatalog::GetInstance()->GetDatabaseCatalogEntries(txn);
+  }
+  // make sure to check IsValidTableObjects() before getting table objects
+  PELOTON_ASSERT(txn->catalog_cache.valid_database_catalog_entry_);
+  return txn->catalog_cache.database_catalog_entries_cache_;
+}
+
 /* Check table from pg_table with table_name  & schema_name using txn,
  * get it from storage layer using table_oid,
  * throw exception and abort txn if not exists/invisible

src/catalog/catalog_cache.cpp

@@ -16,6 +16,7 @@
 
 #include "catalog/database_catalog.h"
 #include "common/logger.h"
+#include "concurrency/transaction_context.h"
 
 namespace peloton {
 namespace catalog {
@@ -24,27 +25,27 @@ namespace catalog {
  * @param   database_object
  * @return  false only if database_oid already exists in cache
  */
-bool CatalogCache::InsertDatabaseObject(
+bool CatalogCache::InsertDatabaseCatalogEntry(
     std::shared_ptr<DatabaseCatalogEntry> database_object) {
   if (!database_object || database_object->GetDatabaseOid() == INVALID_OID) {
     return false;  // invalid object
   }
 
   // check if already in cache
-  if (database_objects_cache_.find(database_object->GetDatabaseOid()) !=
-      database_objects_cache_.end()) {
-    LOG_DEBUG("Database %u already exists in cache!",
+  if (database_catalog_entries_cache_.find(database_object->GetDatabaseOid()) !=
+      database_catalog_entries_cache_.end()) {
+    LOG_TRACE("Database %u already exists in cache!",
               database_object->GetDatabaseOid());
     return false;
   }
   if (database_name_cache_.find(database_object->GetDatabaseName()) !=
       database_name_cache_.end()) {
-    LOG_DEBUG("Database %s already exists in cache!",
+    LOG_TRACE("Database %s already exists in cache!",
               database_object->GetDatabaseName().c_str());
     return false;
   }
 
-  database_objects_cache_.insert(
+  database_catalog_entries_cache_.insert(
       std::make_pair(database_object->GetDatabaseOid(), database_object));
   database_name_cache_.insert(
       std::make_pair(database_object->GetDatabaseName(), database_object));
@@ -55,15 +56,15 @@ bool CatalogCache::InsertDatabaseObject(
  * @param   database_oid
  * @return  true if database_oid is found and evicted; false if not found
  */
-bool CatalogCache::EvictDatabaseObject(oid_t database_oid) {
-  auto it = database_objects_cache_.find(database_oid);
-  if (it == database_objects_cache_.end()) {
+bool CatalogCache::EvictDatabaseCatalogEntry(oid_t database_oid) {
+  auto it = database_catalog_entries_cache_.find(database_oid);
+  if (it == database_catalog_entries_cache_.end()) {
     return false;  // database oid not found in cache
   }
 
   auto database_object = it->second;
   PELOTON_ASSERT(database_object);
-  database_objects_cache_.erase(it);
+  database_catalog_entries_cache_.erase(it);
   database_name_cache_.erase(database_object->GetDatabaseName());
   return true;
 }
@@ -72,7 +73,7 @@ bool CatalogCache::EvictDatabaseObject(oid_t database_oid) {
  * @param   database_name
  * @return  true if database_name is found and evicted; false if not found
  */
-bool CatalogCache::EvictDatabaseObject(const std::string &database_name) {
+bool CatalogCache::EvictDatabaseCatalogEntry(const std::string &database_name) {
   auto it = database_name_cache_.find(database_name);
   if (it == database_name_cache_.end()) {
     return false;  // database name not found in cache
@@ -81,18 +82,18 @@ bool CatalogCache::EvictDatabaseObject(const std::string &database_name) {
   auto database_object = it->second;
   PELOTON_ASSERT(database_object);
   database_name_cache_.erase(it);
-  database_objects_cache_.erase(database_object->GetDatabaseOid());
+  database_catalog_entries_cache_.erase(database_object->GetDatabaseOid());
   return true;
 }
 
 /*@brief   get database catalog object from cache
  * @param   database_oid
  * @return  database catalog object; if not found return object with invalid oid
  */
-std::shared_ptr<DatabaseCatalogEntry> CatalogCache::GetDatabaseObject(
-    oid_t database_oid) {
-  auto it = database_objects_cache_.find(database_oid);
-  if (it == database_objects_cache_.end()) {
+std::shared_ptr<DatabaseCatalogEntry>
+CatalogCache::GetDatabaseCatalogEntry(oid_t database_oid) {
+  auto it = database_catalog_entries_cache_.find(database_oid);
+  if (it == database_catalog_entries_cache_.end()) {
     return nullptr;
   }
   return it->second;
@@ -102,23 +103,40 @@ std::shared_ptr<DatabaseCatalogEntry> CatalogCache::GetDatabaseObject(
  * @param   database_name
  * @return  database catalog object; if not found return null
  */
-std::shared_ptr<DatabaseCatalogEntry> CatalogCache::GetDatabaseObject(
-    const std::string &database_name) {
+std::shared_ptr<DatabaseCatalogEntry>
+CatalogCache::GetDatabaseCatalogEntry(const std::string &database_name) {
   auto it = database_name_cache_.find(database_name);
   if (it == database_name_cache_.end()) {
     return nullptr;
   }
   return it->second;
 }
 
+/* @brief   Get database catalog object from cache,
+            or all the way from storage
+ * @param   txn   if nullptr, return nullptr on a cache miss
+ * @return  Shared pointer to the requested database catalog object
+ */
+std::unordered_map<oid_t, std::shared_ptr<DatabaseCatalogEntry>>
+CatalogCache::GetDatabaseCatalogEntries(concurrency::TransactionContext *txn) {
+  if (!valid_database_catalog_entry_ && txn != nullptr) {
+    // cache miss get from pg_database
+    return DatabaseCatalog::GetInstance()->GetDatabaseCatalogEntries(txn);
+  }
+  // make sure to check IsValidTableObjects() before getting table objects
+  PELOTON_ASSERT(valid_database_catalog_entry_);
+  return database_catalog_entries_cache_;
+}
+
 /*@brief   search table catalog object from all cached database objects
  * @param   table_oid
  * @return  table catalog object; if not found return null
  */
-std::shared_ptr<TableCatalogEntry> CatalogCache::GetCachedTableObject(
-		oid_t database_oid, oid_t table_oid) {
-	auto database_object = GetDatabaseObject(database_oid);
-	if (database_object == nullptr) return nullptr;
+std::shared_ptr<TableCatalogEntry>
+CatalogCache::GetCachedTableCatalogEntry(oid_t database_oid,
+                                         oid_t table_oid) {
+  auto database_object = GetDatabaseCatalogEntry(database_oid);
+  if (database_object == nullptr) return nullptr;
   auto table_object = database_object->GetTableCatalogEntry(table_oid, true);
   if (table_object) return table_object;
   return nullptr;
@@ -128,27 +146,30 @@ std::shared_ptr<TableCatalogEntry> CatalogCache::GetCachedTableObject(
  * @param   index_oid
  * @return  index catalog object; if not found return null
  */
-std::shared_ptr<IndexCatalogEntry> CatalogCache::GetCachedIndexObject(
-		oid_t database_oid, oid_t index_oid) {
-	auto database_object = GetDatabaseObject(database_oid);
-	if (database_object == nullptr) return nullptr;
-	auto index_object = database_object->GetCachedIndexCatalogEntry(index_oid);
-	if (index_object) return index_object;
+std::shared_ptr<IndexCatalogEntry>
+CatalogCache::GetCachedIndexCatalogEntry(oid_t database_oid,
+                                         oid_t index_oid) {
+  auto database_object = GetDatabaseCatalogEntry(database_oid);
+  if (database_object == nullptr) return nullptr;
+  auto index_object = database_object->GetCachedIndexCatalogEntry(index_oid);
+  if (index_object) return index_object;
   return nullptr;
 }
 
 /*@brief   search index catalog object from all cached database objects
  * @param   index_name
  * @return  index catalog object; if not found return null
  */
-std::shared_ptr<IndexCatalogEntry> CatalogCache::GetCachedIndexObject(const std::string &database_name,
-                                                                       const std::string &schema_name,
-                                                                       const std::string &index_name) {
-	auto database_object = GetDatabaseObject(database_name);
-	if (database_object == nullptr) return nullptr;
-	auto index_object =
-        database_object->GetCachedIndexCatalogEntry(index_name, schema_name);
-	if (index_object) return index_object;
+std::shared_ptr<IndexCatalogEntry>
+CatalogCache::GetCachedIndexCatalogEntry(const std::string &database_name,
+                                         const std::string &index_name,
+                                         const std::string &schema_name) {
+  auto database_object = GetDatabaseCatalogEntry(database_name);
+  if (database_object == nullptr) return nullptr;
+  auto index_object =
+      database_object->GetCachedIndexCatalogEntry(index_name, schema_name);
+  if (index_object) return index_object;
+
   return nullptr;
 }
 

src/catalog/database_catalog.cpp

@@ -26,11 +26,14 @@ namespace peloton {
 namespace catalog {
 
 DatabaseCatalogEntry::DatabaseCatalogEntry(concurrency::TransactionContext *txn,
-                                           executor::LogicalTile *tile)
-    : database_oid_(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_OID)
-                       .GetAs<oid_t>()),
-      database_name_(tile->GetValue(0, DatabaseCatalog::ColumnId::DATABASE_NAME)
-                        .ToString()),
+                                           executor::LogicalTile *tile,
+                                           int tupleId)
+    : database_oid_(
+          tile->GetValue(tupleId, DatabaseCatalog::ColumnId::DATABASE_OID)
+              .GetAs<oid_t>()),
+      database_name_(
+          tile->GetValue(tupleId, DatabaseCatalog::ColumnId::DATABASE_NAME)
+              .ToString()),
       table_catalog_entries_cache_(),
       table_catalog_entries_cache_by_name(),
       valid_table_catalog_entries(false),
@@ -180,7 +183,7 @@ DatabaseCatalogEntry::GetTableCatalogEntries(const std::string &schema_name) {
     // insert every table object into cache
     pg_table->GetTableCatalogEntries(txn_);
   }
-  // make sure to check IsValidTableObjects() before getting table objects
+  // make sure to check IsValidTableCatalogEntries() before getting table objects
   PELOTON_ASSERT(valid_table_catalog_entries);
   std::vector<std::shared_ptr<TableCatalogEntry>> result;
   for (auto it : table_catalog_entries_cache_) {
@@ -206,7 +209,7 @@ DatabaseCatalogEntry::GetTableCatalogEntries(bool cached_only) {
                         ->GetTableCatalog();
     return pg_table->GetTableCatalogEntries(txn_);
   }
-  // make sure to check IsValidTableObjects() before getting table objects
+  // make sure to check IsValidTableCatalogEntries() before getting table objects
   PELOTON_ASSERT(valid_table_catalog_entries);
   return table_catalog_entries_cache_;
 }
@@ -324,7 +327,7 @@ bool DatabaseCatalog::DeleteDatabase(concurrency::TransactionContext *txn, oid_t
   values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy());
 
   // evict cache
-  txn->catalog_cache.EvictDatabaseObject(database_oid);
+  txn->catalog_cache.EvictDatabaseCatalogEntry(database_oid);
 
   return DeleteWithIndexScan(txn, index_offset, values);
 }
@@ -336,7 +339,7 @@ std::shared_ptr<DatabaseCatalogEntry> DatabaseCatalog::GetDatabaseCatalogEntry(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid);
+  auto database_object = txn->catalog_cache.GetDatabaseCatalogEntry(database_oid);
   if (database_object) return database_object;
 
   // cache miss, get from pg_database
@@ -355,7 +358,7 @@ std::shared_ptr<DatabaseCatalogEntry> DatabaseCatalog::GetDatabaseCatalogEntry(
     auto database_object =
         std::make_shared<DatabaseCatalogEntry>(txn, (*result_tiles)[0].get());
     // insert into cache
-    bool success = txn->catalog_cache.InsertDatabaseObject(database_object);
+    bool success = txn->catalog_cache.InsertDatabaseCatalogEntry(database_object);
     PELOTON_ASSERT(success == true);
     (void)success;
     return database_object;
@@ -379,7 +382,7 @@ std::shared_ptr<DatabaseCatalogEntry> DatabaseCatalog::GetDatabaseCatalogEntry(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto database_object = txn->catalog_cache.GetDatabaseObject(database_name);
+  auto database_object = txn->catalog_cache.GetDatabaseCatalogEntry(database_name);
   if (database_object) return database_object;
 
   // cache miss, get from pg_database
@@ -400,7 +403,7 @@ std::shared_ptr<DatabaseCatalogEntry> DatabaseCatalog::GetDatabaseCatalogEntry(
         std::make_shared<DatabaseCatalogEntry>(txn, (*result_tiles)[0].get());
     if (database_object) {
       // insert into cache
-      bool success = txn->catalog_cache.InsertDatabaseObject(database_object);
+      bool success = txn->catalog_cache.InsertDatabaseCatalogEntry(database_object);
       PELOTON_ASSERT(success == true);
       (void)success;
     }
@@ -411,5 +414,35 @@ std::shared_ptr<DatabaseCatalogEntry> DatabaseCatalog::GetDatabaseCatalogEntry(
   return nullptr;
 }
 
+std::unordered_map<oid_t, std::shared_ptr<DatabaseCatalogEntry>>
+DatabaseCatalog::GetDatabaseCatalogEntries(concurrency::TransactionContext *txn) {
+  if (txn == nullptr) {
+    throw CatalogException("Transaction is invalid!");
+  }
+
+  // try get from cache
+  if (txn->catalog_cache.IsValidDatabaseCatalogEntries()) {
+    return txn->catalog_cache.GetDatabaseCatalogEntries();
+  }
+
+  // get from pg_database
+  std::vector<oid_t> column_ids(all_column_ids_);
+  auto result_tiles = this->GetResultWithSeqScan(txn, nullptr, column_ids);
+
+  for (auto &tile : (*result_tiles)) {
+    for (auto tuple_id : *tile) {
+      auto database_object =
+          std::make_shared<DatabaseCatalogEntry>(txn, tile.get(), tuple_id);
+      if (database_object) {
+        // insert into cache
+        txn->catalog_cache.InsertDatabaseCatalogEntry(database_object);
+      }
+    }
+  }
+
+  txn->catalog_cache.SetValidDatabaseCatalogEntries(true);
+  return txn->catalog_cache.GetDatabaseCatalogEntries();
+}
+
 }  // namespace catalog
 }  // namespace peloton

src/catalog/index_catalog.cpp

@@ -186,12 +186,12 @@ bool IndexCatalog::DeleteIndex(concurrency::TransactionContext *txn,
   std::vector<type::Value> values;
   values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy());
 
-  auto index_object = txn->catalog_cache.GetCachedIndexObject(database_oid,
-                                                              index_oid);
+  auto index_object = txn->catalog_cache.GetCachedIndexCatalogEntry(database_oid,
+                                                                    index_oid);
   if (index_object) {
     auto table_object =
-        txn->catalog_cache.GetCachedTableObject(database_oid,
-                                                index_object->GetTableOid());
+        txn->catalog_cache.GetCachedTableCatalogEntry(database_oid,
+                                                      index_object->GetTableOid());
     table_object->EvictAllIndexCatalogEntries();
   }
 
@@ -206,8 +206,8 @@ std::shared_ptr<IndexCatalogEntry> IndexCatalog::GetIndexCatalogEntry(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto index_object = txn->catalog_cache.GetCachedIndexObject(database_oid,
-                                                              index_oid);
+  auto index_object = txn->catalog_cache.GetCachedIndexCatalogEntry(database_oid,
+                                                                    index_oid);
   if (index_object) {
     return index_object;
   }
@@ -254,9 +254,9 @@ std::shared_ptr<IndexCatalogEntry> IndexCatalog::GetIndexCatalogEntry(
   }
   // try get from cache
   auto index_object =
-      txn->catalog_cache.GetCachedIndexObject(database_name,
-                                              schema_name,
-                                              index_name);
+      txn->catalog_cache.GetCachedIndexCatalogEntry(database_name,
+                                                    schema_name,
+                                                    index_name);
   if (index_object) {
     return index_object;
   }