Checkpointing

src/catalog/catalog.cpp

@@ -15,6 +15,7 @@
 #include "catalog/column_catalog.h"
 #include "catalog/database_catalog.h"
 #include "catalog/database_metrics_catalog.h"
+#include "catalog/foreign_key.h"
 #include "catalog/index_catalog.h"
 #include "catalog/index_metrics_catalog.h"
 #include "catalog/language_catalog.h"
@@ -148,12 +149,12 @@ void Catalog::Bootstrap() {
   DatabaseMetricsCatalog::GetInstance(txn);
   TableMetricsCatalog::GetInstance(txn);
   IndexMetricsCatalog::GetInstance(txn);
-  QueryMetricsCatalog::GetInstance(txn);  
+  QueryMetricsCatalog::GetInstance(txn);
   SettingsCatalog::GetInstance(txn);
   TriggerCatalog::GetInstance(txn);
   LanguageCatalog::GetInstance(txn);
   ProcCatalog::GetInstance(txn);
-  
+
   if (settings::SettingsManager::GetBool(settings::SettingId::brain)) {
     QueryHistoryCatalog::GetInstance(txn);
   }
@@ -614,18 +615,18 @@ ResultType Catalog::DropIndex(oid_t index_oid,
 
 ResultType Catalog::DropIndex(const std::string &index_name,
                               concurrency::TransactionContext *txn) {
-    if(txn == nullptr) {
-        throw CatalogException("Do not have transaction to drop index " +
-                               index_name);
-    }
-    auto index_object = catalog::IndexCatalog::GetInstance()->GetIndexObject(
-                index_name, txn);
-    if(index_object == nullptr) {
-        throw CatalogException("Index name " + index_name + " cannot be found");
-    }
-    ResultType result = DropIndex(index_object->GetIndexOid(), txn);
+  if (txn == nullptr) {
+    throw CatalogException("Do not have transaction to drop index " +
+                           index_name);
+  }
+  auto index_object =
+      catalog::IndexCatalog::GetInstance()->GetIndexObject(index_name, txn);
+  if (index_object == nullptr) {
+    throw CatalogException("Index name " + index_name + " cannot be found");
+  }
+  ResultType result = DropIndex(index_object->GetIndexOid(), txn);
 
-    return result;
+  return result;
 }
 
 //===--------------------------------------------------------------------===//
@@ -719,6 +720,26 @@ std::shared_ptr<DatabaseCatalogObject> Catalog::GetDatabaseObject(
   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<DatabaseCatalogObject>>
+Catalog::GetDatabaseObjects(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_objects) {
+    // cache miss get from pg_table
+    return DatabaseCatalog::GetInstance()->GetDatabaseObjects(txn);
+  }
+  // make sure to check IsValidTableObjects() before getting table objects
+  PELOTON_ASSERT(txn->catalog_cache.valid_database_objects);
+  return txn->catalog_cache.database_objects_cache;
+}
+
 /* Check table from pg_table with table_name using txn,
  * get it from storage layer using table_oid,
  * throw exception and abort txn if not exists/invisible
@@ -787,6 +808,76 @@ std::shared_ptr<TableCatalogObject> Catalog::GetTableObject(
   return table_object;
 }
 
+//===--------------------------------------------------------------------===//
+// CHECK EXISTENCE WITH NAME - CHECK FROM CATALOG TABLES, USING TRANSACTION
+//===--------------------------------------------------------------------===//
+
+// check existence of database with database_name using txn.
+bool Catalog::ExistDatabaseByName(const std::string &database_name,
+                                  concurrency::TransactionContext *txn) {
+  if (txn == nullptr)
+    throw CatalogException("Do not have transaction to check database " +
+                           database_name);
+
+  auto database_object =
+      DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn);
+  if (database_object == nullptr) {
+    return false;
+  } else {
+    return true;
+  }
+}
+
+// check existence of table with table_name using txn.
+bool Catalog::ExistTableByName(const std::string &database_name,
+                               const std::string &table_name,
+                               concurrency::TransactionContext *txn) {
+  if (txn == nullptr)
+    throw CatalogException("Do not have transaction to check table " +
+                           table_name);
+
+  auto database_object =
+      DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn);
+  if (database_object == nullptr) {
+    return false;
+  } else {
+    auto table_object = database_object->GetTableObject(table_name);
+    if (table_object == nullptr) {
+      return false;
+    } else {
+      return true;
+    }
+  }
+}
+
+// check existence of index with index_name using txn.
+bool Catalog::ExistIndexByName(const std::string &database_name,
+                               const std::string &table_name,
+                               const std::string &index_name,
+                               concurrency::TransactionContext *txn) {
+  if (txn == nullptr)
+    throw CatalogException("Do not have transaction to check index " +
+                           index_name);
+
+  auto database_object =
+      DatabaseCatalog::GetInstance()->GetDatabaseObject(database_name, txn);
+  if (database_object == nullptr) {
+    return false;
+  } else {
+    auto table_object = database_object->GetTableObject(table_name);
+    if (table_object == nullptr) {
+      return false;
+    } else {
+      auto index_object = table_object->GetIndexObject(index_name);
+      if (index_object == nullptr) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+  }
+}
+
 //===--------------------------------------------------------------------===//
 // DEPRECATED
 //===--------------------------------------------------------------------===//
@@ -1064,11 +1155,11 @@ void Catalog::InitializeFunctions() {
       /**
        * decimal functions
        */
-      AddBuiltinFunction(
-          "abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL, internal_lang,
-          "Abs", function::BuiltInFuncType{OperatorId::Abs,
-                                            function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::DECIMAL}, type::TypeId::DECIMAL,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
       AddBuiltinFunction(
           "sqrt", {type::TypeId::TINYINT}, type::TypeId::DECIMAL, internal_lang,
           "Sqrt", function::BuiltInFuncType{OperatorId::Sqrt,
@@ -1105,33 +1196,29 @@ void Catalog::InitializeFunctions() {
       /**
        * integer functions
        */
-      AddBuiltinFunction(
-          "abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::TINYINT}, type::TypeId::TINYINT,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
-      AddBuiltinFunction(
-          "abs", {type::TypeId::SMALLINT}, type::TypeId::SMALLINT, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::SMALLINT},
+                         type::TypeId::SMALLINT, internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
-      AddBuiltinFunction(
-          "abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::INTEGER}, type::TypeId::INTEGER,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
-      AddBuiltinFunction(
-          "abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT, 
-          internal_lang, "Abs",
-          function::BuiltInFuncType{OperatorId::Abs,
-                                    function::DecimalFunctions::_Abs},
-          txn);
+      AddBuiltinFunction("abs", {type::TypeId::BIGINT}, type::TypeId::BIGINT,
+                         internal_lang, "Abs",
+                         function::BuiltInFuncType{
+                             OperatorId::Abs, function::DecimalFunctions::_Abs},
+                         txn);
 
       AddBuiltinFunction(
           "floor", {type::TypeId::INTEGER}, type::TypeId::DECIMAL,

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 {
@@ -33,13 +34,13 @@ bool CatalogCache::InsertDatabaseObject(
   // 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!",
+    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;
   }
@@ -111,6 +112,22 @@ std::shared_ptr<DatabaseCatalogObject> CatalogCache::GetDatabaseObject(
   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<DatabaseCatalogObject>>
+CatalogCache::GetDatabaseObjects(concurrency::TransactionContext *txn) {
+  if (!valid_database_objects && txn != nullptr) {
+    // cache miss get from pg_database
+    return DatabaseCatalog::GetInstance()->GetDatabaseObjects(txn);
+  }
+  // make sure to check IsValidTableObjects() before getting table objects
+  PELOTON_ASSERT(valid_database_objects);
+  return database_objects_cache;
+}
+
 /*@brief   search table catalog object from all cached database objects
 * @param   table_oid
 * @return  table catalog object; if not found return null

src/catalog/column.cpp

@@ -42,6 +42,48 @@ void Column::SetInlined() {
   }
 }
 
+// Serialize this column
+void Column::SerializeTo(SerializeOutput &out) {
+  // Column basic information
+  out.WriteTextString(column_name);
+  out.WriteInt((int)column_type);
+  out.WriteInt(GetLength());
+  out.WriteInt(column_offset);
+  out.WriteBool(is_inlined);
+
+  // Column constraints
+  out.WriteLong(constraints.size());
+  for (auto constraint : constraints) {
+    constraint.SerializeTo(out);
+  }
+}
+
+// Deserialize this column
+Column Column::DeserializeFrom(SerializeInput &in) {
+  // read basic column information
+  std::string column_name = in.ReadTextString();
+  type::TypeId column_type = (type::TypeId)in.ReadInt();
+  size_t column_length = in.ReadInt();
+  oid_t column_offset = in.ReadInt();
+  bool is_inlined = in.ReadBool();
+
+  auto column = catalog::Column(column_type, column_length, column_name,
+                                is_inlined, column_offset);
+
+  // recover column constraints
+  size_t column_constraint_count = in.ReadLong();
+  for (oid_t constraint_idx = 0; constraint_idx < column_constraint_count;
+       constraint_idx++) {
+    auto column_constraint = Constraint::DeserializeFrom(in, column_type);
+    // Foreign key constraint will be stored by DataTable deserializer
+    if (column_constraint.GetType() != ConstraintType::FOREIGN) {
+      column.AddConstraint(column_constraint);
+    }
+  }
+
+  return column;
+}
+
 const std::string Column::GetInfo() const {
   std::ostringstream os;
 

src/catalog/constraint.cpp

@@ -17,6 +17,49 @@
 namespace peloton {
 namespace catalog {
 
+// Serialize this constraint
+void Constraint::SerializeTo(SerializeOutput &out) {
+  out.WriteTextString(constraint_name);
+  out.WriteInt((int)constraint_type);
+  out.WriteInt(fk_list_offset);
+  out.WriteInt(unique_index_list_offset);
+
+  if (constraint_type == ConstraintType::DEFAULT) {
+    default_value->SerializeTo(out);
+  }
+
+  if (constraint_type == ConstraintType::CHECK) {
+    out.WriteInt((int)exp.first);
+    exp.second.SerializeTo(out);
+  }
+}
+
+// Deserialize this constraint
+Constraint Constraint::DeserializeFrom(SerializeInput &in,
+                                       const type::TypeId column_type) {
+  std::string constraint_name = in.ReadTextString();
+  ConstraintType constraint_type = (ConstraintType)in.ReadInt();
+  oid_t foreign_key_list_offset = in.ReadInt();
+  oid_t unique_index_offset = in.ReadInt();
+
+  auto column_constraint = Constraint(constraint_type, constraint_name);
+  column_constraint.SetForeignKeyListOffset(foreign_key_list_offset);
+  column_constraint.SetUniqueIndexOffset(unique_index_offset);
+
+  if (constraint_type == ConstraintType::DEFAULT) {
+    type::Value default_value = type::Value::DeserializeFrom(in, column_type);
+    column_constraint.addDefaultValue(default_value);
+  }
+
+  if (constraint_type == ConstraintType::CHECK) {
+    auto exp = column_constraint.GetCheckExpression();
+    ExpressionType exp_type = (ExpressionType)in.ReadInt();
+    type::Value exp_value = type::Value::DeserializeFrom(in, column_type);
+    column_constraint.AddCheck(exp_type, exp_value);
+  }
+  return column_constraint;
+}
+
 const std::string Constraint::GetInfo() const {
   std::ostringstream os;
   os << "Constraint[" << GetName() << ", "
@@ -25,6 +68,9 @@ const std::string Constraint::GetInfo() const {
   if (GetType() == ConstraintType::CHECK) {
     os << ", " << exp.first << " " << exp.second.GetInfo();
   }
+  if (GetType() == ConstraintType::DEFAULT) {
+    os << ", " << default_value->GetInfo();
+  }
   os << "]";
   return os.str();
 }