From 2528bd5be4632c29705333e4fbbe130c95e257dc Mon Sep 17 00:00:00 2001
From: bastih <sebastian.hillig@gmail.com>
Date: Mon, 18 Nov 2013 11:44:02 +0100
Subject: [PATCH 1/4] Allow for tuples to be set directly in Table

---
 src/lib/storage/Table.cpp | 13 +++++++++++++
 src/lib/storage/Table.h   |  4 ++++
 2 files changed, 17 insertions(+)

diff --git a/src/lib/storage/Table.cpp b/src/lib/storage/Table.cpp
index 1dd834542..bfd6c038f 100644
--- a/src/lib/storage/Table.cpp
+++ b/src/lib/storage/Table.cpp
@@ -57,6 +57,19 @@ Table::Table(
 }
 
 
+Table::Table(std::vector<ColumnMetadata> m,
+             SharedAttributeVector av,
+             std::vector<SharedDictionary> dicts) :
+  tuples(av),
+  _metadata(m.size()),
+  _dictionaries(dicts),
+  width(m.size()) {
+  assert(m.size() == dicts.size() && "Metadata size and dictionaries must match");
+  for (size_t i = 0; i < width; i++) {
+    _metadata[i] = new ColumnMetadata(m.at(i));
+  }
+}
+
 
 hyrise::storage::atable_ptr_t Table::copy_structure(const field_list_t *fields, const bool reuse_dict, const size_t initial_size, const bool with_containers, const bool compressed) const {
 
diff --git a/src/lib/storage/Table.h b/src/lib/storage/Table.h
index fe5ded5d9..cd1149671 100644
--- a/src/lib/storage/Table.h
+++ b/src/lib/storage/Table.h
@@ -70,6 +70,10 @@ class Table : public AbstractTable {
         bool sorted = true,
         bool compressed = true);
 
+  Table(std::vector<ColumnMetadata> m,
+        SharedAttributeVector av,
+        std::vector<SharedDictionary> dicts);
+
   ~Table();
 
   size_t size() const;

From 5f6f48f1be405892893d62d05aed4c12b1687159 Mon Sep 17 00:00:00 2001
From: bastih <sebastian.hillig@gmail.com>
Date: Mon, 18 Nov 2013 11:45:54 +0100
Subject: [PATCH 2/4] Remove DictionaryFactory in favor of simpler
 makeDictionary

---
 src/bin/units_storage/dict_factory.cpp | 13 ++++++++++
 src/lib/access/ExpressionScan.cpp      |  3 ++-
 src/lib/access/GroupByScan.cpp         |  3 ++-
 src/lib/access/Layouter.cpp            | 14 +++++-----
 src/lib/storage/AbstractDictionary.h   | 31 +---------------------
 src/lib/storage/AbstractTable.cpp      |  5 ++--
 src/lib/storage/DictionaryFactory.h    | 36 ++++++++++++++++++++++++++
 src/lib/storage/Table.cpp              | 14 +++++-----
 src/lib/storage/TableBuilder.cpp       |  3 ++-
 src/lib/storage/TableGenerator.cpp     |  5 ++--
 10 files changed, 77 insertions(+), 50 deletions(-)
 create mode 100644 src/bin/units_storage/dict_factory.cpp
 create mode 100644 src/lib/storage/DictionaryFactory.h

diff --git a/src/bin/units_storage/dict_factory.cpp b/src/bin/units_storage/dict_factory.cpp
new file mode 100644
index 000000000..26f5b550c
--- /dev/null
+++ b/src/bin/units_storage/dict_factory.cpp
@@ -0,0 +1,13 @@
+#include "gtest/gtest.h"
+
+#include "storage/DictionaryFactory.h"
+#include "storage/OrderPreservingDictionary.h"
+#include "storage/OrderIndifferentDictionary.h"
+
+namespace hyrise { namespace storage {
+
+TEST(factory, creation) {
+  auto d = makeDictionary<OrderIndifferentDictionary>(IntegerType, 10);
+}
+
+}}
diff --git a/src/lib/access/ExpressionScan.cpp b/src/lib/access/ExpressionScan.cpp
index 8a53aaeae..61e589781 100644
--- a/src/lib/access/ExpressionScan.cpp
+++ b/src/lib/access/ExpressionScan.cpp
@@ -2,6 +2,7 @@
 #include "access/ExpressionScan.h"
 
 #include "access/system/QueryParser.h"
+#include "storage/DictionaryFactory.h"
 #include "storage/OrderIndifferentDictionary.h"
 #include "storage/MutableVerticalTable.h"
 #include "storage/Table.h"
@@ -48,7 +49,7 @@ void ExpressionScan::executePlanOperation() {
   metadata.push_back(m);
 
   std::vector<AbstractTable::SharedDictionaryPtr> dicts;
-  dicts.push_back(AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary>>(_expression->getType()));
+  dicts.push_back(storage::makeDictionary<OrderIndifferentDictionary>(_expression->getType()));
 
   storage::atable_ptr_t exp_result = std::make_shared<Table>(&metadata, &dicts, 0, false);
   exp_result->resize(input_size);
diff --git a/src/lib/access/GroupByScan.cpp b/src/lib/access/GroupByScan.cpp
index 4878c82cf..a06758fe7 100644
--- a/src/lib/access/GroupByScan.cpp
+++ b/src/lib/access/GroupByScan.cpp
@@ -3,6 +3,7 @@
 
 #include "access/system/QueryParser.h"
 #include "storage/ColumnMetadata.h"
+#include "storage/DictionaryFactory.h"
 #include "storage/HashTable.h"
 #include "storage/PointerCalculator.h"
 #include "storage/OrderIndifferentDictionary.h"
@@ -133,7 +134,7 @@ storage::atable_ptr_t GroupByScan::createResultTableLayout() {
   for (const auto & fun: _aggregate_functions) {
     ColumnMetadata *m = new ColumnMetadata(fun->columnName(), fun->getType());
     metadata.push_back(m);
-    dictionaries.push_back(AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary> >(fun->getType()));
+    dictionaries.push_back(storage::makeDictionary<OrderIndifferentDictionary>(fun->getType()));
   }
   storage::atable_ptr_t agg_tab = std::make_shared<Table>(&metadata, &dictionaries, 0, false);
 
diff --git a/src/lib/access/Layouter.cpp b/src/lib/access/Layouter.cpp
index f8d6909a3..c8f50068b 100644
--- a/src/lib/access/Layouter.cpp
+++ b/src/lib/access/Layouter.cpp
@@ -2,7 +2,7 @@
 #include "access/Layouter.h"
 
 #include "access/system/QueryParser.h"
-
+#include "storage/DictionaryFactory.h"
 #include "storage/OrderIndifferentDictionary.h"
 #include "storage/Table.h"
 
@@ -64,12 +64,12 @@ void LayoutSingleTable::executePlanOperation() {
 
 
   std::vector<AbstractTable::SharedDictionaryPtr > vd;
-  vd.push_back(DictionaryFactory<OrderIndifferentDictionary>::build(StringType));
-  vd.push_back(DictionaryFactory<OrderIndifferentDictionary>::build(IntegerType));
-  vd.push_back(DictionaryFactory<OrderIndifferentDictionary>::build(FloatType));
-  vd.push_back(DictionaryFactory<OrderIndifferentDictionary>::build(IntegerType));
-  vd.push_back(DictionaryFactory<OrderIndifferentDictionary>::build(FloatType));
-  vd.push_back(DictionaryFactory<OrderIndifferentDictionary>::build(FloatType));
+  vd.push_back(storage::makeDictionary<OrderIndifferentDictionary>(StringType));
+  vd.push_back(storage::makeDictionary<OrderIndifferentDictionary>(IntegerType));
+  vd.push_back(storage::makeDictionary<OrderIndifferentDictionary>(FloatType));
+  vd.push_back(storage::makeDictionary<OrderIndifferentDictionary>(IntegerType));
+  vd.push_back(storage::makeDictionary<OrderIndifferentDictionary>(FloatType));
+  vd.push_back(storage::makeDictionary<OrderIndifferentDictionary>(FloatType));
 
   // Allocate a new Table
   result = std::make_shared<Table>(&vc, &vd, _maxResults, false);
diff --git a/src/lib/storage/AbstractDictionary.h b/src/lib/storage/AbstractDictionary.h
index 48e3120da..433ccf489 100644
--- a/src/lib/storage/AbstractDictionary.h
+++ b/src/lib/storage/AbstractDictionary.h
@@ -8,30 +8,6 @@
 
 #include "storage/storage_types.h"
 
-class AbstractDictionary;
-
-template < template<typename T> class D >
-struct DictionaryFactory {
-  static std::shared_ptr<AbstractDictionary> build(DataType type, size_t size = 0) {
-    switch (type) {
-      case IntegerType:
-        return std::make_shared<D<hyrise_int_t>>(size);
-        break;
-
-      case FloatType:
-        return std::make_shared<D<hyrise_float_t>>(size);
-        break;
-
-      case StringType:
-        return std::make_shared<D<hyrise_string_t>>(size);
-        break;
-
-      default:
-        throw std::runtime_error("Type not supported for dictionary");
-    }
-  }
-};
-
 
 class AbstractDictionary {
 public:
@@ -39,11 +15,6 @@ class AbstractDictionary {
 
   virtual bool isOrdered() = 0;
 
-  template< class Factory >
-  static std::shared_ptr<AbstractDictionary> dictionaryWithType(DataType type, size_t size = 0) {
-    return Factory::build(type, size);
-  }
-
   virtual void reserve(size_t size) = 0;
 
   virtual std::shared_ptr<AbstractDictionary> copy() = 0;
@@ -54,5 +25,5 @@ class AbstractDictionary {
 
 };
 
-#endif  // SRC_LIB_STORAGE_ABSTRACTDICTIONARY_H_
 
+#endif  // SRC_LIB_STORAGE_ABSTRACTDICTIONARY_H_
diff --git a/src/lib/storage/AbstractTable.cpp b/src/lib/storage/AbstractTable.cpp
index 200a03807..8c558deca 100644
--- a/src/lib/storage/AbstractTable.cpp
+++ b/src/lib/storage/AbstractTable.cpp
@@ -3,6 +3,7 @@
 
 #include <storage/MutableVerticalTable.h>
 #include <storage/Table.h>
+#include <storage/DictionaryFactory.h>
 #include <storage/Store.h>
 #include <storage/ColumnMetadata.h>
 #include <storage/ColumnMetadata.h>
@@ -58,12 +59,12 @@ hyrise::storage::atable_ptr_t AbstractTable::copy_structure_modifiable(const fie
   if (fields != nullptr) {
 for (const field_t & field: *fields) {
       metadata.push_back(metadataAt(field));
-      dictionaries->push_back(AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary> >(metadataAt(field)->getType()));
+      dictionaries->push_back(makeDictionary<OrderIndifferentDictionary>(metadataAt(field)->getType()));
     }
   } else {
     for (size_t i = 0; i < columnCount(); ++i) {
       metadata.push_back(metadataAt(i));
-      dictionaries->push_back(AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary> >(metadataAt(i)->getType()));
+      dictionaries->push_back(makeDictionary<OrderIndifferentDictionary>(metadataAt(i)->getType()));
     }
   }
 
diff --git a/src/lib/storage/DictionaryFactory.h b/src/lib/storage/DictionaryFactory.h
new file mode 100644
index 000000000..4995f099a
--- /dev/null
+++ b/src/lib/storage/DictionaryFactory.h
@@ -0,0 +1,36 @@
+#ifndef STORAGE_DICTIONARYFACTORY_H_
+#define STORAGE_DICTIONARYFACTORY_H_
+
+#include <memory>
+
+#include "storage/AbstractDictionary.h"
+#include "storage/meta_storage.h"
+
+namespace hyrise { namespace storage { namespace detail {
+
+template <template <typename T> class D>
+struct DictionaryCreator {
+  using value_type = std::shared_ptr<AbstractDictionary>;
+  std::size_t size;
+
+  template <typename R>
+  std::shared_ptr<AbstractDictionary> operator()() {
+    return std::make_shared<D<R>>(size);
+  }
+};
+
+} // ns detail
+
+// Create dictionary for type and size,
+// Usage: makeDictionary<OrderIndifferentDictionary>(IntegerType, 10),
+// which returns shared_ptr<OrderIndifferentDictionary<hyrise_int_t>> (init-ed
+// for 10 elements)
+template <template <typename T> class D>
+std::shared_ptr<AbstractDictionary> makeDictionary(DataType type, size_t size=0) {
+  detail::DictionaryCreator<D> dc {size};
+  return type_switch<hyrise_basic_types>()(type, dc);
+}
+
+}}
+
+#endif
diff --git a/src/lib/storage/Table.cpp b/src/lib/storage/Table.cpp
index bfd6c038f..35b4ae687 100644
--- a/src/lib/storage/Table.cpp
+++ b/src/lib/storage/Table.cpp
@@ -5,8 +5,11 @@
 #include <cmath>
 
 #include "storage/AttributeVectorFactory.h"
+#include "storage/DictionaryFactory.h"
 #include "storage/ValueIdMap.hpp"
 
+using namespace hyrise::storage;
+
 Table::Table(
   std::vector<const ColumnMetadata *> *m,
   std::vector<SharedDictionary> *d,
@@ -35,9 +38,7 @@ Table::Table(
     // for empty tables is not useful
     if (!sorted) {
       for (size_t i = 0; i < width; i++) {
-        _dictionaries[i] = AbstractDictionary::dictionaryWithType <
-                           DictionaryFactory<OrderIndifferentDictionary> > (
-                             _metadata[i]->getType(), initial_size);
+        _dictionaries[i] = makeDictionary<OrderIndifferentDictionary>(_metadata[i]->getType(), initial_size);
       }
     }
   }
@@ -111,17 +112,18 @@ hyrise::storage::atable_ptr_t Table::copy_structure_modifiable(const field_list_
   std::vector<AbstractTable::SharedDictionaryPtr > *dictionaries = new std::vector<AbstractTable::SharedDictionaryPtr >;
 
   if (fields != nullptr) {
-for (const field_t & field: *fields) {
+    for (const field_t & field: *fields) {
       metadata.push_back(metadataAt(field));
-      dictionaries->push_back(AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary> >(metadataAt(field)->getType()));
     }
   } else {
     for (size_t i = 0; i < columnCount(); ++i) {
       metadata.push_back(metadataAt(i));
-      dictionaries->push_back(AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary> >(metadataAt(i)->getType()));
     }
   }
 
+  for (const auto& field: metadata) {
+    dictionaries->push_back(makeDictionary<OrderIndifferentDictionary>(field->getType()));
+  }
 
   auto result = std::make_shared<Table>(&metadata, dictionaries, initial_size, false, _compressed);
   delete dictionaries;
diff --git a/src/lib/storage/TableBuilder.cpp b/src/lib/storage/TableBuilder.cpp
index 5e41ab943..efef08026 100644
--- a/src/lib/storage/TableBuilder.cpp
+++ b/src/lib/storage/TableBuilder.cpp
@@ -2,6 +2,7 @@
 #include "storage/TableBuilder.h"
 
 #include "storage/AbstractTable.h"
+#include "storage/DictionaryFactory.h"
 #include "storage/OrderIndifferentDictionary.h"
 #include "storage/Table.h"
 #include "storage/MutableVerticalTable.h"
@@ -31,7 +32,7 @@ hyrise::storage::atable_ptr_t TableBuilder::createTable(param_list::param_list_t
   for (; begin != end; ++begin) {
     vc.push_back(ColumnMetadata::metadataFromString((*begin).type, (*begin).name));
     vd.push_back(
-      DictionaryFactory<OrderIndifferentDictionary>::build(vc.back()->getType()));
+      makeDictionary<OrderIndifferentDictionary>(vc.back()->getType()));
   }
 
   auto tmp = std::make_shared<Table>(&vc, &vd, 0, 0, compressed);
diff --git a/src/lib/storage/TableGenerator.cpp b/src/lib/storage/TableGenerator.cpp
index b23890038..001721a65 100644
--- a/src/lib/storage/TableGenerator.cpp
+++ b/src/lib/storage/TableGenerator.cpp
@@ -13,6 +13,7 @@
 #include <helper/types.h>
 
 #include <storage/AbstractTable.h>
+#include <storage/DictionaryFactory.h>
 #include <storage/MutableVerticalTable.h>
 #include <storage/AbstractMergeStrategy.h>
 #include <storage/SequentialHeapMerger.h>
@@ -363,7 +364,7 @@ hyrise::storage::atable_ptr_t TableGenerator::create_empty_table(size_t rows, st
     md.push_back(m);
 
     auto d = new std::vector<AbstractTable::SharedDictionaryPtr>;
-    auto new_dict = AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderPreservingDictionary> >(IntegerType);
+    auto new_dict = makeDictionary<OrderPreservingDictionary>(IntegerType);
     d->push_back(new_dict);
     dicts.push_back(d);
   }
@@ -433,7 +434,7 @@ hyrise::storage::atable_ptr_t TableGenerator::create_empty_table_modifiable(size
     md.push_back(m);
 
     auto d = new std::vector<AbstractTable::SharedDictionaryPtr>;
-    auto new_dict = AbstractDictionary::dictionaryWithType<DictionaryFactory<OrderIndifferentDictionary> >(IntegerType);
+    auto new_dict = makeDictionary<OrderIndifferentDictionary>(IntegerType);
     d->push_back(new_dict);
     dicts.push_back(d);
   }

From be3d1f4b8ba2228784c11b0df41c492cbb8e5e82 Mon Sep 17 00:00:00 2001
From: bastih <sebastian.hillig@gmail.com>
Date: Mon, 18 Nov 2013 12:59:12 +0100
Subject: [PATCH 3/4] Add short documentation for Table constructor

---
 src/lib/storage/Table.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/lib/storage/Table.h b/src/lib/storage/Table.h
index cd1149671..8dabefaf1 100644
--- a/src/lib/storage/Table.h
+++ b/src/lib/storage/Table.h
@@ -70,6 +70,9 @@ class Table : public AbstractTable {
         bool sorted = true,
         bool compressed = true);
 
+  // Construct table from vector of metadata,
+  // a storage vector and dictionaries
+  // Expects: m.size() == dicts.size()
   Table(std::vector<ColumnMetadata> m,
         SharedAttributeVector av,
         std::vector<SharedDictionary> dicts);

From c67ca2ed58dcac6ce02288f001bee56debbe9ed4 Mon Sep 17 00:00:00 2001
From: bastih <sebastian.hillig@gmail.com>
Date: Wed, 20 Nov 2013 13:09:48 +0000
Subject: [PATCH 4/4] Improve check

---
 src/lib/storage/BitCompressedVector.h | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/lib/storage/BitCompressedVector.h b/src/lib/storage/BitCompressedVector.h
index f674f72e4..42c7728be 100644
--- a/src/lib/storage/BitCompressedVector.h
+++ b/src/lib/storage/BitCompressedVector.h
@@ -10,6 +10,7 @@
 #include <mutex>
 #include <string>
 #include <stdexcept>
+#include <type_traits>
 
 #include "memory/MallocStrategy.h"
 #include "storage/BaseAttributeVector.h"
@@ -18,7 +19,14 @@
 #define WORD_LENGTH 64
 #endif
 
-
+// Compute the maximum number representable for n-bit width integers.
+template <typename T,
+          class = typename std::enable_if<std::is_integral<T>::value>::type>
+T maxValueForBits(const std::size_t bits) {
+  assert(bits <= sizeof(T) * 8);
+  if (bits == sizeof(T) * 8) return static_cast<T>(-1);
+  else return (1ull << bits) -1;
+}
 /*
   can only save positive numbers
 */
@@ -96,7 +104,8 @@ class BitCompressedVector : public BaseAttributeVector<T> {
   void set(size_t column, size_t row, T value) {
     checkAccess(column, row);
 #ifdef EXPENSIVE_ASSERTIONS
-    if (value >= (1 << _bits[column])) throw std::out_of_range("trying to insert value larger than can be stored");
+    if (value > maxValueForBits<T>(_bits[column]))
+      throw std::out_of_range("trying to insert value larger than can be stored");
 #endif
     auto offset = _blockOffset(row);
     auto colOffset = _offsetForColumn(column);