This compiles and passes all the tests except for the sequence test (obviously)

Author: apavlo

src/catalog/catalog_cache.cpp

@@ -112,6 +112,14 @@ std::shared_ptr<DatabaseCatalogObject> CatalogCache::GetDatabaseObject(
   return it->second;
 }
 
+std::vector<std::shared_ptr<DatabaseCatalogObject>> CatalogCache::GetAllDatabaseObjects() {
+  std::vector<std::shared_ptr<DatabaseCatalogObject>> databases;
+  for (auto it : database_objects_cache) {
+    databases.push_back(it.second);
+  }
+  return (databases);
+}
+
 /*@brief   search table catalog object from all cached database objects
  * @param   table_oid
  * @return  table catalog object; if not found return null

src/catalog/database_catalog.cpp

@@ -314,7 +314,7 @@ bool DatabaseCatalog::DeleteDatabase(oid_t database_oid,
   values.push_back(type::ValueFactory::GetIntegerValue(database_oid).Copy());
 
   // evict cache
-  txn->catalog_cache.EvictDatabaseObject(database_oid);
+  txn->GetCatalogCache()->EvictDatabaseObject(database_oid);
 
   return DeleteWithIndexScan(index_offset, values, txn);
 }
@@ -325,7 +325,7 @@ std::shared_ptr<DatabaseCatalogObject> DatabaseCatalog::GetDatabaseObject(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid);
+  auto database_object = txn->GetCatalogCache()->GetDatabaseObject(database_oid);
   if (database_object) return database_object;
 
   // cache miss, get from pg_database
@@ -341,7 +341,7 @@ std::shared_ptr<DatabaseCatalogObject> DatabaseCatalog::GetDatabaseObject(
     auto database_object =
         std::make_shared<DatabaseCatalogObject>((*result_tiles)[0].get(), txn);
     // insert into cache
-    bool success = txn->catalog_cache.InsertDatabaseObject(database_object);
+    bool success = txn->GetCatalogCache()->InsertDatabaseObject(database_object);
     PELOTON_ASSERT(success == true);
     (void)success;
     return database_object;
@@ -364,7 +364,7 @@ std::shared_ptr<DatabaseCatalogObject> DatabaseCatalog::GetDatabaseObject(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto database_object = txn->catalog_cache.GetDatabaseObject(database_name);
+  auto database_object = txn->GetCatalogCache()->GetDatabaseObject(database_name);
   if (database_object) return database_object;
 
   // cache miss, get from pg_database
@@ -382,7 +382,7 @@ std::shared_ptr<DatabaseCatalogObject> DatabaseCatalog::GetDatabaseObject(
         std::make_shared<DatabaseCatalogObject>((*result_tiles)[0].get(), txn);
     if (database_object) {
       // insert into cache
-      bool success = txn->catalog_cache.InsertDatabaseObject(database_object);
+      bool success = txn->GetCatalogCache()->InsertDatabaseObject(database_object);
       PELOTON_ASSERT(success == true);
       (void)success;
     }

src/catalog/index_catalog.cpp

@@ -173,10 +173,10 @@ bool IndexCatalog::DeleteIndex(oid_t index_oid,
   std::vector<type::Value> values;
   values.push_back(type::ValueFactory::GetIntegerValue(index_oid).Copy());
 
-  auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid);
+  auto index_object = txn->GetCatalogCache()->GetCachedIndexObject(index_oid);
   if (index_object) {
     auto table_object =
-        txn->catalog_cache.GetCachedTableObject(index_object->GetTableOid());
+        txn->GetCatalogCache()->GetCachedTableObject(index_object->GetTableOid());
     table_object->EvictAllIndexObjects();
   }
 
@@ -189,7 +189,7 @@ std::shared_ptr<IndexCatalogObject> IndexCatalog::GetIndexObject(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto index_object = txn->catalog_cache.GetCachedIndexObject(index_oid);
+  auto index_object = txn->GetCatalogCache()->GetCachedIndexObject(index_oid);
   if (index_object) {
     return index_object;
   }
@@ -231,7 +231,7 @@ std::shared_ptr<IndexCatalogObject> IndexCatalog::GetIndexObject(
   }
   // try get from cache
   auto index_object =
-      txn->catalog_cache.GetCachedIndexObject(index_name, schema_name);
+      txn->GetCatalogCache()->GetCachedIndexObject(index_name, schema_name);
   if (index_object) {
     return index_object;
   }

src/catalog/table_catalog.cpp

@@ -501,7 +501,7 @@ bool TableCatalog::DeleteTable(oid_t table_oid,
   values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy());
 
   // evict from cache
-  auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid);
+  auto table_object = txn->GetCatalogCache()->GetCachedTableObject(table_oid);
   if (table_object) {
     auto database_object =
         DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn);
@@ -522,7 +522,7 @@ std::shared_ptr<TableCatalogObject> TableCatalog::GetTableObject(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid);
+  auto table_object = txn->GetCatalogCache()->GetCachedTableObject(table_oid);
   if (table_object) return table_object;
 
   // cache miss, get from pg_table
@@ -568,7 +568,7 @@ std::shared_ptr<TableCatalogObject> TableCatalog::GetTableObject(
     throw CatalogException("Transaction is invalid!");
   }
   // try get from cache
-  auto database_object = txn->catalog_cache.GetDatabaseObject(database_oid);
+  auto database_object = txn->GetCatalogCache()->GetDatabaseObject(database_oid);
   if (database_object) {
     auto table_object =
         database_object->GetTableObject(table_name, schema_name, true);
@@ -662,7 +662,7 @@ bool TableCatalog::UpdateVersionId(oid_t update_val, oid_t table_oid,
       type::ValueFactory::GetIntegerValue(update_val).Copy());
 
   // get table object, then evict table object
-  auto table_object = txn->catalog_cache.GetCachedTableObject(table_oid);
+  auto table_object = txn->GetCatalogCache()->GetCachedTableObject(table_oid);
   if (table_object) {
     auto database_object =
         DatabaseCatalog::GetInstance()->GetDatabaseObject(database_oid, txn);

src/concurrency/transaction_context.cpp

@@ -87,6 +87,11 @@ void TransactionContext::Init(const size_t thread_id,
   gc_set_.reset(new GCSet());
   gc_object_set_.reset(new GCObjectSet());
 
+  // TODO: I think that we need to delete this object when
+  // we delete the TransactionContext. It probably shouldn't
+  // be a shared_ptr since the TransactionContext owns it
+  catalog_cache.reset(new catalog::CatalogCache());
+
   on_commit_triggers_.reset();
 }
 

src/function/sequence_functions.cpp

@@ -35,28 +35,32 @@ uint32_t SequenceFunctions::Nextval(executor::ExecutorContext &ctx,
                                    const char *sequence_name) {
   PELOTON_ASSERT(sequence_name != nullptr);
   concurrency::TransactionContext* txn = ctx.GetTransaction();
-  // get the database oid for this transaction
-  oid_t database_oid = catalog::Catalog::GetInstance()
-          ->GetDatabaseObject(ctx.GetDatabaseName(), txn)->GetDatabaseOid();
-  LOG_DEBUG("Get database oid: %u", database_oid);
+
+  // HACK: Assume that there is only one database in our cache
+  auto all_databases = txn->GetCatalogCache()->GetAllDatabaseObjects();
+  PELOTON_ASSERT(all_databases.empty() == false);
+  auto database_catalog = all_databases[0];
+  LOG_DEBUG("Get database oid: %u", database_catalog->GetDatabaseOid());
 
   // initialize a new transaction for incrementing sequence value
   auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
   auto mini_txn = txn_manager.BeginTransaction();
 
   // evict the old cached copy of sequence
-  txn->catalog_cache.EvictSequenceObject(sequence_name,database_oid);
+  txn->GetCatalogCache()->EvictSequenceObject(sequence_name,
+                                              database_catalog->GetDatabaseOid());
   auto sequence_object =
           catalog::Catalog::GetInstance()
-          ->GetSystemCatalogs(database_oid)
+          ->GetSystemCatalogs(database_catalog->GetDatabaseOid())
           ->GetSequenceCatalog()
-          ->GetSequence(database_oid, sequence_name, mini_txn);
+          ->GetSequence(database_catalog->GetDatabaseOid(),
+                        sequence_name, mini_txn);
 
   if (sequence_object != nullptr) {
     uint32_t val = sequence_object->GetNextVal();
     int64_t curr_val = sequence_object->GetCurrVal();
     // insert the new copy of sequence into cache for future currval
-    txn->catalog_cache.InsertSequenceObject(sequence_object);
+    txn->GetCatalogCache()->InsertSequenceObject(sequence_object);
 
     auto ret = txn_manager.CommitTransaction(mini_txn);
     if (ret != ResultType::SUCCESS) {
@@ -65,9 +69,9 @@ uint32_t SequenceFunctions::Nextval(executor::ExecutorContext &ctx,
     }
 
     catalog::Catalog::GetInstance()
-                  ->GetSystemCatalogs(database_oid)
+                  ->GetSystemCatalogs(database_catalog->GetDatabaseOid())
                   ->GetSequenceCatalog()
-                  ->InsertCurrValCache(txn->GetTemporarySchemaName(),
+                  ->InsertCurrValCache("FIXME_SCHEMA",
                                        sequence_name, curr_val);
     return val;
   } else {
@@ -88,23 +92,24 @@ uint32_t SequenceFunctions::Currval(executor::ExecutorContext &ctx,
   PELOTON_ASSERT(sequence_name != nullptr);
   concurrency::TransactionContext* txn = ctx.GetTransaction();
   // get the database oid for this transaction
-  oid_t database_oid = catalog::Catalog::GetInstance()
-          ->GetDatabaseObject(ctx.GetDatabaseName(), txn)->GetDatabaseOid();
-  LOG_DEBUG("Get database oid: %u", database_oid);
+  // HACK: Assume that there is only one database in our cache
+  auto all_databases = txn->GetCatalogCache()->GetAllDatabaseObjects();
+  PELOTON_ASSERT(all_databases.empty() == false);
+  auto database_catalog = all_databases[0];
 
   // get the sequence copy from cache
   auto sequence_catalog = catalog::Catalog::GetInstance()
-                    ->GetSystemCatalogs(database_oid)
+                    ->GetSystemCatalogs(database_catalog->GetDatabaseOid())
                     ->GetSequenceCatalog();
 
   if(sequence_catalog->CheckCachedCurrValExistence(
-      txn->GetTemporarySchemaName(), std::string(sequence_name))) {
+      "FIXME_SCHEMA", std::string(sequence_name))) {
     return sequence_catalog->GetCachedCurrVal(
-      txn->GetTemporarySchemaName(), std::string(sequence_name));
+      "FIXME_SCHEMA", std::string(sequence_name));
   } else {
     // get sequence from catalog
     auto sequence_object = sequence_catalog
-                    ->GetSequence(database_oid, sequence_name, txn);
+                    ->GetSequence(database_catalog->GetDatabaseOid(), sequence_name, txn);
     if (sequence_object != nullptr) {
       throw SequenceException(
               StringUtil::Format("currval for sequence \"%s\" is undefined for this session",

src/include/catalog/catalog_cache.h

@@ -13,6 +13,7 @@
 #pragma once
 
 #include <mutex>
+#include <vector>
 #include <unordered_map>
 
 #include "common/internal_types.h"
@@ -35,7 +36,6 @@ class TableCatalogObject;
 class IndexCatalogObject;
 
 class CatalogCache {
-  friend class Transaction;
   friend class DatabaseCatalog;
   friend class TableCatalog;
   friend class IndexCatalog;
@@ -56,6 +56,12 @@ class CatalogCache {
   std::shared_ptr<DatabaseCatalogObject> GetDatabaseObject(
       const std::string &name);
 
+  /**
+   * @brief Retrieve a vector of all the DatabaseObjects cached
+   * @return
+   */
+  std::vector<std::shared_ptr<DatabaseCatalogObject>> GetAllDatabaseObjects();
+
   std::shared_ptr<TableCatalogObject> GetCachedTableObject(oid_t table_oid);
   std::shared_ptr<IndexCatalogObject> GetCachedIndexObject(oid_t index_oid);
   std::shared_ptr<IndexCatalogObject> GetCachedIndexObject(

src/include/concurrency/transaction_context.h

@@ -69,6 +69,14 @@ class TransactionContext : public Printable {
   // Mutators and Accessors
   //===--------------------------------------------------------------------===//
 
+  /**
+   * @brief Get the CatalogCache for this txn
+   * @return the CatalogCache for this txn
+   */
+  inline std::shared_ptr<catalog::CatalogCache> GetCatalogCache() const {
+    return (catalog_cache);
+  }
+
   /**
    * @brief      Gets the thread identifier.
    *
@@ -283,14 +291,14 @@ class TransactionContext : public Printable {
     return isolation_level_;
   }
 
-  /** cache for table catalog objects */
-  catalog::CatalogCache catalog_cache;
-
  private:
   //===--------------------------------------------------------------------===//
   // Data members
   //===--------------------------------------------------------------------===//
 
+  /** cache for table catalog objects */
+  std::shared_ptr<catalog::CatalogCache> catalog_cache;
+
   /** transaction id */
   txn_id_t txn_id_;
 

src/include/planner/plan_util.h

@@ -62,7 +62,7 @@ class PlanUtil {
    * @return set of affected index object ids
    */
   static const std::set<oid_t> GetAffectedIndexes(
-      catalog::CatalogCache &catalog_cache,
+      std::shared_ptr<catalog::CatalogCache> catalog_cache,
       const parser::SQLStatement &sql_stmt);
 
   /**
@@ -73,7 +73,7 @@ class PlanUtil {
   * @return vector of affected column ids with triplet format
   */
   static const std::vector<col_triplet> GetIndexableColumns(
-      catalog::CatalogCache &catalog_cache,
+      std::shared_ptr<catalog::CatalogCache> catalog_cache,
       std::unique_ptr<parser::SQLStatementList> sql_stmt_list,
       const std::string &db_name);
 

src/planner/plan_util.cpp

@@ -34,7 +34,7 @@ namespace peloton {
 namespace planner {
 
 const std::set<oid_t> PlanUtil::GetAffectedIndexes(
-    catalog::CatalogCache &catalog_cache,
+    std::shared_ptr<catalog::CatalogCache> catalog_cache,
     const parser::SQLStatement &sql_stmt) {
   std::set<oid_t> index_oids;
   std::string db_name, table_name, schema_name;
@@ -56,7 +56,7 @@ const std::set<oid_t> PlanUtil::GetAffectedIndexes(
         table_name = delete_stmt.GetTableName();
         schema_name = delete_stmt.GetSchemaName();
       }
-      auto indexes_map = catalog_cache.GetDatabaseObject(db_name)
+      auto indexes_map = catalog_cache->GetDatabaseObject(db_name)
                              ->GetTableObject(table_name, schema_name)
                              ->GetIndexObjects();
       for (auto &index : indexes_map) {
@@ -69,7 +69,7 @@ const std::set<oid_t> PlanUtil::GetAffectedIndexes(
       db_name = update_stmt.table->GetDatabaseName();
       table_name = update_stmt.table->GetTableName();
       schema_name = update_stmt.table->GetSchemaName();
-      auto table_object = catalog_cache.GetDatabaseObject(db_name)
+      auto table_object = catalog_cache->GetDatabaseObject(db_name)
                               ->GetTableObject(table_name, schema_name);
 
       auto &update_clauses = update_stmt.updates;
@@ -105,7 +105,7 @@ const std::set<oid_t> PlanUtil::GetAffectedIndexes(
 }
 
 const std::vector<col_triplet> PlanUtil::GetIndexableColumns(
-    catalog::CatalogCache &catalog_cache,
+    std::shared_ptr<catalog::CatalogCache> catalog_cache,
     std::unique_ptr<parser::SQLStatementList> sql_stmt_list,
     const std::string &db_name) {
   std::vector<col_triplet> column_oids;
@@ -132,7 +132,7 @@ const std::vector<col_triplet> PlanUtil::GetIndexableColumns(
       try {
         auto plan = optimizer->BuildPelotonPlanTree(sql_stmt_list, txn);
 
-        auto db_object = catalog_cache.GetDatabaseObject(db_name);
+        auto db_object = catalog_cache->GetDatabaseObject(db_name);
         database_id = db_object->GetDatabaseOid();
 
         // Perform a breadth first search on plan tree