Style Fix

Author: poojanilangekar

src/catalog/catalog.cpp

@@ -182,8 +182,8 @@ void Catalog::BootstrapSystemCatalogs(storage::Database *database,
       COLUMN_CATALOG_OID, COLUMN_CATALOG_NAME, CATALOG_SCHEMA_NAME,
       database_oid, pool_.get(), txn);
   system_catalogs->GetTableCatalog()->InsertTable(
-          LAYOUT_CATALOG_OID, LAYOUT_CATALOG_NAME, CATALOG_SCHEMA_NAME,
-          database_oid, pool_.get(), txn);
+      LAYOUT_CATALOG_OID, LAYOUT_CATALOG_NAME, CATALOG_SCHEMA_NAME,
+      database_oid, pool_.get(), txn);
 }
 
 void Catalog::Bootstrap() {
@@ -570,11 +570,9 @@ ResultType Catalog::CreateIndex(
  * @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) {
-
+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);
@@ -583,13 +581,12 @@ Catalog::CreateLayout(oid_t database_oid, oid_t table_oid,
   // 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));
+      new const storage::Layout(column_map, layout_oid));
 
   // Add the layout the pg_layout table
-  auto pg_layout =
-          catalog_map_[database_oid]->GetLayoutCatalog();
-  bool result = pg_layout->InsertLayout(table_oid, new_layout,
-                                             pool_.get(), txn);
+  auto pg_layout = catalog_map_[database_oid]->GetLayoutCatalog();
+  bool result =
+      pg_layout->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;
@@ -607,10 +604,9 @@ Catalog::CreateLayout(oid_t database_oid, oid_t table_oid,
  * @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) {
+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) {
@@ -787,7 +783,7 @@ ResultType Catalog::DropTable(oid_t database_oid, oid_t table_oid,
 
   // delete record in pg_layout
   auto pg_layout =
-          catalog_map_[database_object->GetDatabaseOid()]->GetLayoutCatalog();
+      catalog_map_[database_object->GetDatabaseOid()]->GetLayoutCatalog();
   pg_layout->DeleteLayouts(table_oid, txn);
 
   // delete record in pg_table
@@ -834,7 +830,6 @@ ResultType Catalog::DropIndex(oid_t database_oid, oid_t index_oid,
   return ResultType::SUCCESS;
 }
 
-
 /*@brief   Drop layout
  * tile_groups
  * @param   database_oid    the database to which the table belongs
@@ -860,8 +855,7 @@ ResultType Catalog::DropLayout(oid_t database_oid, oid_t table_oid,
   auto pg_layout = catalog_map_[database_oid]->GetLayoutCatalog();
   if (!pg_layout->DeleteLayout(table_oid, layout_oid, txn)) {
     auto layout = table->GetDefaultLayout();
-    LOG_DEBUG("Layout delete failed. Default layout id: %u",
-              layout.GetOid());
+    LOG_DEBUG("Layout delete failed. Default layout id: %u", layout.GetOid());
     return ResultType::FAILURE;
   }
 

src/catalog/layout_catalog.cpp

@@ -26,15 +26,13 @@ namespace catalog {
  *  @param   pg_catalog  The database to which this pg_layout belongs.
  */
 LayoutCatalog::LayoutCatalog(
-        storage::Database *pg_catalog,
-        UNUSED_ATTRIBUTE type::AbstractPool *pool,
-        UNUSED_ATTRIBUTE concurrency::TransactionContext *txn)
-        : AbstractCatalog(LAYOUT_CATALOG_OID, LAYOUT_CATALOG_NAME,
-                          InitializeSchema().release(), pg_catalog) {
+    storage::Database *pg_catalog, UNUSED_ATTRIBUTE type::AbstractPool *pool,
+    UNUSED_ATTRIBUTE concurrency::TransactionContext *txn)
+    : AbstractCatalog(LAYOUT_CATALOG_OID, LAYOUT_CATALOG_NAME,
+                      InitializeSchema().release(), pg_catalog) {
   // Add indexes for pg_attribute
-  AddIndex({ColumnId::TABLE_OID, ColumnId::LAYOUT_OID},
-           LAYOUT_CATALOG_PKEY_OID, LAYOUT_CATALOG_NAME "_pkey",
-           IndexConstraintType::PRIMARY_KEY);
+  AddIndex({ColumnId::TABLE_OID, ColumnId::LAYOUT_OID}, LAYOUT_CATALOG_PKEY_OID,
+           LAYOUT_CATALOG_NAME "_pkey", IndexConstraintType::PRIMARY_KEY);
   AddIndex({ColumnId::TABLE_OID}, LAYOUT_CATALOG_SKEY0_OID,
            LAYOUT_CATALOG_NAME "_skey0", IndexConstraintType::DEFAULT);
 }
@@ -49,35 +47,36 @@ std::unique_ptr<catalog::Schema> LayoutCatalog::InitializeSchema() {
   const std::string not_null_constraint_name = "not_null";
 
   auto table_id_column = catalog::Column(
-          type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
-          "table_oid", true);
+      type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
+      "table_oid", true);
   table_id_column.AddConstraint(catalog::Constraint(
-          ConstraintType::PRIMARY, primary_key_constraint_name));
+      ConstraintType::PRIMARY, primary_key_constraint_name));
   table_id_column.AddConstraint(
-          catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
+      catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
 
   auto layout_oid_column = catalog::Column(
-          type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
-          "layout_oid", true);
+      type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
+      "layout_oid", true);
   layout_oid_column.AddConstraint(catalog::Constraint(
-          ConstraintType::PRIMARY, primary_key_constraint_name));
+      ConstraintType::PRIMARY, primary_key_constraint_name));
   layout_oid_column.AddConstraint(
-          catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
+      catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
 
   auto num_columns_column = catalog::Column(
-          type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
-          "num_columns", true);
+      type::TypeId::INTEGER, type::Type::GetTypeSize(type::TypeId::INTEGER),
+      "num_columns", true);
   num_columns_column.AddConstraint(
-          catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
+      catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
 
   auto column_map_column = catalog::Column(
-          type::TypeId::VARCHAR, type::Type::GetTypeSize(type::TypeId::VARCHAR),
-          "column_map", false);
+      type::TypeId::VARCHAR, type::Type::GetTypeSize(type::TypeId::VARCHAR),
+      "column_map", false);
   column_map_column.AddConstraint(
-          catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
+      catalog::Constraint(ConstraintType::NOTNULL, not_null_constraint_name));
 
