make check passes. Need to add test with hybrid layout.

Author: poojanilangekar

src/gc/gc_manager.cpp

@@ -24,7 +24,7 @@ namespace gc {
 
 // Check a tuple and reclaim all varlen field
 void GCManager::CheckAndReclaimVarlenColumns(storage::TileGroup *tile_group, oid_t tuple_id) {
-    oid_t tile_count = tile_group->tile_count;
+    oid_t tile_count = tile_group->tile_count_;
     oid_t tile_col_count;
     type::TypeId type_id;
     char *tuple_location;

src/include/storage/tile_group.h

@@ -130,7 +130,7 @@ class TileGroup : public Printable {
 
   // Get the tile at given offset in the tile group
   inline Tile *GetTile(const oid_t tile_offset) const {
-    PELOTON_ASSERT(tile_offset < tile_count);
+    PELOTON_ASSERT(tile_offset < tile_count_);
     Tile *tile = tiles[tile_offset].get();
     return tile;
   }
@@ -152,7 +152,7 @@ class TileGroup : public Printable {
 
   void SetTileGroupId(oid_t tile_group_id_) { tile_group_id = tile_group_id_; }
 
-  size_t GetTileCount() const { return tile_count; }
+  size_t GetTileCount() const { return tile_count_; }
 
   type::Value GetValue(oid_t tuple_id, oid_t column_id);
 
@@ -189,7 +189,7 @@ class TileGroup : public Printable {
   oid_t num_tuple_slots;
 
   // number of tiles
-  oid_t tile_count;
+  oid_t tile_count_;
 
   std::mutex tile_group_mutex;
 

src/storage/abstract_table.cpp

@@ -30,7 +30,8 @@ AbstractTable::AbstractTable(oid_t table_oid, catalog::Schema *schema,
 
   // The default Layout should always be ROW or COLUMN
   PELOTON_ASSERT((layout_type == LayoutType::ROW) || (layout_type == LayoutType::COLUMN));
-  default_layout_ = std::make_shared<const Layout>(schema->GetColumnCount(), layout_type);
+  default_layout_ = std::shared_ptr<const Layout>(
+          new Layout(schema->GetColumnCount(), layout_type));
 }
 
 AbstractTable::~AbstractTable() {

src/storage/data_table.cpp

@@ -937,7 +937,8 @@ void DataTable::AddTileGroupWithOidForRecovery(const oid_t &tile_group_id) {
   if (default_layout_->IsRowStore()) {
     layout = default_layout_;
   } else {
-    layout = std::make_shared<const Layout>((schema->GetColumnCount());
+    layout = std::shared_ptr<const Layout>(
+            new const Layout(schema->GetColumnCount()));
   }
 
   std::shared_ptr<TileGroup> tile_group(TileGroupFactory::GetTileGroup(
@@ -1365,7 +1366,7 @@ void DataTable::ClearIndexSamples() {
 }
 
 void DataTable::SetDefaultLayout(const column_map_type &column_map) {
-  default_layout_ = std::make_shared<const Layout>(column_map);
+  default_layout_ = std::shared_ptr<const Layout>(new const Layout(column_map));
 }
 
 const Layout& DataTable::GetDefaultLayout() const {

src/storage/layout.cpp

@@ -160,16 +160,27 @@ std::vector<catalog::Schema> Layout::GetLayoutSchemas(
   // Build the schema tile at a time
   std::map<oid_t, std::vector<catalog::Column>> tile_schemas;
 
-  // This only works if the order of columns in the tile are the same
-  // as the schema. This snipet was initially in abstract_table.cpp.
-  for (auto column_info : column_layout_) {
-    tile_schemas[column_info.second.first].push_back(
-            schema->GetColumn(column_info.first));
-  }
+  // Handle schemas population based on the layout type
+  if (layout_type_ == LayoutType::ROW) {
+    schemas.push_back(*schema);
+  } else if (layout_type_ == LayoutType::COLUMN) {
+    for (oid_t col_id = 0; col_id < num_columns_; col_id++) {
+      std::vector<catalog::Column> tile_schema({schema->GetColumn(col_id)});
+      schemas.push_back(tile_schema);
+    }
+  } else {
+    // For LayoutType::HYBRID, use the old technique.
+    // This only works if the order of columns in the tile are the same
+    // as the schema. This snipet was initially in abstract_table.cpp.
+    for (auto column_info : column_layout_) {
+      tile_schemas[column_info.second.first].push_back(
+              schema->GetColumn(column_info.first));
+    }
 
-  for (auto entry : tile_schemas) {
-    catalog::Schema tile_schema(entry.second);
-    schemas.push_back(tile_schema);
+    for (auto entry : tile_schemas) {
+      catalog::Schema tile_schema(entry.second);
+      schemas.push_back(tile_schema);
+    }
   }
 
   return schemas;

src/storage/tile_group.cpp

@@ -41,8 +41,8 @@ TileGroup::TileGroup(BackendType backend_type,
       table(table),
       num_tuple_slots(tuple_count),
       tile_group_layout_(layout){
-  tile_count = schemas.size();
-  for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) {
+  tile_count_ = schemas.size();
+  for (oid_t tile_itr = 0; tile_itr < tile_count_; tile_itr++) {
     auto &manager = catalog::Manager::GetInstance();
     oid_t tile_id = manager.GetNextTileId();
 
@@ -107,7 +107,7 @@ void TileGroup::CopyTuple(const Tuple *tuple, const oid_t &tuple_slot_id) {
   oid_t tile_column_count;
   oid_t column_itr = 0;
 
-  for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) {
+  for (oid_t tile_itr = 0; tile_itr < tile_count_; tile_itr++) {
     storage::Tile *tile = GetTile(tile_itr);
     PELOTON_ASSERT(tile);
     const catalog::Schema *schema = tile->GetSchema();
@@ -188,7 +188,7 @@ oid_t TileGroup::InsertTupleFromRecovery(cid_t commit_id, oid_t tuple_slot_id,
   oid_t tile_column_count;
   oid_t column_itr = 0;
 
-  for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) {
+  for (oid_t tile_itr = 0; tile_itr < tile_count_; tile_itr++) {
     storage::Tile *tile = GetTile(tile_itr);
     PELOTON_ASSERT(tile);
     const catalog::Schema *schema = tile->GetSchema();
@@ -287,7 +287,7 @@ oid_t TileGroup::InsertTupleFromCheckpoint(oid_t tuple_slot_id,
   oid_t tile_column_count;
   oid_t column_itr = 0;
 
-  for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) {
+  for (oid_t tile_itr = 0; tile_itr < tile_count_; tile_itr++) {
 
     storage::Tile *tile = GetTile(tile_itr);
     PELOTON_ASSERT(tile);
@@ -336,7 +336,7 @@ void TileGroup::SetValue(type::Value &value, oid_t tuple_id,
 
 std::shared_ptr<Tile> TileGroup::GetTileReference(
     const oid_t tile_offset) const {
-  PELOTON_ASSERT(tile_offset < tile_count);
+  PELOTON_ASSERT(tile_offset < tile_count_);
   return tiles[tile_offset];
 }
 
@@ -360,7 +360,7 @@ const std::string TileGroup::GetInfo() const {
   os << "Table[" << table_id << "] " << std::endl;
   os << (*tile_group_header) << std::endl;
 
-  for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) {
+  for (oid_t tile_itr = 0; tile_itr < tile_count_; tile_itr++) {
     Tile *tile = GetTile(tile_itr);
     if (tile != nullptr) {
       os << std::endl << (*tile);

test/executor/seq_scan_test.cpp

@@ -101,13 +101,13 @@ storage::DataTable *CreateTable() {
       storage::TileGroupFactory::GetTileGroup(
           INVALID_OID, INVALID_OID,
           TestingHarness::GetInstance().GetNextTileGroupId(), table.get(),
-          schemas1, column_map1, tuple_count)));
+          schemas1, layout1, tuple_count)));
 
   table->AddTileGroup(std::shared_ptr<storage::TileGroup>(
       storage::TileGroupFactory::GetTileGroup(
           INVALID_OID, INVALID_OID,
           TestingHarness::GetInstance().GetNextTileGroupId(), table.get(),
-          schemas2, column_map2, tuple_count)));
+          schemas2, layout2, tuple_count)));
 
   TestingExecutorUtil::PopulateTiles(table->GetTileGroup(0), tuple_count);
   TestingExecutorUtil::PopulateTiles(table->GetTileGroup(1), tuple_count);

test/executor/testing_executor_util.cpp

@@ -29,6 +29,7 @@
 #include "index/index_factory.h"
 #include "storage/data_table.h"
 #include "storage/database.h"
+#include "storage/layout.h"
 #include "storage/table_factory.h"
 #include "storage/tile.h"
 #include "storage/tile_group.h"
@@ -171,7 +172,7 @@ std::shared_ptr<storage::TileGroup> TestingExecutorUtil::CreateTileGroup(
   column_map[3] = std::make_pair(1, 1);
 
   std::shared_ptr<const storage::Layout> layout =
-          std::make_shared<const storage::Layout>(column_map);
+          std::shared_ptr<const storage::Layout>(new const storage::Layout(column_map));
 
   std::shared_ptr<storage::TileGroup> tile_group_ptr(
       storage::TileGroupFactory::GetTileGroup(

test/executor/update_test.cpp

@@ -91,7 +91,8 @@ storage::DataTable *CreateTable() {
   column_map1[3] = std::make_pair(1, 1);
 
   std::shared_ptr<const storage::Layout> layout1 =
-          std::make_shared<const storage::Layout>(column_map1);
+          std::shared_ptr<const storage::Layout>(
+                  new const storage::Layout(column_map1));
 
   std::map<oid_t, std::pair<oid_t, oid_t>> column_map2;
   column_map2[0] = std::make_pair(0, 0);
@@ -100,7 +101,8 @@ storage::DataTable *CreateTable() {
   column_map2[3] = std::make_pair(1, 2);
 
   std::shared_ptr<const storage::Layout> layout2 =
-          std::make_shared<const storage::Layout>(column_map2);
+          std::shared_ptr<const storage::Layout>(
+                  new const storage::Layout(column_map1));
 
   // Create tile groups.
   table->AddTileGroup(std::shared_ptr<storage::TileGroup>(