Remove Store main tables in favor of a single main table

src/bin/units_access/MergeTableTests.cpp

@@ -13,7 +13,7 @@ TEST_F(MergeTableTests, basic_merge_table_test) {
   auto s = Loader::shortcuts::loadMainDelta("test/merge1_main.tbl", "test/merge1_delta.tbl");
   auto reference = Loader::shortcuts::load("test/merge1_result.tbl");
 
-  ASSERT_EQ(4u, s->getMainTables()[0]->size());
+  ASSERT_EQ(4u, s->getMainTable()->size());
   ASSERT_EQ(5u, s->getDeltaTable()->size());
 
   MergeTable mt;

src/bin/units_io/shortcut_tests.cpp

@@ -14,7 +14,7 @@ TEST_F(LoaderShortcutTests, loadMainDelta) {
       "test/reference/update_scan_insert_only_after_update_main.tbl",
       "test/reference/update_scan_insert_only_after_update_delta.tbl"
                                             );
-  ASSERT_EQ(3u, s->getMainTables()[0]->size());
+  ASSERT_EQ(3u, s->getMainTable()->size());
   ASSERT_EQ(1u, s->getDeltaTable()->size());
 }
 

src/bin/units_storage/merge_tests.cpp

@@ -234,7 +234,7 @@ TEST_F(MergeTests, DISABLED_parallel_heap_merger_delta_test) {
 TEST_F(MergeTests, simple_logarithmic_merger_test) {
   auto m = Loader::shortcuts::loadMainDelta("test/merge1_main.tbl", "test/merge1_delta.tbl");
   std::vector<hyrise::storage::c_atable_ptr_t > tables;
-  tables.push_back(m->getMainTables()[0]);
+  tables.push_back(m->getMainTable());
   tables.push_back(m->getDeltaTable());
   TableMerger merger(new DefaultMergeStrategy(), new SequentialHeapMerger());
   const auto& result = merger.merge(tables);
@@ -250,7 +250,7 @@ TEST_F(MergeTests, simple_logarithmic_merger_test) {
 TEST_F(MergeTests, DISABLED_parallel_value_merger_test) {
   auto m = Loader::shortcuts::loadMainDelta("test/merge1_main.tbl", "test/merge1_delta.tbl", Loader::params().setCompressed(false));
   std::vector<hyrise::storage::c_atable_ptr_t > tables;
-  tables.push_back(m->getMainTables()[0]);
+  tables.push_back(m->getMainTable());
   tables.push_back(m->getDeltaTable());
 
   TableMerger merger(new DefaultMergeStrategy(), new SequentialHeapMerger());
@@ -335,15 +335,15 @@ TEST_F(MergeTests, store_merge_compex) {
   TableMerger merger(new DefaultMergeStrategy(), new SequentialHeapMerger());
 
   std::vector<hyrise::storage::c_atable_ptr_t> tables;
-  tables.push_back(linxxxs->getMainTables()[0]);
+  tables.push_back(linxxxs->getMainTable());
   tables.push_back(linxxxs->getDeltaTable());
 
   // Valid Vector
   std::vector<bool> valid = {0,1,1,1,0,1,1};
   auto result = merger.merge(tables, true, valid);
   ASSERT_EQ(5u, result[0]->size());
 
-  EXPECT_RELATION_EQ(ref, result[0]); 
+  EXPECT_RELATION_EQ(ref, result[0]);
 }
 
 

src/lib/access/LayoutTable.cpp

@@ -25,14 +25,12 @@ void LayoutTable::executePlanOperation() {
   if (store == nullptr)
     throw std::runtime_error("Input is not a store");
 
-  auto main = store->getMainTables()[0];
+  auto main = store->getMainTable();
   auto dest = createEmptyLayoutedTable(_layout);
 
   // Add all table to the game
-  std::vector<storage::c_atable_ptr_t> tables;
-  tables.push_back(main);
-  tables.push_back(store->getDeltaTable());
-
+  std::vector<storage::c_atable_ptr_t> tables { main, store->getDeltaTable() };
+
   // Call the Merge
   TableMerger merger(new DefaultMergeStrategy(), new SequentialHeapMerger());
 

src/lib/access/MergeTable.cpp

@@ -21,8 +21,7 @@ void MergeTable::executePlanOperation() {
   // Add all tables to the game
   for (auto& table: input.getTables()) {
     if (auto store = std::dynamic_pointer_cast<const storage::Store>(table)) {
-      auto mains = store->getMainTables();
-      tables.insert(tables.end(), mains.begin(), mains.end());
+      tables.push_back(store->getMainTable());
       tables.push_back(store->getDeltaTable());
     } else {
       tables.push_back(table);

src/lib/io/Loader.cpp

@@ -139,7 +139,7 @@ std::shared_ptr<AbstractTable> Loader::load(const params &args) {
   }
 
   if (!args.getModifiableMutableVerticalTable() && args.getReturnsMutableVerticalTable()) {
-    table = std::dynamic_pointer_cast<storage::Store>(result)->getMainTables()[0];
+    table = std::dynamic_pointer_cast<storage::Store>(result)->getMainTable();
     result = table;
   }
 

src/lib/io/TableDump.cpp

@@ -197,7 +197,7 @@ void SimpleTableDump::verify(std::shared_ptr<AbstractTable> table) {
 
 bool SimpleTableDump::dump(std::string name, std::shared_ptr<AbstractTable> table) {
   verify(table);
-  auto mainTable = std::dynamic_pointer_cast<Store>(table)->getMainTables()[0];
+  auto mainTable = std::dynamic_pointer_cast<Store>(table)->getMainTable();
   prepare(name);
   for(size_t i=0; i < mainTable->columnCount(); ++i) {
     // For each attribute dump dictionary and values

src/lib/storage/Store.cpp

@@ -23,14 +23,13 @@ Store::Store() :
 }
 
 Store::Store(atable_ptr_t main_table) :
-  delta(main_table->copy_structure_modifiable()),
-  merger(createDefaultMerger()),
-  _cidBeginVector(main_table->size(), 0),
-  _cidEndVector(main_table->size(), tx::INF_CID),
-  _tidVector(main_table->size(), tx::UNKNOWN) {
-
+    _main_table(main_table),
+    delta(main_table->copy_structure_modifiable()),
+    merger(createDefaultMerger()),
+    _cidBeginVector(main_table->size(), 0),
+    _cidEndVector(main_table->size(), tx::INF_CID),
+    _tidVector(main_table->size(), tx::UNKNOWN) {
   setUuid();
-  main_tables.push_back(main_table);
 }
 
 Store::~Store() {
@@ -46,8 +45,7 @@ void Store::merge() {
   atable_ptr_t new_delta = delta->copy_structure_modifiable();
 
   // Prepare the merge
-  std::vector<c_atable_ptr_t> tmp(main_tables.begin(), main_tables.end());
-  tmp.push_back(delta);
+  std::vector<c_atable_ptr_t> tmp {_main_table, delta};
 
   // get valid positions
   std::vector<bool> validPositions(_cidBeginVector.size());
@@ -56,109 +54,65 @@ void Store::merge() {
     validPositions[i] = isVisibleForTransaction(i, last_commit_id, tx::MERGE_TID);
   });
 
-  main_tables = merger->merge(tmp, true, validPositions);
-
+  auto tables = merger->merge(tmp, true, validPositions);
+  assert(tables.size() == 1);
+  _main_table = tables.front();
   // Fixup the cid and tid vectors
-  _cidBeginVector = std::vector<tx::transaction_cid_t>(main_tables[0]->size(), tx::UNKNOWN_CID);
-  _cidEndVector = std::vector<tx::transaction_cid_t>(main_tables[0]->size(), tx::INF_CID);
-  _tidVector = std::vector<tx::transaction_id_t>(main_tables[0]->size(), tx::START_TID);
+  _cidBeginVector = std::vector<tx::transaction_cid_t>(_main_table->size(), tx::UNKNOWN_CID);
+  _cidEndVector = std::vector<tx::transaction_cid_t>(_main_table->size(), tx::INF_CID);
+  _tidVector = std::vector<tx::transaction_id_t>(_main_table->size(), tx::START_TID);
 
   // Replace the delta partition
   delta = new_delta;
 }
 
 
-std::vector< atable_ptr_t > Store::getMainTables() const {
-  return main_tables;
+atable_ptr_t Store::getMainTable() const {
+  return _main_table;
 }
 
 atable_ptr_t Store::getDeltaTable() const {
   return delta;
 }
 
 const ColumnMetadata *Store::metadataAt(const size_t column_index, const size_t row_index, const table_id_t table_id) const {
-  size_t offset = 0;
-
-  for (size_t main = 0; main < main_tables.size(); main++)
-    if (main_tables[main]->size() + offset > row_index) {
-      return main_tables[main]->metadataAt(column_index, row_index - offset, table_id);
-    } else {
-      offset += main_tables[main]->size();
-    }
-
-  // row is not in main tables. return metadata from delta
+  size_t offset = _main_table->size();
+  if (row_index < offset) {
+    return _main_table->metadataAt(column_index, row_index, table_id);
+  }
   return delta->metadataAt(column_index, row_index - offset, table_id);
 }
 
 void Store::setDictionaryAt(AbstractTable::SharedDictionaryPtr dict, const size_t column, const size_t row, const table_id_t table_id) {
-  size_t offset = 0;
-
-  for (size_t main = 0; main < main_tables.size(); main++)
-    if (main_tables[main]->size() + offset > row) {
-      main_tables[main]->setDictionaryAt(dict, column, row - offset, table_id);
-      return;
-    } else {
-      offset += main_tables[main]->size();
-    }
-
-  // row is not in main tables. set dict in delta
+  size_t offset = _main_table->size();
+  if (row < offset) {
+    _main_table->setDictionaryAt(dict, column, row, table_id);
+  }
   delta->setDictionaryAt(dict, column, row - offset, table_id);
 }
 
 const AbstractTable::SharedDictionaryPtr& Store::dictionaryAt(const size_t column, const size_t row, const table_id_t table_id) const {
-  // if (!row) {
-  //   return this->dictionaryByTableId(column, table_id);
-  // }
-
-  // if (table_id) {
-  //   if (table_id < main_tables.size()) {
-  //     return main_tables[table_id]->dictionaryAt(column, row);
-  //   } else {
-  //     return delta->dictionaryAt(column, row);
-  //   }
-  // }
-
-  size_t offset = 0;
-
-  for (size_t main = 0; main < main_tables.size(); main++)
-    if (main_tables[main]->size() + offset > row) {
-      return main_tables[main]->dictionaryAt(column, row - offset);
-    } else {
-      offset += main_tables[main]->size();
-    }
-
-  // row is not in main tables. return row from delta
+  size_t offset = _main_table->size();
+  if (row < offset) {
+    return _main_table->dictionaryAt(column, row);
+  }
   return delta->dictionaryAt(column, row - offset);
 }
 
 const AbstractTable::SharedDictionaryPtr& Store::dictionaryByTableId(const size_t column, const table_id_t table_id) const {
-  assert(table_id <= main_tables.size());
-
-  if (table_id < main_tables.size()) {
-    return main_tables[table_id]->dictionaryByTableId(column, table_id);
-  } else {
+  if (table_id == 0)
+    return _main_table->dictionaryByTableId(column, table_id);
+  else
     return delta->dictionaryByTableId(column, table_id);
-  }
 }
 
 inline Store::table_offset_idx_t Store::responsibleTable(const size_t row) const {
-  size_t offset = 0;
-  size_t tableIdx = 0;
-
-  for (const auto& table: main_tables) {
-    size_t sz = table->size();
-    if ((sz + offset) > row) {
-      return {table, row - offset, tableIdx};
-    } else {
-      offset += sz;
-    }
-    ++tableIdx;
+  size_t offset = _main_table->size();
+  if (row < offset) {
+    return {_main_table, row, 0};
   }
-
-  if ((delta->size() + offset) > row) {
-    return {delta, row - offset, tableIdx};
-  }
-  throw std::out_of_range("Requested row is located beyond store boundaries");
+  assert( row - offset < delta->size() );
+  return {delta, row - offset, 1};
 }
 
 void Store::setValueId(const size_t column, const size_t row, ValueId vid) {
@@ -175,26 +129,25 @@ ValueId Store::getValueId(const size_t column, const size_t row) const {
 
 
 size_t Store::size() const {
-  size_t main_tables_size = functional::foldLeft(main_tables, 0ul,
-    [](size_t s, const atable_ptr_t& t){return s + t->size();});
-  return main_tables_size + delta->size();
+  return _main_table->size() + delta->size();
 }
 
 size_t Store::deltaOffset() const {
-  return size() - delta->size();
+  return _main_table->size();
 }
 
 size_t Store::columnCount() const {
   return delta->columnCount();
 }
 
 unsigned Store::partitionCount() const {
-  return main_tables[0]->partitionCount();
+  return _main_table->partitionCount();
 }
 
 size_t Store::partitionWidth(const size_t slice) const {
   // TODO we now require that all main tables have the same layout
-  return main_tables[0]->partitionWidth(slice);
+  //return main_tables[0]->partitionWidth(slice);
+  return  _main_table->partitionWidth(slice);
 }
 
 
@@ -214,10 +167,7 @@ void Store::setDelta(atable_ptr_t _delta) {
 atable_ptr_t Store::copy() const {
   std::shared_ptr<Store> new_store = std::make_shared<Store>();
 
-  for (size_t i = 0; i < main_tables.size(); ++i) {
-    new_store->main_tables.push_back(main_tables[i]->copy());
-  }
-
+  new_store->_main_table = _main_table->copy();
   new_store->delta = delta->copy();
 
   if (merger == nullptr) {
@@ -232,10 +182,10 @@ atable_ptr_t Store::copy() const {
 
 const attr_vectors_t Store::getAttributeVectors(size_t column) const {
   attr_vectors_t tables;
-  for (const auto& main: main_tables) {
-    const auto& subtables = main->getAttributeVectors(column);
-    tables.insert(tables.end(), subtables.begin(), subtables.end());
-  }
+
+  const auto& subtablesM = _main_table->getAttributeVectors(column);
+  tables.insert(tables.end(), subtablesM.begin(), subtablesM.end());
+
   const auto& subtables = delta->getAttributeVectors(column);
   tables.insert(tables.end(), subtables.begin(), subtables.end());
   return tables;
@@ -244,9 +194,7 @@ const attr_vectors_t Store::getAttributeVectors(size_t column) const {
 void Store::debugStructure(size_t level) const {
   std::cout << std::string(level, '\t') << "Store " << this << std::endl;
   std::cout << std::string(level, '\t') << "(main) " << this << std::endl;
-  for (const auto& m: main_tables) {
-    m->debugStructure(level+1);
-  }
+  _main_table->debugStructure(level+1);
   std::cout << std::string(level, '\t') << "(delta) " << this << std::endl;
   delta->debugStructure(level+1);
 }
@@ -319,7 +267,7 @@ std::pair<size_t, size_t> Store::appendToDelta(size_t num) {
   // Update Delta
   delta->resize(start + num);
   // Update CID, TID and valid
-  auto main_tables_size = functional::sum(main_tables, 0ul, [](atable_ptr_t& t){return t->size();});
+  auto main_tables_size = _main_table->size();
 
   _cidBeginVector.resize(main_tables_size + start + num, tx::INF_CID);
   _cidEndVector.resize(main_tables_size + start + num, tx::INF_CID);
@@ -329,7 +277,7 @@ std::pair<size_t, size_t> Store::appendToDelta(size_t num) {
 }
 
 void Store::copyRowToDelta(const c_atable_ptr_t& source, const size_t src_row, const size_t dst_row, tx::transaction_id_t tid) {
-  auto main_tables_size = functional::sum(main_tables, 0ul, [](atable_ptr_t& t){return t->size();});
+  auto main_tables_size = _main_table->size();
 
   // Update the validity
   _tidVector[main_tables_size + dst_row] = tid;

src/lib/storage/Store.h

@@ -33,7 +33,7 @@ class Store : public AbstractTable {
   explicit Store(atable_ptr_t main_table);
   virtual ~Store();
 
-  std::vector< atable_ptr_t > getMainTables() const;
+  atable_ptr_t getMainTable() const;
   void setDelta(atable_ptr_t _delta);
   atable_ptr_t getDeltaTable() const;
   size_t deltaOffset() const;
@@ -80,16 +80,14 @@ class Store : public AbstractTable {
   unsigned partitionCount() const override;
   size_t partitionWidth(size_t slice) const override;
   void print(size_t limit = (size_t) - 1) const override;
-  table_id_t subtableCount() const override {
-    return main_tables.size() + 1;
-  }
+  table_id_t subtableCount() const override { return 2; }
   atable_ptr_t copy() const override;
   const attr_vectors_t getAttributeVectors(size_t column) const override;
   void debugStructure(size_t level=0) const override;
 
  private:
   //* Vector containing the main tables
-  std::vector< atable_ptr_t > main_tables;
+  atable_ptr_t _main_table;
 
   //* Delta store
   atable_ptr_t delta;