-  std::unique_ptr<catalog::Schema> column_catalog_schema(new catalog::Schema(
-          {table_id_column, layout_oid_column, num_columns_column, column_map_column}));
+  std::unique_ptr<catalog::Schema> column_catalog_schema(
+      new catalog::Schema({table_id_column, layout_oid_column,
+                           num_columns_column, column_map_column}));
 
   return column_catalog_schema;
 }
@@ -95,7 +94,7 @@ bool LayoutCatalog::InsertLayout(oid_t table_oid,
                                  concurrency::TransactionContext *txn) {
   // Create the tuple first
   std::unique_ptr<storage::Tuple> tuple(
-          new storage::Tuple(catalog_table_->GetSchema(), true));
+      new storage::Tuple(catalog_table_->GetSchema(), true));
 
   auto val0 = type::ValueFactory::GetIntegerValue(table_oid);
   auto val1 = type::ValueFactory::GetIntegerValue(layout->GetOid());
@@ -120,16 +119,15 @@ bool LayoutCatalog::InsertLayout(oid_t table_oid,
  */
 bool LayoutCatalog::DeleteLayout(oid_t table_oid, oid_t layout_oid,
                                  concurrency::TransactionContext *txn) {
-  oid_t index_offset =
-          IndexId::PRIMARY_KEY;  // Index of table_oid & layout_oid
+  oid_t index_offset = IndexId::PRIMARY_KEY;  // Index of table_oid & layout_oid
 
   std::vector<type::Value> values;
   values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy());
   values.push_back(type::ValueFactory::GetIntegerValue(layout_oid).Copy());
 
   auto pg_table = Catalog::GetInstance()
-          ->GetSystemCatalogs(database_oid)
-          ->GetTableCatalog();
+                      ->GetSystemCatalogs(database_oid)
+                      ->GetTableCatalog();
 
   // delete column from cache
   auto table_object = pg_table->GetTableObject(table_oid, txn);
@@ -151,8 +149,8 @@ bool LayoutCatalog::DeleteLayouts(oid_t table_oid,
 
   // delete layouts from cache
   auto pg_table = Catalog::GetInstance()
-          ->GetSystemCatalogs(database_oid)
-          ->GetTableCatalog();
+                      ->GetSystemCatalogs(database_oid)
+                      ->GetTableCatalog();
   auto table_object = pg_table->GetTableObject(table_oid, txn);
   table_object->EvictAllLayouts();
 
@@ -169,8 +167,8 @@ LayoutCatalog::GetLayouts(oid_t table_oid,
                           concurrency::TransactionContext *txn) {
   // Try to find the layouts in the cache
   auto pg_table = Catalog::GetInstance()
-          ->GetSystemCatalogs(database_oid)
-          ->GetTableCatalog();
+                      ->GetSystemCatalogs(database_oid)
+                      ->GetTableCatalog();
   auto table_object = pg_table->GetTableObject(table_oid, txn);
   PELOTON_ASSERT(table_object && table_object->GetTableOid() == table_oid);
   auto layout_objects = table_object->GetLayouts(true);
@@ -185,23 +183,23 @@ LayoutCatalog::GetLayouts(oid_t table_oid,
   values.push_back(type::ValueFactory::GetIntegerValue(table_oid).Copy());
 
   auto result_tiles =
-          GetResultWithIndexScan(column_ids, index_offset, values, txn);
+      GetResultWithIndexScan(column_ids, index_offset, values, txn);
 
-  for (auto &tile : (*result_tiles)) { // Iterate through the result_tiles
+  for (auto &tile : (*result_tiles)) {  // Iterate through the result_tiles
     for (auto tuple_id : *tile) {
       oid_t layout_oid =
-              tile->GetValue(tuple_id, LayoutCatalog::ColumnId::LAYOUT_OID)
-                      .GetAs<oid_t>();
+          tile->GetValue(tuple_id, LayoutCatalog::ColumnId::LAYOUT_OID)
+              .GetAs<oid_t>();
       oid_t num_columns =
-              tile->GetValue(tuple_id, LayoutCatalog::ColumnId::NUM_COLUMNS)
-                      .GetAs<oid_t>();
+          tile->GetValue(tuple_id, LayoutCatalog::ColumnId::NUM_COLUMNS)
+              .GetAs<oid_t>();
       std::string column_map_str =
-              tile->GetValue(tuple_id, LayoutCatalog::ColumnId::COLUMN_MAP)
-                      .ToString();
-      auto column_map = storage::Layout::DeserializeColumnMap(num_columns,
-                                                              column_map_str);
+          tile->GetValue(tuple_id, LayoutCatalog::ColumnId::COLUMN_MAP)
+              .ToString();
+      auto column_map =
+          storage::Layout::DeserializeColumnMap(num_columns, column_map_str);
       auto layout_object =
-              std::make_shared<const storage::Layout>(column_map, layout_oid);
+          std::make_shared<const storage::Layout>(column_map, layout_oid);
       table_object->InsertLayout(layout_object);
     }
   }
@@ -216,9 +214,8 @@ LayoutCatalog::GetLayouts(oid_t table_oid,
  *  @return     shared_ptr corresponding to the layout_oid if found.
  *              nullptr otherwise.
  */
-std::shared_ptr<const storage::Layout>
-LayoutCatalog::GetLayoutWithOid(oid_t table_oid, oid_t layout_oid,
-                 concurrency::TransactionContext *txn) {
+std::shared_ptr<const storage::Layout> LayoutCatalog::GetLayoutWithOid(
+    oid_t table_oid, oid_t layout_oid, concurrency::TransactionContext *txn) {
   auto table_layouts = GetLayouts(table_oid, txn);
   for (const auto &layout_entry : table_layouts) {
     if (layout_entry.second->GetOid() == layout_oid) {

src/catalog/schema.cpp

@@ -211,7 +211,8 @@ Schema *Schema::AppendSchema(const Schema *first, const Schema *second) {
 
 // Append subset of columns in the two given schemas
 Schema *Schema::AppendSchema(const Schema *first, std::vector<oid_t> &first_set,
-                             const Schema *second, std::vector<oid_t> &second_set) {
+                             const Schema *second,
+                             std::vector<oid_t> &second_set) {
   const std::vector<const Schema *> schema_list({first, second});
   const std::vector<std::vector<oid_t>> subsets({first_set, second_set});
   return AppendSchemaPtrList(schema_list, subsets);
@@ -229,7 +230,8 @@ Schema *Schema::AppendSchemaList(std::vector<Schema> &schema_list) {
 }
 
 // Append given schemas.
-Schema *Schema::AppendSchemaPtrList(const std::vector<const Schema *> &schema_list) {
+Schema *Schema::AppendSchemaPtrList(
+    const std::vector<const Schema *> &schema_list) {
   std::vector<std::vector<oid_t>> subsets;
 
   for (unsigned int i = 0; i < schema_list.size(); i++) {

src/catalog/table_catalog.cpp

@@ -320,8 +320,8 @@ std::shared_ptr<ColumnCatalogObject> TableCatalogObject::GetColumnObject(
 TableCatalog::TableCatalog(
     storage::Database *database, UNUSED_ATTRIBUTE type::AbstractPool *pool,
     UNUSED_ATTRIBUTE concurrency::TransactionContext *txn)
-        : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME,
-                          InitializeSchema().release(), database) {
+    : AbstractCatalog(TABLE_CATALOG_OID, TABLE_CATALOG_NAME,
+                      InitializeSchema().release(), database) {
   // Add indexes for pg_namespace
   AddIndex({0}, TABLE_CATALOG_PKEY_OID, TABLE_CATALOG_NAME "_pkey",
            IndexConstraintType::PRIMARY_KEY);
@@ -335,14 +335,14 @@ TableCatalog::TableCatalog(
  *  @param   layout  Layout object to be inserted
  *  @return  false if layout already exists in cache
  */
-bool TableCatalogObject::InsertLayout(std::shared_ptr<const storage::Layout> layout) {
-
+bool TableCatalogObject::InsertLayout(
+    std::shared_ptr<const storage::Layout> layout) {
   // Invalid object
   if (layout == nullptr) {
     return false;
   }
 
-  oid_t  layout_id = layout->GetOid();
+  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);
@@ -370,8 +370,8 @@ TableCatalogObject::GetLayouts(bool cached_only) {
   if (!valid_layout_objects_ && !cached_only) {
     // get layout catalog objects from pg_layout
     auto pg_layout = Catalog::GetInstance()
-            ->GetSystemCatalogs(database_oid)
-            ->GetLayoutCatalog();
+                         ->GetSystemCatalogs(database_oid)
+                         ->GetLayoutCatalog();
     pg_layout->GetLayouts(table_oid, txn);
     valid_column_objects = true;
   }
@@ -383,8 +383,8 @@ TableCatalogObject::GetLayouts(bool cached_only) {
  *  @param   cached_only If set to true, don't fetch the layout objects.
  *  @return  Layout object of corresponding to the layout_id if present.
  */
-std::shared_ptr<const storage::Layout>
-TableCatalogObject::GetLayout(oid_t layout_id, bool cached_entry) {
+std::shared_ptr<const storage::Layout> TableCatalogObject::GetLayout(
+    oid_t layout_id, bool cached_entry) {
   // fetch layout objects in case we have not
   GetLayouts(cached_entry);
   auto it = layout_objects_.find(layout_id);

src/codegen/proxy/runtime_functions_proxy.cpp

@@ -24,8 +24,7 @@ DEFINE_TYPE(ColumnLayoutInfo, "peloton::ColumnLayoutInfo",
 DEFINE_TYPE(AbstractExpression, "peloton::expression::AbstractExpression",
             MEMBER(opaque));
 
-DEFINE_TYPE(Schema, "peloton::catalog::Schema",
-			MEMBER(opaque));
+DEFINE_TYPE(Schema, "peloton::catalog::Schema", MEMBER(opaque));
 
 DEFINE_METHOD(peloton::codegen, RuntimeFunctions, HashCrc64);
 DEFINE_METHOD(peloton::codegen, RuntimeFunctions, GetTileGroup);

src/codegen/runtime_functions.cpp

@@ -20,8 +20,8 @@
 #include "expression/expression_util.h"
 #include "storage/data_table.h"
 #include "storage/layout.h"
-#include "storage/tile_group.h"
 #include "storage/tile.h"
+#include "storage/tile_group.h"
 #include "storage/zone_map_manager.h"
 #include "type/value_factory.h"
 
@@ -102,10 +102,10 @@ void RuntimeFunctions::FillPredicateArray(
 // to skip over to find successive values of the column.
 //===----------------------------------------------------------------------===//
 void RuntimeFunctions::GetTileGroupLayout(const storage::TileGroup *tile_group,
-                                          const catalog::Schema *schema, 
+                                          const catalog::Schema *schema,
                                           ColumnLayoutInfo *infos,
                                           uint32_t num_cols) {
-  const auto& layout = tile_group->GetLayout();
+  const auto &layout = tile_group->GetLayout();
   // For LayoutType::ROW, the tile group contains a single tile
   // and all the columns are in the same order as the table schema.
   if (layout.IsRowStore()) {

src/codegen/tile_group.cpp

@@ -88,17 +88,15 @@ llvm::Value *TileGroup::GetTileGroupId(CodeGen &codegen,
 std::vector<TileGroup::ColumnLayout> TileGroup::GetColumnLayouts(
     CodeGen &codegen, llvm::Value *tile_group_ptr,
     llvm::Value *column_layout_infos) const {
-
-  llvm::Value *schema_ptr = codegen->CreateIntToPtr(
-          codegen.Const64((int64_t)&schema_),
-          SchemaProxy::GetType(codegen)->getPointerTo());
+  llvm::Value *schema_ptr =
+      codegen->CreateIntToPtr(codegen.Const64((int64_t)&schema_),
+                              SchemaProxy::GetType(codegen)->getPointerTo());
 
   // Call RuntimeFunctions::GetTileGroupLayout()
   uint32_t num_cols = schema_.GetColumnCount();
-  codegen.Call(
-      RuntimeFunctionsProxy::GetTileGroupLayout,
-      {tile_group_ptr, schema_ptr, column_layout_infos,
-       codegen.Const32(num_cols)});
+  codegen.Call(RuntimeFunctionsProxy::GetTileGroupLayout,
+               {tile_group_ptr, schema_ptr, column_layout_infos,
+                codegen.Const32(num_cols)});
 
   // Collect <start, stride, is_columnar> triplets of all columns
   std::vector<TileGroup::ColumnLayout> layouts;

src/codegen/updater.cpp

@@ -45,7 +45,7 @@ char *Updater::GetDataPtr(uint32_t tile_group_id, uint32_t tuple_offset) {
   auto tile_group = table_->GetTileGroupById(tile_group_id);
 
   // Get the tile offset assuming that it is still a row store
-  // Hence the Tile offset is 0. 
+  // Hence the Tile offset is 0.
   auto layout = tile_group->GetLayout();
   PELOTON_ASSERT(layout.IsRowStore());
   tile_ = tile_group->GetTileReference(0);