DBMain and Settings Manager

CMakeLists.txt

@@ -354,8 +354,10 @@ if (CMAKE_COMPILER_IS_GNUCXX)
 endif()
 
 set(TERRIER_LINK_LIBS
+    gflags
     ${TERRIER_LINK_LIBS}
     ${PTHREAD_LIBRARY}
+    gflags
     pg_query)
 
 set(TERRIER_TEST_LINK_LIBS

apidoc/Doxyfile.in

@@ -831,7 +831,8 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                = ../src/include/parser/parsenodes.h
+EXCLUDE                = ../src/include/parser/parsenodes.h \
+                         ../src/include/settings/settings_defs.h
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded

benchmark/CMakeLists.txt

@@ -7,9 +7,10 @@ list(APPEND BENCHMARK_UTIL_SRCS ${BENCHMARK_UTIL_HDRS})
 ###############################################
 if (TERRIER_BUILD_BENCHMARKS)
     add_library(benchmark_util STATIC ${BENCHMARK_UTIL_SRCS})
-    target_link_libraries(benchmark_util benchmark)
+    target_link_libraries(benchmark_util benchmark pthread)
     add_dependencies(benchmark_util gtest)
 
+    add_subdirectory(catalog)
     add_subdirectory(storage)
     add_subdirectory(transaction)
 endif()

benchmark/catalog/CMakeLists.txt

@@ -0,0 +1 @@
+ADD_TERRIER_BENCHMARKS()

benchmark/catalog/catalog_benchmark.cpp

@@ -0,0 +1,63 @@
+#include <utility>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+#include "catalog/catalog.h"
+#include "catalog/catalog_defs.h"
+#include "common/scoped_timer.h"
+#include "transaction/transaction_manager.h"
+#include "util/transaction_benchmark_util.h"
+
+namespace terrier {
+
+class CatalogBenchmark : public benchmark::Fixture {
+ public:
+  void SetUp(const benchmark::State &state) final {
+    txn_manager_ = new transaction::TransactionManager(&buffer_pool_, true, LOGGING_DISABLED);
+
+    txn_ = txn_manager_->BeginTransaction();
+    catalog_ = new catalog::Catalog(txn_manager_, txn_);
+  }
+
+  void TearDown(const benchmark::State &state) final {
+    txn_manager_->Commit(txn_, TestCallbacks::EmptyCallback, nullptr);
+
+    delete catalog_;  // need to delete catalog_first
+    delete txn_manager_;
+    delete txn_;
+  }
+
+  // transaction manager
+  transaction::TransactionManager *txn_manager_;
+  storage::RecordBufferSegmentPool buffer_pool_{100, 100};
+
+  transaction::TransactionContext *txn_;
+
+  catalog::Catalog *catalog_;
+
+  const int num_lookups = 100000;
+};
+
+// NOLINTNEXTLINE
+BENCHMARK_DEFINE_F(CatalogBenchmark, DatabaseLookupTime)(benchmark::State &state) {
+  std::vector<type::TransientValue> search_vec, ret_row;
+  // setup search vector, lookup the default database
+  search_vec.push_back(type::TransientValueFactory::GetNull(type::TypeId::INTEGER));
+  search_vec.push_back(type::TransientValueFactory::GetVarChar("terrier"));
+
+  catalog::DatabaseHandle db_handle = catalog_->GetDatabaseHandle();
+
+  // NOLINTNEXTLINE
+  for (auto _ : state) {
+    for (int32_t iter = 0; iter < num_lookups; iter++) {
+      // TODO(pakhtar): replace with GetDatabaseEntry(from name);
+      // ret_row = db_handle.pg_database_rw_->FindRow(txn_, search_vec);
+      auto entry = db_handle.GetDatabaseEntry(txn_, "terrier");
+    }
+  }
+  state.SetItemsProcessed(state.iterations() * num_lookups);
+}
+
+BENCHMARK_REGISTER_F(CatalogBenchmark, DatabaseLookupTime)->Unit(benchmark::kMillisecond)->MinTime(2);
+
+}  // namespace terrier

benchmark/util/benchmark_main.cpp

@@ -18,6 +18,7 @@
 // Modified from the Apache Arrow project for the Terrier project.
 
 #include "benchmark/benchmark.h"
+#include "loggers/catalog_logger.h"
 #include "loggers/index_logger.h"
 #include "loggers/main_logger.h"
 #include "loggers/storage_logger.h"
@@ -29,6 +30,7 @@ int main(int argc, char **argv) {
   terrier::storage::init_index_logger();
   terrier::storage::init_storage_logger();
   terrier::transaction::init_transaction_logger();
+  terrier::catalog::init_catalog_logger();
 
   benchmark::Initialize(&argc, argv);
   benchmark::RunSpecifiedBenchmarks();

build-support/clang_format_exclusions.txt

@@ -1 +1,2 @@
 *third_party*
+*/include/settings/settings_defs.h

build-support/run-clang-tidy.py

@@ -362,4 +362,4 @@ def update_progress(current_file, num_files):
     sys.exit(return_code)
 
 if __name__ == '__main__':
-    main()
+    main()

src/catalog/attr_def_handle.cpp

@@ -0,0 +1,73 @@
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "catalog/attr_def_handle.h"
+#include "catalog/catalog.h"
+#include "catalog/catalog_defs.h"
+#include "storage/sql_table.h"
+#include "transaction/transaction_context.h"
+
+namespace terrier::catalog {
+
+const std::vector<SchemaCol> AttrDefHandle::schema_cols_ = {{0, true, "oid", type::TypeId::INTEGER},
+                                                            {1, true, "adrelid", type::TypeId::INTEGER},
+                                                            {2, true, "adnum", type::TypeId::INTEGER},
+                                                            {3, true, "adbin", type::TypeId::VARCHAR},
+                                                            {4, false, "adsrc", type::TypeId::VARCHAR}};
+
+// Find entry with (row) oid and return it
+std::shared_ptr<AttrDefEntry> AttrDefHandle::GetAttrDefEntry(transaction::TransactionContext *txn, col_oid_t oid) {
+  std::vector<type::TransientValue> search_vec, ret_row;
+  search_vec.push_back(type::TransientValueFactory::GetInteger(!oid));
+  ret_row = pg_attrdef_rw_->FindRow(txn, search_vec);
+  if (ret_row.empty()) {
+    return nullptr;
+  }
+  return std::make_shared<AttrDefEntry>(oid, pg_attrdef_rw_, std::move(ret_row));
+}
+
+void AttrDefHandle::DeleteEntries(transaction::TransactionContext *txn, table_oid_t table_oid) {
+  // auto layout = pg_attrdef_rw_->GetLayout();
+  int32_t col_index = pg_attrdef_rw_->ColNameToIndex("adrelid");
+
+  auto it = pg_attrdef_rw_->begin(txn);
+  while (it != pg_attrdef_rw_->end(txn)) {
+    // storage::ProjectedColumns::RowView row_view = it->InterpretAsRow(layout, 0);
+    storage::ProjectedColumns::RowView row_view = it->InterpretAsRow(0);
+    // check if a matching row, delete if it is
+    byte *col_p = row_view.AccessWithNullCheck(pg_attrdef_rw_->ColNumToOffset(col_index));
+    if (col_p == nullptr) {
+      continue;
+    }
+    auto col_int_value = *(reinterpret_cast<int32_t *>(col_p));
+    if (static_cast<uint32_t>(col_int_value) == !table_oid) {
+      // delete the entry
+      pg_attrdef_rw_->GetSqlTable()->Delete(txn, *(it->TupleSlots()));
+    }
+    ++it;
+  }
+}
+
+SqlTableHelper *AttrDefHandle::Create(transaction::TransactionContext *txn, Catalog *catalog, db_oid_t db_oid,
+                                      const std::string &name) {
+  catalog::SqlTableHelper *pg_attrdef;
+
+  // get an oid
+  table_oid_t pg_attrdef_oid(catalog->GetNextOid());
+
+  // uninitialized storage
+  pg_attrdef = new catalog::SqlTableHelper(pg_attrdef_oid);
+
+  for (auto col : AttrDefHandle::schema_cols_) {
+    pg_attrdef->DefineColumn(col.col_name, col.type_id, false, col_oid_t(catalog->GetNextOid()));
+  }
+
+  // now actually create, with the provided schema
+  pg_attrdef->Create();
+  catalog->AddToMaps(db_oid, pg_attrdef_oid, name, pg_attrdef);
+  return pg_attrdef;
+}
+
+}  // namespace terrier::catalog

src/catalog/attribute_handle.cpp

@@ -0,0 +1,97 @@
+#include "catalog/attribute_handle.h"
+#include <iostream>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "catalog/catalog.h"
+#include "catalog/schema.h"
+#include "common/exception.h"
+#include "loggers/catalog_logger.h"
+#include "storage/block_layout.h"
+#include "storage/sql_table.h"
+#include "storage/storage_defs.h"
+#include "type/type_id.h"
+
+namespace terrier::catalog {
+
+// note that this is not identical to Postgres's column sequence
+
+const std::vector<SchemaCol> AttributeHandle::schema_cols_ = {
+    {0, true, "oid", type::TypeId::INTEGER},     {1, true, "attrelid", type::TypeId::INTEGER},
+    {2, true, "attname", type::TypeId::VARCHAR}, {3, true, "atttypid", type::TypeId::INTEGER},
+    {4, true, "attlen", type::TypeId::INTEGER},  {5, true, "attnum", type::TypeId::INTEGER}};
+
+// TODO(pakhtar): add unused columns
+
+std::shared_ptr<AttributeEntry> AttributeHandle::GetAttributeEntry(transaction::TransactionContext *txn,
+                                                                   table_oid_t table_oid, col_oid_t col_oid) {
+  std::vector<type::TransientValue> search_vec, ret_row;
+  search_vec.push_back(type::TransientValueFactory::GetInteger(!col_oid));
+  search_vec.push_back(type::TransientValueFactory::GetInteger(!table_oid));
+  ret_row = pg_attribute_hrw_->FindRow(txn, search_vec);
+  if (ret_row.empty()) {
+    return nullptr;
+  }
+  col_oid_t oid(type::TransientValuePeeker::PeekInteger(ret_row[0]));
+  return std::make_shared<AttributeEntry>(oid, pg_attribute_hrw_, std::move(ret_row));
+}
+
+std::shared_ptr<AttributeEntry> AttributeHandle::GetAttributeEntry(transaction::TransactionContext *txn,
+                                                                   table_oid_t table_oid, const std::string &name) {
+  std::vector<type::TransientValue> search_vec, ret_row;
+  search_vec.push_back(type::TransientValueFactory::GetNull(type::TypeId::INTEGER));
+  search_vec.push_back(type::TransientValueFactory::GetInteger(!table_oid));
+  search_vec.push_back(type::TransientValueFactory::GetVarChar(name));
+  ret_row = pg_attribute_hrw_->FindRow(txn, search_vec);
+  if (ret_row.empty()) {
+    return nullptr;
+    // throw CATALOG_EXCEPTION("attribute doesn't exist");
+  }
+  col_oid_t oid(type::TransientValuePeeker::PeekInteger(ret_row[0]));
+  return std::make_shared<AttributeEntry>(oid, pg_attribute_hrw_, std::move(ret_row));
+}
+
+void AttributeHandle::DeleteEntries(transaction::TransactionContext *txn, table_oid_t table_oid) {
+  // auto layout = pg_attribute_hrw_->GetLayout();
+  int32_t col_index = pg_attribute_hrw_->ColNameToIndex("attrelid");
+
+  auto it = pg_attribute_hrw_->begin(txn);
+  while (it != pg_attribute_hrw_->end(txn)) {
+    // storage::ProjectedColumns::RowView row_view = it->InterpretAsRow(layout, 0);
+    storage::ProjectedColumns::RowView row_view = it->InterpretAsRow(0);
+    // check if a matching row, delete if it is
+    byte *col_p = row_view.AccessWithNullCheck(pg_attribute_hrw_->ColNumToOffset(col_index));
+    if (col_p == nullptr) {
+      continue;
+    }
+    auto col_int_value = *(reinterpret_cast<int32_t *>(col_p));
+    if (static_cast<uint32_t>(col_int_value) == !table_oid) {
+      // delete the entry
+      pg_attribute_hrw_->GetSqlTable()->Delete(txn, *(it->TupleSlots()));
+    }
+    ++it;
+  }
+}
+
+SqlTableHelper *AttributeHandle::Create(transaction::TransactionContext *txn, Catalog *catalog, db_oid_t db_oid,
+                                        const std::string &name) {
+  catalog::SqlTableHelper *pg_attr;
+
+  // get an oid
+  table_oid_t pg_attr_oid(catalog->GetNextOid());
+
+  // uninitialized storage
+  pg_attr = new catalog::SqlTableHelper(pg_attr_oid);
+
+  for (auto col : AttributeHandle::schema_cols_) {
+    pg_attr->DefineColumn(col.col_name, col.type_id, false, col_oid_t(catalog->GetNextOid()));
+  }
+
+  // now actually create, with the provided schema
+  pg_attr->Create();
+  catalog->AddToMaps(db_oid, pg_attr_oid, name, pg_attr);
+  return pg_attr;
+}
+
+}  // namespace terrier::catalog