From 4a7fc7f00d8421f842362fa3ee8e19bfa32fbefa Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sat, 6 Oct 2018 09:27:04 +0300
Subject: [PATCH 01/63] added asterisk without type and added move constructor
 to iterator

---
 dev/aggregate_functions.h       |  9 +++++++--
 dev/column_result.h             |  5 +++++
 dev/storage.h                   | 12 ++++++++++++
 include/sqlite_orm/sqlite_orm.h | 26 ++++++++++++++++++++++++--
 4 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/dev/aggregate_functions.h b/dev/aggregate_functions.h
index e63aff3c3..d5003bb8e 100644
--- a/dev/aggregate_functions.h
+++ b/dev/aggregate_functions.h
@@ -34,7 +34,12 @@ namespace sqlite_orm {
             operator std::string() const {
                 return "COUNT";
             }
-            
+        };
+        
+        struct count_asterisk_without_type {
+            operator std::string() const {
+                return "COUNT";
+            }
         };
         
         template<class T>
@@ -104,7 +109,7 @@ namespace sqlite_orm {
         return {t};
     }
     
-    inline aggregate_functions::count_asterisk_t<void> count() {
+    inline aggregate_functions::count_asterisk_without_type count() {
         return {};
     }
     
diff --git a/dev/column_result.h b/dev/column_result.h
index 22e978772..1df797697 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -171,6 +171,11 @@ namespace sqlite_orm {
             using type = std::shared_ptr<typename column_result_t<T>::type>;
         };
         
+        template<>
+        struct column_result_t<aggregate_functions::count_asterisk_without_type, void> {
+            using type = int;
+        };
+        
         template<class T>
         struct column_result_t<distinct_t<T>, void> {
             using type = typename column_result_t<T>::type;
diff --git a/dev/storage.h b/dev/storage.h
index 37a1dd23c..99277b6fb 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -109,6 +109,10 @@ namespace sqlite_orm {
                         this->operator++();
                     }
                     
+                    iterator_t(iterator_t&&) = default;
+                    
+                    iterator_t& operator=(iterator_t&&) = default;
+                    
                     ~iterator_t() {
                         if(this->stmt){
                             statement_finalizer f{*this->stmt};
@@ -600,6 +604,10 @@ namespace sqlite_orm {
             
             template<class T>
             std::string string_from_expression(const aggregate_functions::count_asterisk_t<T> &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
+                return this->string_from_expression(aggregate_functions::count_asterisk_without_type{});
+            }
+            
+            std::string string_from_expression(const aggregate_functions::count_asterisk_without_type &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
                 std::stringstream ss;
                 ss << static_cast<std::string>(f) << "(*) ";
                 return ss.str();
@@ -1699,6 +1707,10 @@ namespace sqlite_orm {
                 }
             }
             
+            std::set<std::pair<std::string, std::string>> parse_table_name(const aggregate_functions::count_asterisk_without_type &c) {
+                return {};
+            }
+            
             template<class T>
             std::set<std::pair<std::string, std::string>> parse_table_name(const asterisk_t<T> &ast) {
                 auto tableName = this->impl.template find_table_name<T>();
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 9c56fb6dc..94bc67b45 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3010,7 +3010,12 @@ namespace sqlite_orm {
             operator std::string() const {
                 return "COUNT";
             }
-            
+        };
+        
+        struct count_asterisk_without_type {
+            operator std::string() const {
+                return "COUNT";
+            }
         };
         
         template<class T>
@@ -3080,7 +3085,7 @@ namespace sqlite_orm {
         return {t};
     }
     
-    inline aggregate_functions::count_asterisk_t<void> count() {
+    inline aggregate_functions::count_asterisk_without_type count() {
         return {};
     }
     
@@ -4431,6 +4436,11 @@ namespace sqlite_orm {
             using type = std::shared_ptr<typename column_result_t<T>::type>;
         };
         
+        template<>
+        struct column_result_t<aggregate_functions::count_asterisk_without_type, void> {
+            using type = int;
+        };
+        
         template<class T>
         struct column_result_t<distinct_t<T>, void> {
             using type = typename column_result_t<T>::type;
@@ -6034,6 +6044,10 @@ namespace sqlite_orm {
                         this->operator++();
                     }
                     
+                    iterator_t(iterator_t&&) = default;
+                    
+                    iterator_t& operator=(iterator_t&&) = default;
+                    
                     ~iterator_t() {
                         if(this->stmt){
                             statement_finalizer f{*this->stmt};
@@ -6525,6 +6539,10 @@ namespace sqlite_orm {
             
             template<class T>
             std::string string_from_expression(const aggregate_functions::count_asterisk_t<T> &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
+                return this->string_from_expression(aggregate_functions::count_asterisk_without_type{});
+            }
+            
+            std::string string_from_expression(const aggregate_functions::count_asterisk_without_type &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
                 std::stringstream ss;
                 ss << static_cast<std::string>(f) << "(*) ";
                 return ss.str();
@@ -7624,6 +7642,10 @@ namespace sqlite_orm {
                 }
             }
             
+            std::set<std::pair<std::string, std::string>> parse_table_name(const aggregate_functions::count_asterisk_without_type &c) {
+                return {};
+            }
+            
             template<class T>
             std::set<std::pair<std::string, std::string>> parse_table_name(const asterisk_t<T> &ast) {
                 auto tableName = this->impl.template find_table_name<T>();

From dbecb57c781218525443c8d7556e5cf778e74984 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sat, 6 Oct 2018 09:45:13 +0300
Subject: [PATCH 02/63] added copy ctor to iterator

---
 dev/storage.h                   | 4 ++++
 include/sqlite_orm/sqlite_orm.h | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/dev/storage.h b/dev/storage.h
index 99277b6fb..7e1216abf 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -109,10 +109,14 @@ namespace sqlite_orm {
                         this->operator++();
                     }
                     
+                    iterator_t(const iterator_t &) = default;
+                    
                     iterator_t(iterator_t&&) = default;
                     
                     iterator_t& operator=(iterator_t&&) = default;
                     
+                    iterator_t& operator=(const iterator_t&) = default;
+                    
                     ~iterator_t() {
                         if(this->stmt){
                             statement_finalizer f{*this->stmt};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 94bc67b45..9257dc5f3 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -6044,10 +6044,14 @@ namespace sqlite_orm {
                         this->operator++();
                     }
                     
+                    iterator_t(const iterator_t &) = default;
+                    
                     iterator_t(iterator_t&&) = default;
                     
                     iterator_t& operator=(iterator_t&&) = default;
                     
+                    iterator_t& operator=(const iterator_t&) = default;
+                    
                     ~iterator_t() {
                         if(this->stmt){
                             statement_finalizer f{*this->stmt};

From 3007eb6f6de7bef2201e26433c37d6e578951b6d Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Mon, 8 Oct 2018 12:55:45 +0300
Subject: [PATCH 03/63] started except

---
 dev/select_constraints.h        | 39 +++++++++++++++++--
 dev/storage.h                   |  2 +-
 examples/except.cpp             | 69 +++++++++++++++++++++++++++++++++
 include/sqlite_orm/sqlite_orm.h | 41 ++++++++++++++++++--
 4 files changed, 143 insertions(+), 8 deletions(-)
 create mode 100644 examples/except.cpp

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 8d38c189d..ddb565f6d 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -120,18 +120,31 @@ namespace sqlite_orm {
         };
         
         /**
-         *  Union object type.
+         *  Base for UNION, UNION ALL, EXCEPT and INTERSECT
          */
         template<class L, class R>
-        struct union_t {
+        struct compound_operator {
             using left_type = L;
             using right_type = R;
             
             left_type left;
             right_type right;
+            
+            compound_operator(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+        };
+        
+        /**
+         *  Union object type.
+         */
+        template<class L, class R>
+        struct union_t : public compound_operator<L, R> {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
+            
             bool all = false;
             
-            union_t(left_type l, right_type r, decltype(all) all_): left(std::move(l)), right(std::move(r)), all(all_) {
+            union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {
                 this->left.highest_level = true;
                 this->right.highest_level = true;
             }
@@ -147,6 +160,21 @@ namespace sqlite_orm {
             }
         };
         
+        template<class L, class R>
+        struct except_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type left;
+            right_type right;
+            
+            except_t(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+            
+            operator std::string() const {
+                return "EXCEPT";
+            }
+        };
+        
         /**
          *  Generic way to get DISTINCT value from any type.
          */
@@ -224,6 +252,11 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
     
+    template<class L, class R>
+    internal::except_t<L, R> except(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+    
     /**
      *  Public function for UNION ALL operator.
      *  lhs and rhs are subselect objects.
diff --git a/dev/storage.h b/dev/storage.h
index 7e1216abf..00f556f2d 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -2324,7 +2324,7 @@ namespace sqlite_orm {
             class R,
             class ...Args,
             class Ret = typename internal::column_result_t<union_t<L, R>>::type>
-            std::vector<Ret> select(union_t<L, R> op, Args ...args) {
+            std::vector<Ret> select(const union_t<L, R> &op, Args ...args) {
                 std::stringstream ss;
                 ss << this->string_from_expression(op.left) << " ";
                 ss << static_cast<std::string>(op) << " ";
diff --git a/examples/except.cpp b/examples/except.cpp
new file mode 100644
index 000000000..d1b327d37
--- /dev/null
+++ b/examples/except.cpp
@@ -0,0 +1,69 @@
+/**
+ *  Example is implemented from here https://www.tutlane.com/tutorial/sqlite/sqlite-except-operator
+ */
+#include <sqlite_orm/sqlite_orm.h>
+#include <string>
+#include <iostream>
+
+using std::cout;
+using std::endl;
+
+struct DeptMaster {
+    int deptId = 0;
+    std::string deptName;
+};
+
+struct EmpMaster {
+    int empId = 0;
+    std::string firstName;
+    std::string lastName;
+    long salary;
+    decltype(DeptMaster::deptId) deptId;
+};
+
+int main() {
+    using namespace sqlite_orm;
+    
+    auto storage = make_storage("",
+                                make_table("dept_master",
+                                           make_column("dept_id", &DeptMaster::deptId, autoincrement(), primary_key()),
+                                           make_column("dept_name", &DeptMaster::deptName)),
+                                make_table("emp_master",
+                                           make_column("emp_id", &EmpMaster::empId, autoincrement(), primary_key()),
+                                           make_column("first_name", &EmpMaster::firstName),
+                                           make_column("last_name", &EmpMaster::lastName),
+                                           make_column("salary", &EmpMaster::salary),
+                                           make_column("dept_id", &EmpMaster::deptId),
+                                           foreign_key(&EmpMaster::deptId).references(&DeptMaster::deptId)));
+    storage.sync_schema();
+    storage.remove_all<DeptMaster>();
+    storage.remove_all<EmpMaster>();
+    {
+        auto valuesToInsert = {
+            DeptMaster{0, "Admin"},
+            DeptMaster{0, "Sales"},
+            DeptMaster{0, "Quality Control"},
+            DeptMaster{0, "Marketing"},
+        };
+        storage.insert_range(valuesToInsert.begin(), valuesToInsert.end());
+    }
+    {
+        auto valuesToInsert = {
+            EmpMaster{1, "Honey", "Patel", 10100, 1},
+            EmpMaster{2, "Shweta", "Jariwala", 19300, 2},
+            EmpMaster{3, "Vinay", "Jariwala", 35100, 3},
+            EmpMaster{4, "Jagruti", "Viras", 9500, 4},
+        };
+        storage.replace_range(valuesToInsert.begin(), valuesToInsert.end());
+    }
+    {
+        //  SELECT dept_id
+        //  FROM dept_master
+        //  EXCEPT
+        //  SELECT dept_id
+        //  FROM emp_master
+        auto rows = storage.select(<#T m#>, <#Args args...#>)
+    }
+    
+    return 0;
+}
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 9257dc5f3..8a156867f 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3275,18 +3275,31 @@ namespace sqlite_orm {
         };
         
         /**
-         *  Union object type.
+         *  Base for UNION, UNION ALL, EXCEPT and INTERSECT
          */
         template<class L, class R>
-        struct union_t {
+        struct compound_operator {
             using left_type = L;
             using right_type = R;
             
             left_type left;
             right_type right;
+            
+            compound_operator(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+        };
+        
+        /**
+         *  Union object type.
+         */
+        template<class L, class R>
+        struct union_t : public compound_operator<L, R> {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
+            
             bool all = false;
             
-            union_t(left_type l, right_type r, decltype(all) all_): left(std::move(l)), right(std::move(r)), all(all_) {
+            union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {
                 this->left.highest_level = true;
                 this->right.highest_level = true;
             }
@@ -3302,6 +3315,21 @@ namespace sqlite_orm {
             }
         };
         
+        template<class L, class R>
+        struct except_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type left;
+            right_type right;
+            
+            except_t(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+            
+            operator std::string() const {
+                return "EXCEPT";
+            }
+        };
+        
         /**
          *  Generic way to get DISTINCT value from any type.
          */
@@ -3379,6 +3407,11 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
     
+    template<class L, class R>
+    internal::except_t<L, R> except(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+    
     /**
      *  Public function for UNION ALL operator.
      *  lhs and rhs are subselect objects.
@@ -8259,7 +8292,7 @@ namespace sqlite_orm {
             class R,
             class ...Args,
             class Ret = typename internal::column_result_t<union_t<L, R>>::type>
-            std::vector<Ret> select(union_t<L, R> op, Args ...args) {
+            std::vector<Ret> select(const union_t<L, R> &op, Args ...args) {
                 std::stringstream ss;
                 ss << this->string_from_expression(op.left) << " ";
                 ss << static_cast<std::string>(op) << " ";

From 32cc01bf4b5506f5aa09cc6849fd1690ad8c2d5c Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Mon, 8 Oct 2018 13:35:09 +0300
Subject: [PATCH 04/63] added except feature and refactored union and except as
 compound operator derived classes

---
 .travis.yml                     |  2 ++
 dev/column_result.h             |  8 ++++++
 dev/select_constraints.h        | 31 ++++++++++++--------
 dev/storage.h                   | 11 ++++----
 examples/except.cpp             | 12 +++++---
 include/sqlite_orm/sqlite_orm.h | 50 ++++++++++++++++++++++-----------
 tests/static_tests.cpp          |  6 ++++
 7 files changed, 82 insertions(+), 38 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 89e3eca57..69db23f80 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -75,3 +75,5 @@ script:
   - ./a.out
   - clang++ -std=c++1y examples/exists.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
   - ./a.out
+  - clang++ -std=c++1y examples/except.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
+  - ./a.out
diff --git a/dev/column_result.h b/dev/column_result.h
index 1df797697..d2c77bdd0 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -269,5 +269,13 @@ namespace sqlite_orm {
             static_assert(std::is_same<left_type, right_type>::value, "Union subselect queries must return same types");
             using type = left_type;
         };
+        
+        template<class L, class R>
+        struct column_result_t<except_t<L, R>, void> {
+            using left_type = typename column_result_t<L>::type;
+            using right_type = typename column_result_t<R>::type;
+            static_assert(std::is_same<left_type, right_type>::value, "Except subselect queries must return same types");
+            using type = left_type;
+        };
     }
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index ddb565f6d..5776d3f20 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -6,6 +6,15 @@ namespace sqlite_orm {
     
     namespace internal {
         
+        template <template <typename...> class C, typename...Ts>
+        std::true_type is_base_of_template_impl(const C<Ts...>*);
+        
+        template <template <typename...> class C>
+        std::false_type is_base_of_template_impl(...);
+        
+        template <typename T, template <typename...> class C>
+        using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
+        
         /**
          *  DISCTINCT generic container.
          */
@@ -130,7 +139,10 @@ namespace sqlite_orm {
             left_type left;
             right_type right;
             
-            compound_operator(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+            compound_operator(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {
+                this->left.highest_level = true;
+                this->right.highest_level = true;
+            }
         };
         
         /**
@@ -144,10 +156,7 @@ namespace sqlite_orm {
             
             bool all = false;
             
-            union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {
-                this->left.highest_level = true;
-                this->right.highest_level = true;
-            }
+            union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {}
             
             union_t(left_type l, right_type r): union_t(std::move(l), std::move(r), false) {}
 
@@ -161,14 +170,12 @@ namespace sqlite_orm {
         };
         
         template<class L, class R>
-        struct except_t {
-            using left_type = L;
-            using right_type = R;
-            
-            left_type left;
-            right_type right;
+        struct except_t : public compound_operator<L, R> {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
             
-            except_t(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+            using super::super;
             
             operator std::string() const {
                 return "EXCEPT";
diff --git a/dev/storage.h b/dev/storage.h
index 00f556f2d..0b2edb70e 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -2291,7 +2291,8 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename internal::column_result_t<T>::type>
+            class R = typename column_result_t<T>::type,
+            typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr>
             std::vector<R> select(T m, Args ...args) {
                 using select_type = select_t<T, Args...>;
                 auto query = this->string_from_expression(select_type{std::move(m), std::make_tuple<Args...>(std::forward<Args>(args)...), true});
@@ -2320,11 +2321,11 @@ namespace sqlite_orm {
             }
             
             template<
-            class L,
-            class R,
+            class T,
             class ...Args,
-            class Ret = typename internal::column_result_t<union_t<L, R>>::type>
-            std::vector<Ret> select(const union_t<L, R> &op, Args ...args) {
+            class Ret = typename column_result_t<T>::type,
+            typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
+            std::vector<Ret> select(T op, Args ...args) {
                 std::stringstream ss;
                 ss << this->string_from_expression(op.left) << " ";
                 ss << static_cast<std::string>(op) << " ";
diff --git a/examples/except.cpp b/examples/except.cpp
index d1b327d37..c47751dce 100644
--- a/examples/except.cpp
+++ b/examples/except.cpp
@@ -33,8 +33,7 @@ int main() {
                                            make_column("first_name", &EmpMaster::firstName),
                                            make_column("last_name", &EmpMaster::lastName),
                                            make_column("salary", &EmpMaster::salary),
-                                           make_column("dept_id", &EmpMaster::deptId),
-                                           foreign_key(&EmpMaster::deptId).references(&DeptMaster::deptId)));
+                                           make_column("dept_id", &EmpMaster::deptId)));
     storage.sync_schema();
     storage.remove_all<DeptMaster>();
     storage.remove_all<EmpMaster>();
@@ -52,7 +51,7 @@ int main() {
             EmpMaster{1, "Honey", "Patel", 10100, 1},
             EmpMaster{2, "Shweta", "Jariwala", 19300, 2},
             EmpMaster{3, "Vinay", "Jariwala", 35100, 3},
-            EmpMaster{4, "Jagruti", "Viras", 9500, 4},
+            EmpMaster{4, "Jagruti", "Viras", 9500, 12},
         };
         storage.replace_range(valuesToInsert.begin(), valuesToInsert.end());
     }
@@ -62,7 +61,12 @@ int main() {
         //  EXCEPT
         //  SELECT dept_id
         //  FROM emp_master
-        auto rows = storage.select(<#T m#>, <#Args args...#>)
+        auto rows = storage.select(except(select(&DeptMaster::deptId),
+                                          select(&EmpMaster::deptId)));
+        cout << "rows count = " << rows.size() << endl;
+        for(auto id : rows) {
+            cout << id << endl;
+        }
     }
     
     return 0;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 8a156867f..fb49765e1 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3161,6 +3161,15 @@ namespace sqlite_orm {
     
     namespace internal {
         
+        template <template <typename...> class C, typename...Ts>
+        std::true_type is_base_of_template_impl(const C<Ts...>*);
+        
+        template <template <typename...> class C>
+        std::false_type is_base_of_template_impl(...);
+        
+        template <typename T, template <typename...> class C>
+        using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
+        
         /**
          *  DISCTINCT generic container.
          */
@@ -3285,7 +3294,10 @@ namespace sqlite_orm {
             left_type left;
             right_type right;
             
-            compound_operator(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+            compound_operator(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {
+                this->left.highest_level = true;
+                this->right.highest_level = true;
+            }
         };
         
         /**
@@ -3299,10 +3311,7 @@ namespace sqlite_orm {
             
             bool all = false;
             
-            union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {
-                this->left.highest_level = true;
-                this->right.highest_level = true;
-            }
+            union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {}
             
             union_t(left_type l, right_type r): union_t(std::move(l), std::move(r), false) {}
 
@@ -3316,14 +3325,12 @@ namespace sqlite_orm {
         };
         
         template<class L, class R>
-        struct except_t {
-            using left_type = L;
-            using right_type = R;
-            
-            left_type left;
-            right_type right;
+        struct except_t : public compound_operator<L, R> {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
             
-            except_t(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
+            using super::super;
             
             operator std::string() const {
                 return "EXCEPT";
@@ -4567,6 +4574,14 @@ namespace sqlite_orm {
             static_assert(std::is_same<left_type, right_type>::value, "Union subselect queries must return same types");
             using type = left_type;
         };
+        
+        template<class L, class R>
+        struct column_result_t<except_t<L, R>, void> {
+            using left_type = typename column_result_t<L>::type;
+            using right_type = typename column_result_t<R>::type;
+            static_assert(std::is_same<left_type, right_type>::value, "Except subselect queries must return same types");
+            using type = left_type;
+        };
     }
 }
 #pragma once
@@ -8259,7 +8274,8 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename internal::column_result_t<T>::type>
+            class R = typename column_result_t<T>::type,
+            typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr>
             std::vector<R> select(T m, Args ...args) {
                 using select_type = select_t<T, Args...>;
                 auto query = this->string_from_expression(select_type{std::move(m), std::make_tuple<Args...>(std::forward<Args>(args)...), true});
@@ -8288,11 +8304,11 @@ namespace sqlite_orm {
             }
             
             template<
-            class L,
-            class R,
+            class T,
             class ...Args,
-            class Ret = typename internal::column_result_t<union_t<L, R>>::type>
-            std::vector<Ret> select(const union_t<L, R> &op, Args ...args) {
+            class Ret = typename column_result_t<T>::type,
+            typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
+            std::vector<Ret> select(T op, Args ...args) {
                 std::stringstream ss;
                 ss << this->string_from_expression(op.left) << " ";
                 ss << static_cast<std::string>(op) << " ";
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 071f85883..ee00a7573 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -217,6 +217,12 @@ int main() {
                       "Incorrect sum value");
         
     }
+    {
+        auto unionValue = union_(select(&User::id), select(&Token::id));
+        static_assert(internal::is_base_of_template<decltype(unionValue), internal::compound_operator>::value, "union must be base of compound_operator");
+        auto exceptValue = except(select(&User::id), select(&Token::id));
+        static_assert(internal::is_base_of_template<decltype(exceptValue), internal::compound_operator>::value, "except must be base of compound_operator");
+    }
     
     auto storage = make_storage("",
                                 make_table("users",

From 01768423ac83af5cd5595f4f2b6309d02d26c70b Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Wed, 10 Oct 2018 14:12:11 +0300
Subject: [PATCH 05/63] added intersect

---
 dev/column_result.h                           | 22 ++---
 dev/select_constraints.h                      | 31 ++++++-
 .../{except.cpp => except_intersection.cpp}   | 13 +++
 examples/left_and_inner_join.cpp              | 84 ++++++-------------
 include/sqlite_orm/sqlite_orm.h               | 53 ++++++++----
 5 files changed, 115 insertions(+), 88 deletions(-)
 rename examples/{except.cpp => except_intersection.cpp} (85%)

diff --git a/dev/column_result.h b/dev/column_result.h
index d2c77bdd0..a3ab56cc3 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -262,20 +262,14 @@ namespace sqlite_orm {
         template<class T, class ...Args>
         struct column_result_t<select_t<T, Args...>> : column_result_t<T, void> {};
         
-        template<class L, class R>
-        struct column_result_t<union_t<L, R>, void> {
-            using left_type = typename column_result_t<L>::type;
-            using right_type = typename column_result_t<R>::type;
-            static_assert(std::is_same<left_type, right_type>::value, "Union subselect queries must return same types");
-            using type = left_type;
-        };
-        
-        template<class L, class R>
-        struct column_result_t<except_t<L, R>, void> {
-            using left_type = typename column_result_t<L>::type;
-            using right_type = typename column_result_t<R>::type;
-            static_assert(std::is_same<left_type, right_type>::value, "Except subselect queries must return same types");
-            using type = left_type;
+        template<class T>
+        struct column_result_t<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+            using left_type = typename T::left_type;
+            using right_type = typename T::right_type;
+            using left_result = typename column_result_t<left_type>::type;
+            using right_result = typename column_result_t<right_type>::type;
+            static_assert(std::is_same<left_result, right_result>::value, "Compound subselect queries must return same types");
+            using type = left_result;
         };
     }
 }
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index 5776d3f20..cd0397dee 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -146,7 +146,7 @@ namespace sqlite_orm {
         };
         
         /**
-         *  Union object type.
+         *  UNION object type.
          */
         template<class L, class R>
         struct union_t : public compound_operator<L, R> {
@@ -169,6 +169,9 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  EXCEPT object type.
+         */
         template<class L, class R>
         struct except_t : public compound_operator<L, R> {
             using super = compound_operator<L, R>;
@@ -182,6 +185,22 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  INTERSECT object type.
+         */
+        template<class L, class R>
+        struct intersect_t : public compound_operator<L, R> {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
+            
+            using super::super;
+            
+            operator std::string() const {
+                return "INTERSECT";
+            }
+        };
+        
         /**
          *  Generic way to get DISTINCT value from any type.
          */
@@ -259,11 +278,21 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
     
+    /**
+     *  Public function for EXCEPT operator.
+     *  lhs and rhs are subselect objects.
+     *  Look through example in examples/except.cpp
+     */
     template<class L, class R>
     internal::except_t<L, R> except(L lhs, R rhs) {
         return {std::move(lhs), std::move(rhs)};
     }
     
+    template<class L, class R>
+    internal::intersect_t<L, R> intersect(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+    
     /**
      *  Public function for UNION ALL operator.
      *  lhs and rhs are subselect objects.
diff --git a/examples/except.cpp b/examples/except_intersection.cpp
similarity index 85%
rename from examples/except.cpp
rename to examples/except_intersection.cpp
index c47751dce..43ab7beef 100644
--- a/examples/except.cpp
+++ b/examples/except_intersection.cpp
@@ -68,6 +68,19 @@ int main() {
             cout << id << endl;
         }
     }
+    {
+        //  SELECT dept_id
+        //  FROM dept_master
+        //  INTERSECT
+        //  SELECT dept_id
+        //  FROM emp_master
+        auto rows = storage.select(intersect(select(&DeptMaster::deptId),
+                                             select(&EmpMaster::deptId)));
+        cout << "rows count = " << rows.size() << endl;
+        for(auto id : rows) {
+            cout << id << endl;
+        }
+    }
     
     return 0;
 }
diff --git a/examples/left_and_inner_join.cpp b/examples/left_and_inner_join.cpp
index 4c6b597c7..286ccc4d4 100644
--- a/examples/left_and_inner_join.cpp
+++ b/examples/left_and_inner_join.cpp
@@ -39,39 +39,22 @@ inline auto initStorage(const std::string &path){
     using namespace sqlite_orm;
     return make_storage(path,
                         make_table("artists",
-                                   make_column("ArtistId",
-                                               &Artist::artistId,
-                                               primary_key()),
-                                   make_column("Name",
-                                               &Artist::name)),
+                                   make_column("ArtistId", &Artist::artistId, primary_key()),
+                                   make_column("Name", &Artist::name)),
                         make_table("albums",
-                                   make_column("AlbumId",
-                                               &Album::albumId,
-                                               primary_key()),
-                                   make_column("Title",
-                                               &Album::title),
-                                   make_column("ArtistId",
-                                               &Album::artistId)),
+                                   make_column("AlbumId", &Album::albumId, primary_key()),
+                                   make_column("Title", &Album::title),
+                                   make_column("ArtistId", &Album::artistId)),
                         make_table("tracks",
-                                   make_column("TrackId",
-                                               &Track::trackId,
-                                               primary_key()),
-                                   make_column("Name",
-                                               &Track::name),
-                                   make_column("AlbumId",
-                                               &Track::albumId),
-                                   make_column("MediaTypeId",
-                                               &Track::mediaTypeId),
-                                   make_column("GenreId",
-                                               &Track::genreId),
-                                   make_column("Composer",
-                                               &Track::composer),
-                                   make_column("Milliseconds",
-                                               &Track::milliseconds),
-                                   make_column("Bytes",
-                                               &Track::bytes),
-                                   make_column("UnitPrice",
-                                               &Track::unitPrice)));
+                                   make_column("TrackId", &Track::trackId, primary_key()),
+                                   make_column("Name", &Track::name),
+                                   make_column("AlbumId", &Track::albumId),
+                                   make_column("MediaTypeId", &Track::mediaTypeId),
+                                   make_column("GenreId", &Track::genreId),
+                                   make_column("Composer", &Track::composer),
+                                   make_column("Milliseconds", &Track::milliseconds),
+                                   make_column("Bytes", &Track::bytes),
+                                   make_column("UnitPrice", &Track::unitPrice)));
 }
 
 int main(int argc, char **argv) {
@@ -262,36 +245,21 @@ int main(int argc, char **argv) {
         
         auto storage2 = make_storage("doctors.sqlite",
                                      make_table("doctors",
-                                                make_column("doctor_id",
-                                                            &Doctor::id,
-                                                            primary_key()),
-                                                make_column("doctor_name",
-                                                            &Doctor::name),
-                                                make_column("degree",
-                                                            &Doctor::degree)),
+                                                make_column("doctor_id", &Doctor::id, primary_key()),
+                                                make_column("doctor_name", &Doctor::name),
+                                                make_column("degree", &Doctor::degree)),
                                      make_table("visits",
-                                                make_column("doctor_id",
-                                                            &Visit::doctorId),
-                                                make_column("patient_name",
-                                                            &Visit::patientName),
-                                                make_column("vdate",
-                                                            &Visit::vdate)),
+                                                make_column("doctor_id", &Visit::doctorId),
+                                                make_column("patient_name", &Visit::patientName),
+                                                make_column("vdate", &Visit::vdate)),
                                      make_table("table_a",
-                                                make_column("id",
-                                                            &A::id,
-                                                            primary_key()),
-                                                make_column("des1",
-                                                            &A::des1),
-                                                make_column("des2",
-                                                            &A::des2)),
+                                                make_column("id", &A::id, primary_key()),
+                                                make_column("des1", &A::des1),
+                                                make_column("des2", &A::des2)),
                                      make_table("table_b",
-                                                make_column("id",
-                                                            &B::id,
-                                                            primary_key()),
-                                                make_column("des3",
-                                                            &B::des3),
-                                                make_column("des4",
-                                                            &B::des4)));
+                                                make_column("id", &B::id, primary_key()),
+                                                make_column("des3", &B::des3),
+                                                make_column("des4", &B::des4)));
         storage2.sync_schema();
         
         storage2.replace(Doctor{ 210, "Dr. John Linga", "MD", });
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index fb49765e1..32a4e1a9c 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3301,7 +3301,7 @@ namespace sqlite_orm {
         };
         
         /**
-         *  Union object type.
+         *  UNION object type.
          */
         template<class L, class R>
         struct union_t : public compound_operator<L, R> {
@@ -3324,6 +3324,9 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  EXCEPT object type.
+         */
         template<class L, class R>
         struct except_t : public compound_operator<L, R> {
             using super = compound_operator<L, R>;
@@ -3337,6 +3340,22 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  INTERSECT object type.
+         */
+        template<class L, class R>
+        struct intersect_t : public compound_operator<L, R> {
+            using super = compound_operator<L, R>;
+            using left_type = typename super::left_type;
+            using right_type = typename super::right_type;
+            
+            using super::super;
+            
+            operator std::string() const {
+                return "INTERSECT";
+            }
+        };
+        
         /**
          *  Generic way to get DISTINCT value from any type.
          */
@@ -3414,11 +3433,21 @@ namespace sqlite_orm {
         return {std::move(lhs), std::move(rhs)};
     }
     
+    /**
+     *  Public function for EXCEPT operator.
+     *  lhs and rhs are subselect objects.
+     *  Look through example in examples/except.cpp
+     */
     template<class L, class R>
     internal::except_t<L, R> except(L lhs, R rhs) {
         return {std::move(lhs), std::move(rhs)};
     }
     
+    template<class L, class R>
+    internal::intersect_t<L, R> intersect(L lhs, R rhs) {
+        return {std::move(lhs), std::move(rhs)};
+    }
+    
     /**
      *  Public function for UNION ALL operator.
      *  lhs and rhs are subselect objects.
@@ -4567,20 +4596,14 @@ namespace sqlite_orm {
         template<class T, class ...Args>
         struct column_result_t<select_t<T, Args...>> : column_result_t<T, void> {};
         
-        template<class L, class R>
-        struct column_result_t<union_t<L, R>, void> {
-            using left_type = typename column_result_t<L>::type;
-            using right_type = typename column_result_t<R>::type;
-            static_assert(std::is_same<left_type, right_type>::value, "Union subselect queries must return same types");
-            using type = left_type;
-        };
-        
-        template<class L, class R>
-        struct column_result_t<except_t<L, R>, void> {
-            using left_type = typename column_result_t<L>::type;
-            using right_type = typename column_result_t<R>::type;
-            static_assert(std::is_same<left_type, right_type>::value, "Except subselect queries must return same types");
-            using type = left_type;
+        template<class T>
+        struct column_result_t<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+            using left_type = typename T::left_type;
+            using right_type = typename T::right_type;
+            using left_result = typename column_result_t<left_type>::type;
+            using right_result = typename column_result_t<right_type>::type;
+            static_assert(std::is_same<left_result, right_result>::value, "Compound subselect queries must return same types");
+            using type = left_result;
         };
     }
 }

From 38386d41644be4b7a1eb5f9370af95b0219a6eaa Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Wed, 10 Oct 2018 14:26:22 +0300
Subject: [PATCH 06/63] fixed travis except_intersection path

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 69db23f80..cba25a916 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -75,5 +75,5 @@ script:
   - ./a.out
   - clang++ -std=c++1y examples/exists.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
   - ./a.out
-  - clang++ -std=c++1y examples/except.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
+  - clang++ -std=c++1y examples/except_intersection.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
   - ./a.out

From a7c99ff1e07c616521d236763dc8a5c94c895b87 Mon Sep 17 00:00:00 2001
From: Yevgeniy Zakharov <fnc12@me.com>
Date: Wed, 10 Oct 2018 14:33:21 +0300
Subject: [PATCH 07/63] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 871ec4994..0cf063d06 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ SQLite ORM light header only library for modern C++
 * **Built with modern C++14 features (no macros and external scripts)**
 * **CRUD support**
 * **Pure select query support**
+* **UNION, EXCEPT and INTERSECT support**
 * **STL compatible**
 * **Custom types binding support**
 * **BLOB support** - maps to `std::vector<char>` or one can bind your custom type

From 7e47c686f2b2525a215ac3753b172ccfb9ad6387 Mon Sep 17 00:00:00 2001
From: Yevgeniy Zakharov <fnc12@me.com>
Date: Wed, 10 Oct 2018 14:58:52 +0300
Subject: [PATCH 08/63] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 0cf063d06..52558ba47 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,8 @@
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
 [![Build Status](https://travis-ci.org/fnc12/sqlite_orm.svg?branch=master)](https://travis-ci.org/fnc12/sqlite_orm)
 [![Donate using PayPal](https://img.shields.io/badge/donate-PayPal-brightgreen.svg)](https://paypal.me/fnc12)
+[![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/fold_left.svg?style=social&label=Follow%20%40sqlite_orm)](https://twitter.com/sqlite_orm)
+
 
 # SQLite ORM
 SQLite ORM light header only library for modern C++

From 247deae219275b327d6a8cafe3e902a7d6285064 Mon Sep 17 00:00:00 2001
From: elimpnick <elimpnick@users.noreply.github.com>
Date: Thu, 11 Oct 2018 16:40:03 -0400
Subject: [PATCH 09/63] fixed -Wreorder warning issue with g++/clang++

---
 include/sqlite_orm/sqlite_orm.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 32a4e1a9c..aa91379ba 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -6240,11 +6240,11 @@ namespace sqlite_orm {
             storage_t(const storage_t &other):
             filename(other.filename),
             impl(other.impl),
+            currentTransaction(other.currentTransaction),
             inMemory(other.inMemory),
-            pragma(*this),
-            limit(*this),
             collatingFunctions(other.collatingFunctions),
-            currentTransaction(other.currentTransaction)
+            pragma(*this),
+            limit(*this)
             {}
             
         protected:

From 4000b990d7585fbc94290780dbdef467316ec720 Mon Sep 17 00:00:00 2001
From: elimpnick <elimpnick@users.noreply.github.com>
Date: Thu, 11 Oct 2018 16:44:45 -0400
Subject: [PATCH 10/63] fixed -Wreorder warning issue with g++/clang++

---
 dev/storage.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index 0b2edb70e..981cad6ab 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -234,11 +234,11 @@ namespace sqlite_orm {
             storage_t(const storage_t &other):
             filename(other.filename),
             impl(other.impl),
+            currentTransaction(other.currentTransaction),
             inMemory(other.inMemory),
-            pragma(*this),
-            limit(*this),
             collatingFunctions(other.collatingFunctions),
-            currentTransaction(other.currentTransaction)
+            pragma(*this),
+            limit(*this)
             {}
             
         protected:

From 1a1810adfc2f05cab907f324f95094777ea51468 Mon Sep 17 00:00:00 2001
From: Yevgeniy Zakharov <fnc12@me.com>
Date: Fri, 12 Oct 2018 15:09:56 +0300
Subject: [PATCH 11/63] Update TODO.md

---
 TODO.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/TODO.md b/TODO.md
index 9a45dcccc..aa257c0fa 100644
--- a/TODO.md
+++ b/TODO.md
@@ -14,9 +14,9 @@
 * busy handler https://sqlite.org/c3ref/busy_handler.html
 * CAST https://sqlite.org/lang_expr.html#castexpr
 * CREATE VIEW and other view operations https://sqlite.org/lang_createview.html
-* triggers
-* query static check for correct order (e.g. `GROUP BY` after `WHERE`)
-* column alias
-* `LEFT OUTER JOIN`
+* triggers
+* query static check for correct order (e.g. `GROUP BY` after `WHERE`)
+* column alias
+* `FULL OUTER JOIN`
 
 Please feel free to add any feature that isn't listed here and not implemented yet.

From 6612b3872bad8fc4a418c7495a90c34eecede7b1 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 30 Oct 2018 16:27:34 +0300
Subject: [PATCH 12/63] format fixes

---
 examples/collate.cpp            | 17 +++++------------
 examples/core_functions.cpp     | 13 ++++---------
 examples/cross_join.cpp         |  8 +++-----
 examples/date_time.cpp          |  6 ++----
 examples/enum_binding.cpp       | 10 +++-------
 examples/foreign_key.cpp        | 23 ++++++++---------------
 examples/multi_table_select.cpp | 25 ++++++++-----------------
 examples/select.cpp             | 16 +++++-----------
 8 files changed, 38 insertions(+), 80 deletions(-)

diff --git a/examples/collate.cpp b/examples/collate.cpp
index bc463afed..ba5a5cf02 100644
--- a/examples/collate.cpp
+++ b/examples/collate.cpp
@@ -23,19 +23,12 @@ int main(int argc, char** argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("collate.sqlite",
                                 make_table("users",
-                                           make_column("id",
-                                                       &User::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &User::name),
-                                           make_column("created_at",
-                                                       &User::createdAt)),
+                                           make_column("id", &User::id, primary_key()),
+                                           make_column("name", &User::name),
+                                           make_column("created_at", &User::createdAt)),
                                 make_table("foo",
-                                           make_column("text",
-                                                       &Foo::text,
-                                                       collate_nocase()),
-                                           make_column("baz",
-                                                       &Foo::baz)));
+                                           make_column("text", &Foo::text, collate_nocase()),
+                                           make_column("baz", &Foo::baz)));
     storage.sync_schema();
     storage.remove_all<User>();
     storage.remove_all<Foo>();
diff --git a/examples/core_functions.cpp b/examples/core_functions.cpp
index cc471f810..9426ae15b 100644
--- a/examples/core_functions.cpp
+++ b/examples/core_functions.cpp
@@ -19,15 +19,10 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("core_functions.sqlite",
                                 make_table("marvel",
-                                           make_column("id",
-                                                       &MarvelHero::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &MarvelHero::name),
-                                           make_column("abilities",
-                                                       &MarvelHero::abilities),
-                                           make_column("points",
-                                                       &MarvelHero::points)));
+                                           make_column("id",&MarvelHero::id, primary_key()),
+                                           make_column("name", &MarvelHero::name),
+                                           make_column("abilities", &MarvelHero::abilities),
+                                           make_column("points", &MarvelHero::points)));
     storage.sync_schema();
     
     storage.remove_all<MarvelHero>();
diff --git a/examples/cross_join.cpp b/examples/cross_join.cpp
index 4175f3ef8..aac22dd63 100644
--- a/examples/cross_join.cpp
+++ b/examples/cross_join.cpp
@@ -25,11 +25,9 @@ static auto initStorage(const std::string &path) {
     using namespace sqlite_orm;
     return make_storage(path,
                         make_table("ranks",
-                                   make_column("rank",
-                                               &Rank::rank)),
+                                   make_column("rank", &Rank::rank)),
                         make_table("suits",
-                                   make_column("suit",
-                                               &Suit::suit)));
+                                   make_column("suit", &Suit::suit)));
 }
 
 int main(int argc, char **argv) {
@@ -78,7 +76,7 @@ int main(int argc, char **argv) {
     //  ORDER BY suit;
     auto cards = storage.select(columns(&Rank::rank, &Suit::suit),
                                 cross_join<Suit>(),
-                                order_by(&Suit::suit));
+                                order_by(&Suit::suit)); //  cards is vector<tuple<string, string>>
     
     cout << "cards count = " << cards.size() << endl;
     for(auto card : cards) {
diff --git a/examples/date_time.cpp b/examples/date_time.cpp
index 0a063d186..4492a9a67 100644
--- a/examples/date_time.cpp
+++ b/examples/date_time.cpp
@@ -17,10 +17,8 @@ int main() {
     
     auto storage = make_storage("",
                                 make_table("datetime_text",
-                                           make_column("d1",
-                                                       &DatetimeText::d1),
-                                           make_column("d2",
-                                                       &DatetimeText::d2)));
+                                           make_column("d1", &DatetimeText::d1),
+                                           make_column("d2", &DatetimeText::d2)));
     storage.sync_schema();
     
     //  SELECT date('now');
diff --git a/examples/enum_binding.cpp b/examples/enum_binding.cpp
index 90f8af472..e1f0aafad 100644
--- a/examples/enum_binding.cpp
+++ b/examples/enum_binding.cpp
@@ -122,13 +122,9 @@ int main(int/* argc*/, char **/*argv*/) {
     using namespace sqlite_orm;
     auto storage = make_storage("",
                                 make_table("superheros",
-                                           make_column("id",
-                                                       &SuperHero::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &SuperHero::name),
-                                           make_column("gender",
-                                                       &SuperHero::gender)));
+                                           make_column("id", &SuperHero::id, primary_key()),
+                                           make_column("name", &SuperHero::name),
+                                           make_column("gender", &SuperHero::gender)));
     storage.sync_schema();
     storage.remove_all<SuperHero>();
 
diff --git a/examples/foreign_key.cpp b/examples/foreign_key.cpp
index d0dcdf2d4..05f1646c1 100644
--- a/examples/foreign_key.cpp
+++ b/examples/foreign_key.cpp
@@ -29,24 +29,17 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("foreign_key.sqlite",
                                 make_table("artist",
-                                           make_column("artistid",
-                                                       &Artist::artistId,
-                                                       primary_key()),
-                                           make_column("artistname",
-                                                       &Artist::artistName)),
+                                           make_column("artistid", &Artist::artistId, primary_key()),
+                                           make_column("artistname", &Artist::artistName)),
                                 make_table("track",
-                                           make_column("trackid",
-                                                       &Track::trackId,
-                                                       primary_key()),
-                                           make_column("trackname",
-                                                       &Track::trackName),
-                                           make_column("trackartist",
-                                                       &Track::trackArtist),
+                                           make_column("trackid", &Track::trackId,primary_key()),
+                                           make_column("trackname", &Track::trackName),
+                                           make_column("trackartist", &Track::trackArtist),
                                            foreign_key(&Track::trackArtist).references(&Artist::artistId)));
-    /*auto syncSchemaRes =*/ storage.sync_schema();
-    /*for(auto &p : syncSchemaRes) {
+    auto syncSchemaRes = storage.sync_schema();
+    for(auto &p : syncSchemaRes) {
         cout << p.first << " " << p.second << endl;
-    }*/
+    }
     
     storage.remove_all<Track>();
     storage.remove_all<Artist>();
diff --git a/examples/multi_table_select.cpp b/examples/multi_table_select.cpp
index d8a689a8b..bbea3c51d 100644
--- a/examples/multi_table_select.cpp
+++ b/examples/multi_table_select.cpp
@@ -28,24 +28,15 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("multi_table_select.sqlite",
                                 make_table("ReqEquip",
-                                           make_column("ReqNumber",
-                                                       &ReqEquip::reqNumber,
-                                                       primary_key()),
-                                           make_column("Requestor",
-                                                       &ReqEquip::requestor),
-                                           make_column("Auth",
-                                                       &ReqEquip::auth),
-                                           make_column("ReqDate",
-                                                       &ReqEquip::reqDate)),
+                                           make_column("ReqNumber", &ReqEquip::reqNumber, primary_key()),
+                                           make_column("Requestor", &ReqEquip::requestor),
+                                           make_column("Auth", &ReqEquip::auth),
+                                           make_column("ReqDate", &ReqEquip::reqDate)),
                                 make_table("ReqDetail",
-                                           make_column("ReqNumber",
-                                                       &ReqDetail::reqNumber),
-                                           make_column("StockNumber",
-                                                       &ReqDetail::stockNumber),
-                                           make_column("Quantity",
-                                                       &ReqDetail::quantity),
-                                           make_column("ItemCost",
-                                                       &ReqDetail::itemCost)));
+                                           make_column("ReqNumber", &ReqDetail::reqNumber),
+                                           make_column("StockNumber", &ReqDetail::stockNumber),
+                                           make_column("Quantity", &ReqDetail::quantity),
+                                           make_column("ItemCost", &ReqDetail::itemCost)));
     
     storage.sync_schema();
     storage.remove_all<ReqEquip>();
diff --git a/examples/select.cpp b/examples/select.cpp
index 73572b371..c27a554eb 100644
--- a/examples/select.cpp
+++ b/examples/select.cpp
@@ -22,17 +22,11 @@ using std::endl;
 int main(int argc, char **argv) {
     auto storage = make_storage("select.sqlite",
                                 make_table("COMPANY",
-                                           make_column("ID",
-                                                       &Employee::id,
-                                                       primary_key()),
-                                           make_column("NAME",
-                                                       &Employee::name),
-                                           make_column("AGE",
-                                                       &Employee::age),
-                                           make_column("ADDRESS",
-                                                       &Employee::address),
-                                           make_column("SALARY",
-                                                       &Employee::salary)));
+                                           make_column("ID", &Employee::id, primary_key()),
+                                           make_column("NAME", &Employee::name),
+                                           make_column("AGE", &Employee::age),
+                                           make_column("ADDRESS", &Employee::address),
+                                           make_column("SALARY", &Employee::salary)));
     storage.sync_schema();
     storage.remove_all<Employee>(); //  remove all old employees in case they exist in db..
     

From a82423a86457a476fd40b6565521ca4df571d5fe Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Wed, 31 Oct 2018 19:44:39 +0300
Subject: [PATCH 13/63] fixed merge from master

---
 dev/aggregate_functions.h       |  9 +++++++-
 dev/alias.h                     |  6 +++---
 dev/column_result.h             |  4 ++--
 dev/select_constraints.h        | 14 +++++++++++--
 dev/storage.h                   |  6 +++---
 include/sqlite_orm/sqlite_orm.h | 37 ++++++++++++++++++++++++---------
 tests/tests.cpp                 |  2 +-
 7 files changed, 56 insertions(+), 22 deletions(-)

diff --git a/dev/aggregate_functions.h b/dev/aggregate_functions.h
index b0effbbbb..d5003bb8e 100644
--- a/dev/aggregate_functions.h
+++ b/dev/aggregate_functions.h
@@ -22,7 +22,14 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  T is use to specify type explicitly for queries like
+         *  SELECT COUNT(*) FROM table_name;
+         *  T can be omitted with void.
+         */
+        template<class T>
         struct count_asterisk_t {
+            using type = T;
             
             operator std::string() const {
                 return "COUNT";
@@ -105,7 +112,7 @@ namespace sqlite_orm {
     inline aggregate_functions::count_asterisk_without_type count() {
         return {};
     }
-
+    
     template<class T>
     aggregate_functions::count_asterisk_t<T> count() {
         return {};
diff --git a/dev/alias.h b/dev/alias.h
index 1bc786c58..26a866cd4 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -31,10 +31,10 @@ namespace sqlite_orm {
         };
         
         template<class T, class SFINAE = void>
-        struct alias_exractor;
+        struct alias_extractor;
         
         template<class T>
-        struct alias_exractor<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
+        struct alias_extractor<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
             static std::string get() {
                 std::stringstream ss;
                 ss << T::get();
@@ -43,7 +43,7 @@ namespace sqlite_orm {
         };
         
         template<class T>
-        struct alias_exractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
+        struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
             static std::string get() {
                 return {};
             }
diff --git a/dev/column_result.h b/dev/column_result.h
index 2a0dce943..a3ab56cc3 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -136,8 +136,8 @@ namespace sqlite_orm {
             using type = int;
         };
         
-        template<>
-        struct column_result_t<aggregate_functions::count_asterisk_t, void> {
+        template<class T>
+        struct column_result_t<aggregate_functions::count_asterisk_t<T>, void> {
             using type = int;
         };
         
diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index bd1bf5555..fab831cfe 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -157,8 +157,8 @@ namespace sqlite_orm {
             
             union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {}
             
-            union_t(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
-
+            union_t(left_type l, right_type r): union_t(std::move(l), std::move(r), false) {}
+            
             operator std::string() const {
                 if(!this->all){
                     return "UNION";
@@ -212,6 +212,11 @@ namespace sqlite_orm {
         bool get_distinct(const columns_t<Args...> &cols) {
             return cols.distinct;
         }
+        
+        template<class T>
+        struct asterisk_t {
+            using type = T;
+        };
     }
     
     template<class T>
@@ -296,4 +301,9 @@ namespace sqlite_orm {
     internal::union_t<L, R> union_all(L lhs, R rhs) {
         return {std::move(lhs), std::move(rhs), true};
     }
+    
+    template<class T>
+    internal::asterisk_t<T> asterisk() {
+        return {};
+    }
 }
diff --git a/dev/storage.h b/dev/storage.h
index ffcd65a5f..3738d78c5 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -1040,7 +1040,7 @@ namespace sqlite_orm {
                     using original_join_type = typename decltype(c)::type;
                     using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
                     auto crossJoinedTableName = this->impl.template find_table_name<cross_join_type>();
-                    auto tableAliasString = alias_exractor<original_join_type>::get();
+                    auto tableAliasString = alias_extractor<original_join_type>::get();
                     if(!tableAliasString.length()){
                         tableNamesSet.erase(crossJoinedTableName);
                     }
@@ -1213,7 +1213,7 @@ namespace sqlite_orm {
             template<class T, class O>
             void process_single_condition(std::stringstream &ss, const conditions::inner_join_t<T, O> &l) {
                 ss << static_cast<std::string>(l) << " ";
-                auto aliasString = alias_exractor<T>::get();
+                auto aliasString = alias_extractor<T>::get();
                 ss << " '" << this->impl.template find_table_name<typename mapped_type_proxy<T>::type>() << "' ";
                 if(aliasString.length()){
                     ss << "'" << aliasString << "' ";
@@ -2130,7 +2130,7 @@ namespace sqlite_orm {
             template<class O, class ...Args, class R = typename mapped_type_proxy<O>::type>
             int count(Args&& ...args) {
                 this->assert_mapped_type<R>();
-                auto tableAliasString = alias_exractor<O>::get();
+                auto tableAliasString = alias_extractor<O>::get();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<R>();
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index e55988ad8..adcdfee8c 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2262,10 +2262,10 @@ namespace sqlite_orm {
         };
         
         template<class T, class SFINAE = void>
-        struct alias_exractor;
+        struct alias_extractor;
         
         template<class T>
-        struct alias_exractor<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
+        struct alias_extractor<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
             static std::string get() {
                 std::stringstream ss;
                 ss << T::get();
@@ -2274,7 +2274,7 @@ namespace sqlite_orm {
         };
         
         template<class T>
-        struct alias_exractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
+        struct alias_extractor<T, typename std::enable_if<!std::is_base_of<alias_tag, T>::value>::type> {
             static std::string get() {
                 return {};
             }
@@ -2842,7 +2842,14 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  T is use to specify type explicitly for queries like
+         *  SELECT COUNT(*) FROM table_name;
+         *  T can be omitted with void.
+         */
+        template<class T>
         struct count_asterisk_t {
+            using type = T;
             
             operator std::string() const {
                 return "COUNT";
@@ -3149,8 +3156,8 @@ namespace sqlite_orm {
             
             union_t(left_type l, right_type r, decltype(all) all_): super(std::move(l), std::move(r)), all(all_) {}
             
-            union_t(left_type l, right_type r): left(std::move(l)), right(std::move(r)) {}
-
+            union_t(left_type l, right_type r): union_t(std::move(l), std::move(r), false) {}
+            
             operator std::string() const {
                 if(!this->all){
                     return "UNION";
@@ -3204,6 +3211,11 @@ namespace sqlite_orm {
         bool get_distinct(const columns_t<Args...> &cols) {
             return cols.distinct;
         }
+        
+        template<class T>
+        struct asterisk_t {
+            using type = T;
+        };
     }
     
     template<class T>
@@ -3288,6 +3300,11 @@ namespace sqlite_orm {
     internal::union_t<L, R> union_all(L lhs, R rhs) {
         return {std::move(lhs), std::move(rhs), true};
     }
+    
+    template<class T>
+    internal::asterisk_t<T> asterisk() {
+        return {};
+    }
 }
 #pragma once
 
@@ -4205,8 +4222,8 @@ namespace sqlite_orm {
             using type = int;
         };
         
-        template<>
-        struct column_result_t<aggregate_functions::count_asterisk_t, void> {
+        template<class T>
+        struct column_result_t<aggregate_functions::count_asterisk_t<T>, void> {
             using type = int;
         };
         
@@ -6484,7 +6501,7 @@ namespace sqlite_orm {
                     using original_join_type = typename decltype(c)::type;
                     using cross_join_type = typename internal::mapped_type_proxy<original_join_type>::type;
                     auto crossJoinedTableName = this->impl.template find_table_name<cross_join_type>();
-                    auto tableAliasString = alias_exractor<original_join_type>::get();
+                    auto tableAliasString = alias_extractor<original_join_type>::get();
                     if(!tableAliasString.length()){
                         tableNamesSet.erase(crossJoinedTableName);
                     }
@@ -6657,7 +6674,7 @@ namespace sqlite_orm {
             template<class T, class O>
             void process_single_condition(std::stringstream &ss, const conditions::inner_join_t<T, O> &l) {
                 ss << static_cast<std::string>(l) << " ";
-                auto aliasString = alias_exractor<T>::get();
+                auto aliasString = alias_extractor<T>::get();
                 ss << " '" << this->impl.template find_table_name<typename mapped_type_proxy<T>::type>() << "' ";
                 if(aliasString.length()){
                     ss << "'" << aliasString << "' ";
@@ -7574,7 +7591,7 @@ namespace sqlite_orm {
             template<class O, class ...Args, class R = typename mapped_type_proxy<O>::type>
             int count(Args&& ...args) {
                 this->assert_mapped_type<R>();
-                auto tableAliasString = alias_exractor<O>::get();
+                auto tableAliasString = alias_extractor<O>::get();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<R>();
diff --git a/tests/tests.cpp b/tests/tests.cpp
index cb53fcfa2..e0a0c9303 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -212,8 +212,8 @@ void testExplicitColumns() {
     assert(storage.table_exists("users"));
     assert(storage.table_exists("tokens"));
     
-    storage.remove_all<User>();
     storage.remove_all<Token>();
+    storage.remove_all<User>();
     
     auto brunoId = storage.insert(User{0, "Bruno"});
     auto zeddId = storage.insert(User{0, "Zedd"});

From 3c5854ffaa73fc0621d6a2eb4237b7a5e706374c Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sat, 24 Nov 2018 17:53:26 +0300
Subject: [PATCH 14/63] added quotes for index name and column name

---
 dev/storage.h                   |  4 +-
 examples/exists.cpp             |  5 ++-
 include/sqlite_orm/sqlite_orm.h |  4 +-
 tests/tests.cpp                 | 78 ++++++++++++++++++++++++---------
 4 files changed, 65 insertions(+), 26 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index 981cad6ab..e57101a66 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -2832,13 +2832,13 @@ namespace sqlite_orm {
                 using columns_type = typename decltype(impl->table)::columns_type;
                 using head_t = typename std::tuple_element<0, columns_type>::type;
                 using indexed_type = typename internal::table_type<head_t>::type;
-                ss << "INDEX IF NOT EXISTS " << impl->table.name << " ON '" << this->impl.template find_table_name<indexed_type>() << "' ( ";
+                ss << "INDEX IF NOT EXISTS '" << impl->table.name << "' ON '" << this->impl.template find_table_name<indexed_type>() << "' ( ";
                 std::vector<std::string> columnNames;
                 tuple_helper::iterator<std::tuple_size<columns_type>::value - 1, Cols...>()(impl->table.columns, [&columnNames, this](auto &v){
                     columnNames.push_back(this->impl.column_name(v));
                 });
                 for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << columnNames[i];
+                    ss << "'" << columnNames[i] << "'";
                     if(i < columnNames.size() - 1) {
                         ss << ",";
                     }
diff --git a/examples/exists.cpp b/examples/exists.cpp
index 6649e9121..858b341cd 100644
--- a/examples/exists.cpp
+++ b/examples/exists.cpp
@@ -71,7 +71,8 @@ int main(int argc, char **argv) {
                                            make_column("ADVANCE_AMOUNT", &Order::advanceAmount),
                                            make_column("ORD_DATE", &Order::date),
                                            make_column("CUST_CODE", &Order::custCode),
-                                           make_column("AGENT_CODE", &Order::agentCode)));
+                                           make_column("AGENT_CODE", &Order::agentCode)),
+                                make_trigger("update_examlog", );
     storage.sync_schema();
     storage.remove_all<Order>();
     storage.remove_all<Agent>();
@@ -158,7 +159,7 @@ int main(int argc, char **argv) {
         //      (SELECT *
         //      FROM customer
         //      WHERE grade=3 AND agents.agent_code=customer.agent_code)
-        //      ORDER BY commission;
+        //  ORDER BY commission;
         auto rows = storage.select(columns(&Agent::code, &Agent::name, &Agent::workingArea, &Agent::comission),
                                    where(exists(select(asterisk<Customer>(),
                                                        where(is_equal(&Customer::grade, 3) and is_equal(&Agent::code, &Customer::agentCode))))),
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index aa91379ba..210c55a98 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -8838,13 +8838,13 @@ namespace sqlite_orm {
                 using columns_type = typename decltype(impl->table)::columns_type;
                 using head_t = typename std::tuple_element<0, columns_type>::type;
                 using indexed_type = typename internal::table_type<head_t>::type;
-                ss << "INDEX IF NOT EXISTS " << impl->table.name << " ON '" << this->impl.template find_table_name<indexed_type>() << "' ( ";
+                ss << "INDEX IF NOT EXISTS '" << impl->table.name << "' ON '" << this->impl.template find_table_name<indexed_type>() << "' ( ";
                 std::vector<std::string> columnNames;
                 tuple_helper::iterator<std::tuple_size<columns_type>::value - 1, Cols...>()(impl->table.columns, [&columnNames, this](auto &v){
                     columnNames.push_back(this->impl.column_name(v));
                 });
                 for(size_t i = 0; i < columnNames.size(); ++i) {
-                    ss << columnNames[i];
+                    ss << "'" << columnNames[i] << "'";
                     if(i < columnNames.size() - 1) {
                         ss << ",";
                     }
diff --git a/tests/tests.cpp b/tests/tests.cpp
index b591891ee..0dd8afb06 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -21,30 +21,53 @@ void testThreadsafe() {
 
 void testIn() {
     cout << __func__ << endl;
-    
-    struct User {
-        int id;
-    };
-    
-    auto storage = make_storage("",
-                                make_table("users",
-                                           make_column("id", &User::id, primary_key())));
-    storage.sync_schema();
-    storage.replace(User{ 1 });
-    storage.replace(User{ 2 });
-    storage.replace(User{ 3 });
-    
     {
-        auto rows = storage.get_all<User>(where(in(&User::id, {1, 2, 3})));
-        assert(rows.size() == 3);
+        struct User {
+            int id;
+        };
+        
+        auto storage = make_storage("",
+                                    make_table("users",
+                                               make_column("id", &User::id, primary_key())));
+        storage.sync_schema();
+        storage.replace(User{ 1 });
+        storage.replace(User{ 2 });
+        storage.replace(User{ 3 });
+        
+        {
+            auto rows = storage.get_all<User>(where(in(&User::id, {1, 2, 3})));
+            assert(rows.size() == 3);
+        }
+        {
+            std::vector<int> inArgument;
+            inArgument.push_back(1);
+            inArgument.push_back(2);
+            inArgument.push_back(3);
+            auto rows = storage.get_all<User>(where(in(&User::id, inArgument)));
+            assert(rows.size() == 3);
+        }
     }
     {
-        std::vector<int> inArgument;
-        inArgument.push_back(1);
-        inArgument.push_back(2);
-        inArgument.push_back(3);
-        auto rows = storage.get_all<User>(where(in(&User::id, inArgument)));
+        struct Letter {
+            int id;
+            std::string name;
+        };
+        auto storage = make_storage("",
+                                    make_table("letters",
+                                               make_column("id", &Letter::id, primary_key()),
+                                               make_column("name", &Letter::name)));
+        storage.sync_schema();
+        
+        storage.replace(Letter{1, "A"});
+        storage.replace(Letter{2, "B"});
+        storage.replace(Letter{3, "C"});
+        
+        auto letters = storage.get_all<Letter>(where(in(&Letter::id, {1, 2, 3})));
+        assert(letters.size() == 3);
+        auto rows = storage.select(columns(&Letter::name), where(in(&Letter::id, {1, 2, 3})));
         assert(rows.size() == 3);
+        auto rows2 = storage.select(&Letter::name, where(in(&Letter::id, {1, 2, 3})));
+        assert(rows2.size() == 3);
     }
 }
 
@@ -2205,6 +2228,19 @@ void testRowId() {
     }
 }
 
+void testEscapedIndexName() {
+    cout << __func__ << endl;
+    
+    struct User{
+        std::string group;
+    };
+    auto storage = make_storage("index_group.sqlite",
+                                make_index("index", &User::group),
+                                make_table("users",
+                                           make_column("group", &User::group)));
+    storage.sync_schema();
+}
+
 int main(int argc, char **argv) {
 
     cout << "version = " << make_storage("").libversion() << endl;
@@ -2286,4 +2322,6 @@ int main(int argc, char **argv) {
     testIn();
     
     testJournalMode();
+    
+    testEscapedIndexName();
 }

From 6b0a4b9f3d3b6138dad187f53179db9cbe2a4c9c Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sat, 24 Nov 2018 23:38:11 +0300
Subject: [PATCH 15/63] fixed exists example

---
 examples/exists.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/exists.cpp b/examples/exists.cpp
index 858b341cd..d063caf42 100644
--- a/examples/exists.cpp
+++ b/examples/exists.cpp
@@ -71,8 +71,7 @@ int main(int argc, char **argv) {
                                            make_column("ADVANCE_AMOUNT", &Order::advanceAmount),
                                            make_column("ORD_DATE", &Order::date),
                                            make_column("CUST_CODE", &Order::custCode),
-                                           make_column("AGENT_CODE", &Order::agentCode)),
-                                make_trigger("update_examlog", );
+                                           make_column("AGENT_CODE", &Order::agentCode)));
     storage.sync_schema();
     storage.remove_all<Order>();
     storage.remove_all<Agent>();

From 8664a3fe8ff04d4cd5c00e3db204c579e882b2a3 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Thu, 13 Dec 2018 10:18:32 +0300
Subject: [PATCH 16/63] format improvements

---
 dev/constraints.h               |  2 +-
 dev/storage.h                   | 18 ++++++++----------
 include/sqlite_orm/sqlite_orm.h | 20 +++++++++-----------
 tests/tests.cpp                 | 25 ++++++++-----------------
 4 files changed, 26 insertions(+), 39 deletions(-)

diff --git a/dev/constraints.h b/dev/constraints.h
index d4cf6b8ab..3dbaec446 100644
--- a/dev/constraints.h
+++ b/dev/constraints.h
@@ -82,7 +82,7 @@ namespace sqlite_orm {
          */
         template<class T>
         struct default_t {
-            typedef T value_type;
+            using value_type = T;
             
             value_type value;
             
diff --git a/dev/storage.h b/dev/storage.h
index e57101a66..329872a32 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -1328,29 +1328,27 @@ namespace sqlite_orm {
                 for(size_t i = 0; i < setColumnNames.size(); ++i) {
                     ss << "\"" << setColumnNames[i] << "\"" << " = ?";
                     if(i < setColumnNames.size() - 1) {
-                        ss << ", ";
-                    }else{
-                        ss << " ";
+                        ss << ",";
                     }
+                    ss << " ";
                 }
                 ss << "WHERE ";
                 auto primaryKeyColumnNames = impl.table.primary_key_column_names();
                 for(size_t i = 0; i < primaryKeyColumnNames.size(); ++i) {
                     ss << "\"" << primaryKeyColumnNames[i] << "\"" << " = ?";
                     if(i < primaryKeyColumnNames.size() - 1) {
-                        ss << " AND ";
-                    }else{
-                        ss << " ";
+                        ss << " AND";
                     }
+                    ss << " ";
                 }
                 auto query = ss.str();
                 sqlite3_stmt *stmt;
                 if (sqlite3_prepare_v2(connection->get_db(), query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
                     statement_finalizer finalizer{stmt};
                     auto index = 1;
-                    impl.table.for_each_column([&o, stmt, &index] (auto c) {
+                    impl.table.for_each_column([&o, stmt, &index] (auto &c) {
                         if(!c.template has<constraints::primary_key_t<>>()) {
-                            using field_type = typename decltype(c)::field_type;
+                            using field_type = typename std::decay<decltype(c)>::type::field_type;
                             const field_type *value = nullptr;
                             if(c.member_pointer){
                                 value = &(o.*c.member_pointer);
@@ -1360,9 +1358,9 @@ namespace sqlite_orm {
                             statement_binder<field_type>().bind(stmt, index++, *value);
                         }
                     });
-                    impl.table.for_each_column([&o, stmt, &index] (auto c) {
+                    impl.table.for_each_column([&o, stmt, &index] (auto &c) {
                         if(c.template has<constraints::primary_key_t<>>()) {
-                            typedef typename decltype(c)::field_type field_type;
+                            using field_type = typename std::decay<decltype(c)>::type::field_type;
                             const field_type *value = nullptr;
                             if(c.member_pointer){
                                 value = &(o.*c.member_pointer);
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 210c55a98..17ced9af2 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -482,7 +482,7 @@ namespace sqlite_orm {
          */
         template<class T>
         struct default_t {
-            typedef T value_type;
+            using value_type = T;
             
             value_type value;
             
@@ -7334,29 +7334,27 @@ namespace sqlite_orm {
                 for(size_t i = 0; i < setColumnNames.size(); ++i) {
                     ss << "\"" << setColumnNames[i] << "\"" << " = ?";
                     if(i < setColumnNames.size() - 1) {
-                        ss << ", ";
-                    }else{
-                        ss << " ";
+                        ss << ",";
                     }
+                    ss << " ";
                 }
                 ss << "WHERE ";
                 auto primaryKeyColumnNames = impl.table.primary_key_column_names();
                 for(size_t i = 0; i < primaryKeyColumnNames.size(); ++i) {
                     ss << "\"" << primaryKeyColumnNames[i] << "\"" << " = ?";
                     if(i < primaryKeyColumnNames.size() - 1) {
-                        ss << " AND ";
-                    }else{
-                        ss << " ";
+                        ss << " AND";
                     }
+                    ss << " ";
                 }
                 auto query = ss.str();
                 sqlite3_stmt *stmt;
                 if (sqlite3_prepare_v2(connection->get_db(), query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
                     statement_finalizer finalizer{stmt};
                     auto index = 1;
-                    impl.table.for_each_column([&o, stmt, &index] (auto c) {
+                    impl.table.for_each_column([&o, stmt, &index] (auto &c) {
                         if(!c.template has<constraints::primary_key_t<>>()) {
-                            using field_type = typename decltype(c)::field_type;
+                            using field_type = typename std::decay<decltype(c)>::type::field_type;
                             const field_type *value = nullptr;
                             if(c.member_pointer){
                                 value = &(o.*c.member_pointer);
@@ -7366,9 +7364,9 @@ namespace sqlite_orm {
                             statement_binder<field_type>().bind(stmt, index++, *value);
                         }
                     });
-                    impl.table.for_each_column([&o, stmt, &index] (auto c) {
+                    impl.table.for_each_column([&o, stmt, &index] (auto &c) {
                         if(c.template has<constraints::primary_key_t<>>()) {
-                            typedef typename decltype(c)::field_type field_type;
+                            using field_type = typename std::decay<decltype(c)>::type::field_type;
                             const field_type *value = nullptr;
                             if(c.member_pointer){
                                 value = &(o.*c.member_pointer);
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 0dd8afb06..7ee17fa8c 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1898,29 +1898,20 @@ void testDefaultValue() {
 
     auto storage1 = make_storage("test_db.sqlite",
                                  make_table("User",
-                                            make_column("Id",
-                                                        &User::userId,
-                                                        primary_key()),
-                                            make_column("Name",
-                                                        &User::name),
-                                            make_column("Age",
-                                                        &User::age)));
+                                            make_column("Id", &User::userId, primary_key()),
+                                            make_column("Name", &User::name),
+                                            make_column("Age", &User::age)));
     storage1.sync_schema();
     storage1.remove_all<User>();
 
     auto storage2 = make_storage("test_db.sqlite",
                                  make_table("User",
-                                            make_column("Id",
-                                                        &User::userId,
-                                                        primary_key()),
-                                            make_column("Name",
-                                                        &User::name),
-                                            make_column("Age",
-                                                        &User::age),
-                                            make_column("Email",
-                                                        &User::email,
-                                                        default_value("example@email.com"))));
+                                            make_column("Id", &User::userId, primary_key()),
+                                            make_column("Name", &User::name),
+                                            make_column("Age", &User::age),
+                                            make_column("Email", &User::email, default_value("example@email.com"))));
     storage2.sync_schema();
+    storage2.insert(User{0, "Tom", 15});
 }
 
 //  after #18

From aff11e940683c6e36e7b43baac1952ae74c7c479 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Thu, 13 Dec 2018 13:21:54 +0300
Subject: [PATCH 17/63] added static tests for select result

---
 tests/static_tests.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index ee00a7573..387392233 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -230,6 +230,18 @@ int main() {
     //  this call is important - it tests compilation in inner storage_t::serialize_column_schema function
     storage.sync_schema();
     
+    {
+        using SelectVectorInt = decltype(storage.select(&User::id));
+        static_assert(std::is_same<SelectVectorInt, std::vector<int>>::value, "Incorrect select id vector type");
+        
+        using SelectVectorTuple = decltype(storage.select(columns(&User::id)));
+        auto ids = storage.select(columns(&User::id));
+        static_assert(std::is_same<decltype(ids), SelectVectorTuple>::value, "");
+        static_assert(std::is_same<SelectVectorTuple, std::vector<std::tuple<int>>>::value, "Incorrect select id vector type");
+        using IdsTuple = SelectVectorTuple::value_type;
+        static_assert(std::tuple_size<IdsTuple>::value == 1, "Incorrect tuple size");
+    }
+    
     
     return 0;
 }

From 490ffe8e101e424935eda74699ea1f07dcca1550 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sat, 15 Dec 2018 17:33:49 +0300
Subject: [PATCH 18/63] added foreign composite key support

---
 dev/constraints.h               | 43 ++++++++++------
 dev/storage.h                   | 49 +++++++++++++++---
 examples/composite_key.cpp      | 34 ++++++-------
 examples/foreign_key.cpp        |  2 +-
 include/sqlite_orm/sqlite_orm.h | 90 ++++++++++++++++++++++++---------
 5 files changed, 153 insertions(+), 65 deletions(-)

diff --git a/dev/constraints.h b/dev/constraints.h
index 3dbaec446..c3441d869 100644
--- a/dev/constraints.h
+++ b/dev/constraints.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <string>   //  std::string
-#include <tuple>    //  std::tuple
+#include <tuple>    //  std::tuple, std::make_tuple
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::is_base_of, std::false_type, std::true_type
 
@@ -105,16 +105,25 @@ namespace sqlite_orm {
         
         /**
          *  FOREIGN KEY constraint class.
-         *  C is column which has foreign key
-         *  R is column which C references to
+         *  Cs are columns which has foreign key
+         *  Rs are column which C references to
          *  Available in SQLite 3.6.19 or higher
          */
-        template<class C, class R>
-        struct foreign_key_t {
-            C m = nullptr;
-            R r = nullptr;
+        
+        template<class A, class B>
+        struct foreign_key_t;
+        
+        template<class ...Cs, class ...Rs>
+        struct foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> {
+            using columns_type = std::tuple<Cs...>;
+            using references_type = std::tuple<Rs...>;
+            
+            columns_type columns;
+            references_type references;
             
-            foreign_key_t(C m_, R r_): m(m_), r(r_) {}
+            static_assert(std::tuple_size<columns_type>::value == std::tuple_size<references_type>::value, "Columns size must be equal to references tuple");
+            
+            foreign_key_t(columns_type columns_, references_type references_): columns(std::move(columns_)), references(std::move(references_)) {}
             
             using field_type = void;    //  for column iteration. Better be deleted
             using constraints_type = std::tuple<>;
@@ -129,20 +138,22 @@ namespace sqlite_orm {
         };
         
         /**
-         *  C can be a class member pointer, a getter function member pointer or setter
+         *  Cs can be a class member pointer, a getter function member pointer or setter
          *  func member pointer
          *  Available in SQLite 3.6.19 or higher
          */
-        template<class C>
+        template<class ...Cs>
         struct foreign_key_intermediate_t {
-            C m = nullptr;
+            using tuple_type = std::tuple<Cs...>;
+            
+            tuple_type columns;
             
-            foreign_key_intermediate_t(C m_): m(m_) {}
+            foreign_key_intermediate_t(tuple_type columns_): columns(std::move(columns_)) {}
             
-            template<class T>
-            foreign_key_t<C, T> references(T t) {
-                using ret_type = foreign_key_t<C, T>;
-                return ret_type(this->m, t);
+            template<class ...Rs>
+            foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> references(Rs ...references) {
+                using ret_type = foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>>;
+                return ret_type(std::move(this->columns), std::make_tuple(std::forward<Rs>(references)...));
             }
         };
 #endif
diff --git a/dev/storage.h b/dev/storage.h
index 329872a32..0127474ca 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -303,14 +303,47 @@ namespace sqlite_orm {
             
 #if SQLITE_VERSION_NUMBER >= 3006019
             
-            template<class C, class R>
-            std::string serialize_column_schema(constraints::foreign_key_t<C, R> &fk) {
-                std::stringstream ss;
-                using ref_type = typename internal::table_type<decltype(fk.r)>::type;
-                auto refTableName = this->impl.template find_table_name<ref_type>();
-                auto refColumnName = this->impl.column_name(fk.r);
-                ss << "FOREIGN KEY(" << this->impl.column_name(fk.m) << ") REFERENCES ";
-                ss << refTableName << "(" << refColumnName << ") ";
+            template<class ...Cs, class ...Rs>
+            std::string serialize_column_schema(constraints::foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> &fk) {
+                std::stringstream ss;
+                std::vector<std::string> columnNames;
+                using columns_type_t = typename std::decay<decltype(fk)>::type::columns_type;
+                constexpr const int columnsCount = std::tuple_size<columns_type_t>::value;
+                columnNames.reserve(columnsCount);
+                tuple_helper::iterator<columnsCount - 1, Cs...>()(fk.columns, [&columnNames, this](auto &v){
+                    columnNames.push_back(this->impl.column_name(v));
+                });
+                ss << "FOREIGN KEY( ";
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNames.size() - 1){
+                        ss << ",";
+                    }
+                    ss << " ";
+                }
+                ss << ") REFERENCES ";
+                std::vector<std::string> referencesNames;
+                using references_type_t = typename std::decay<decltype(fk)>::type::references_type;
+                constexpr const int referencesCount = std::tuple_size<references_type_t>::value;
+                referencesNames.reserve(referencesCount);
+                {
+                    using first_reference_t = typename std::tuple_element<0, references_type_t>::type;
+                    using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
+                    auto refTableName = this->impl.template find_table_name<first_reference_mapped_type>();
+                    ss << refTableName << " ";
+                }
+                tuple_helper::iterator<referencesCount - 1, Rs...>()(fk.references, [&referencesNames, this](auto &v){
+                    referencesNames.push_back(this->impl.column_name(v));
+                });
+                ss << "( ";
+                for(size_t i = 0; i < referencesNames.size(); ++i){
+                    ss << referencesNames[i];
+                    if(i < referencesNames.size() - 1){
+                        ss << ",";
+                    }
+                    ss << " ";
+                }
+                ss << ") ";
                 return ss.str();
             }
 #endif
diff --git a/examples/composite_key.cpp b/examples/composite_key.cpp
index 33d0ccb25..1d0aef2f8 100644
--- a/examples/composite_key.cpp
+++ b/examples/composite_key.cpp
@@ -3,6 +3,7 @@
 #include <string>
 #include <iostream>
 #include <sqlite_orm/sqlite_orm.h>
+#include <sys/time.h>
 
 using std::cout;
 using std::endl;
@@ -13,18 +14,25 @@ struct User {
     std::string lastName;
 };
 
+struct UserVisit {
+    int userId;
+    std::string userFirstName;
+    time_t time;
+};
+
 int main() {
     using namespace sqlite_orm;
     
     auto storage = make_storage("",
                                 make_table("users",
-                                           make_column("id",
-                                                       &User::id),
-                                           make_column("first_name",
-                                                       &User::firstName),
-                                           make_column("last_name",
-                                                       &User::lastName),
-                                           primary_key(&User::id, &User::firstName)));
+                                           make_column("id", &User::id),
+                                           make_column("first_name", &User::firstName),
+                                           make_column("last_name", &User::lastName),
+                                           primary_key(&User::id, &User::firstName)),
+                                make_table("visits",
+                                           make_column("user_id", &UserVisit::userId),
+                                           make_column("user_first_name", &UserVisit::userFirstName),
+                                           make_column("time", &UserVisit::time)));
     storage.sync_schema();
     
     storage.replace(User{
@@ -37,19 +45,11 @@ int main() {
     auto bebeRexhaMaybe = storage.get_no_throw<User>(1, "Bebe");
     try{
         //  2 and 'Drake' values will be ignored cause they are primary keys
-        storage.insert(User{
-            2,
-            "Drake",
-            "Singer",
-        });
+        storage.insert(User{ 2, "Drake", "Singer" });
     }catch(std::system_error e){
         cout << "exception = " << e.what() << endl;
     }
-    storage.replace(User{
-        2,
-        "The Weeknd",
-        "Singer",
-    });
+    storage.replace(User{ 2, "The Weeknd", "Singer" });
     auto weeknd = storage.get<User>(2, "The Weeknd");
     cout << "weeknd = " << storage.dump(weeknd) << endl;
     return 0;
diff --git a/examples/foreign_key.cpp b/examples/foreign_key.cpp
index 05f1646c1..bf0ac07cf 100644
--- a/examples/foreign_key.cpp
+++ b/examples/foreign_key.cpp
@@ -32,7 +32,7 @@ int main(int argc, char **argv) {
                                            make_column("artistid", &Artist::artistId, primary_key()),
                                            make_column("artistname", &Artist::artistName)),
                                 make_table("track",
-                                           make_column("trackid", &Track::trackId,primary_key()),
+                                           make_column("trackid", &Track::trackId, primary_key()),
                                            make_column("trackname", &Track::trackName),
                                            make_column("trackartist", &Track::trackArtist),
                                            foreign_key(&Track::trackArtist).references(&Artist::artistId)));
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 17ced9af2..f2aef4f1e 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -401,7 +401,7 @@ namespace sqlite_orm {
 #pragma once
 
 #include <string>   //  std::string
-#include <tuple>    //  std::tuple
+#include <tuple>    //  std::tuple, std::make_tuple
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::is_base_of, std::false_type, std::true_type
 
@@ -505,16 +505,25 @@ namespace sqlite_orm {
         
         /**
          *  FOREIGN KEY constraint class.
-         *  C is column which has foreign key
-         *  R is column which C references to
+         *  Cs are columns which has foreign key
+         *  Rs are column which C references to
          *  Available in SQLite 3.6.19 or higher
          */
-        template<class C, class R>
-        struct foreign_key_t {
-            C m = nullptr;
-            R r = nullptr;
+        
+        template<class A, class B>
+        struct foreign_key_t;
+        
+        template<class ...Cs, class ...Rs>
+        struct foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> {
+            using columns_type = std::tuple<Cs...>;
+            using references_type = std::tuple<Rs...>;
+            
+            columns_type columns;
+            references_type references;
             
-            foreign_key_t(C m_, R r_): m(m_), r(r_) {}
+            static_assert(std::tuple_size<columns_type>::value == std::tuple_size<references_type>::value, "Columns size must be equal to references tuple");
+            
+            foreign_key_t(columns_type columns_, references_type references_): columns(std::move(columns_)), references(std::move(references_)) {}
             
             using field_type = void;    //  for column iteration. Better be deleted
             using constraints_type = std::tuple<>;
@@ -529,20 +538,22 @@ namespace sqlite_orm {
         };
         
         /**
-         *  C can be a class member pointer, a getter function member pointer or setter
+         *  Cs can be a class member pointer, a getter function member pointer or setter
          *  func member pointer
          *  Available in SQLite 3.6.19 or higher
          */
-        template<class C>
+        template<class ...Cs>
         struct foreign_key_intermediate_t {
-            C m = nullptr;
+            using tuple_type = std::tuple<Cs...>;
             
-            foreign_key_intermediate_t(C m_): m(m_) {}
+            tuple_type columns;
             
-            template<class T>
-            foreign_key_t<C, T> references(T t) {
-                using ret_type = foreign_key_t<C, T>;
-                return ret_type(this->m, t);
+            foreign_key_intermediate_t(tuple_type columns_): columns(std::move(columns_)) {}
+            
+            template<class ...Rs>
+            foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> references(Rs ...references) {
+                using ret_type = foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>>;
+                return ret_type(std::move(this->columns), std::make_tuple(std::forward<Rs>(references)...));
             }
         };
 #endif
@@ -6309,14 +6320,47 @@ namespace sqlite_orm {
             
 #if SQLITE_VERSION_NUMBER >= 3006019
             
-            template<class C, class R>
-            std::string serialize_column_schema(constraints::foreign_key_t<C, R> &fk) {
+            template<class ...Cs, class ...Rs>
+            std::string serialize_column_schema(constraints::foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> &fk) {
                 std::stringstream ss;
-                using ref_type = typename internal::table_type<decltype(fk.r)>::type;
-                auto refTableName = this->impl.template find_table_name<ref_type>();
-                auto refColumnName = this->impl.column_name(fk.r);
-                ss << "FOREIGN KEY(" << this->impl.column_name(fk.m) << ") REFERENCES ";
-                ss << refTableName << "(" << refColumnName << ") ";
+                std::vector<std::string> columnNames;
+                using columns_type_t = typename std::decay<decltype(fk)>::type::columns_type;
+                constexpr const int columnsCount = std::tuple_size<columns_type_t>::value;
+                columnNames.reserve(columnsCount);
+                tuple_helper::iterator<columnsCount - 1, Cs...>()(fk.columns, [&columnNames, this](auto &v){
+                    columnNames.push_back(this->impl.column_name(v));
+                });
+                ss << "FOREIGN KEY( ";
+                for(size_t i = 0; i < columnNames.size(); ++i) {
+                    ss << columnNames[i];
+                    if(i < columnNames.size() - 1){
+                        ss << ",";
+                    }
+                    ss << " ";
+                }
+                ss << ") REFERENCES ";
+                std::vector<std::string> referencesNames;
+                using references_type_t = typename std::decay<decltype(fk)>::type::references_type;
+                constexpr const int referencesCount = std::tuple_size<references_type_t>::value;
+                referencesNames.reserve(referencesCount);
+                {
+                    using first_reference_t = typename std::tuple_element<0, references_type_t>::type;
+                    using first_reference_mapped_type = typename internal::table_type<first_reference_t>::type;
+                    auto refTableName = this->impl.template find_table_name<first_reference_mapped_type>();
+                    ss << refTableName << " ";
+                }
+                tuple_helper::iterator<referencesCount - 1, Rs...>()(fk.references, [&referencesNames, this](auto &v){
+                    referencesNames.push_back(this->impl.column_name(v));
+                });
+                ss << "( ";
+                for(size_t i = 0; i < referencesNames.size(); ++i){
+                    ss << referencesNames[i];
+                    if(i < referencesNames.size() - 1){
+                        ss << ",";
+                    }
+                    ss << " ";
+                }
+                ss << ") ";
                 return ss.str();
             }
 #endif

From 1d49730e9d484e0697867ea578c05f48ae80df27 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sat, 15 Dec 2018 17:44:10 +0300
Subject: [PATCH 19/63] updated foreign key API and added foreign composite key
 example

---
 dev/constraints.h               | 25 +++----------------------
 dev/storage.h                   |  2 +-
 examples/composite_key.cpp      |  8 ++++++--
 include/sqlite_orm/sqlite_orm.h | 27 ++++-----------------------
 4 files changed, 14 insertions(+), 48 deletions(-)

diff --git a/dev/constraints.h b/dev/constraints.h
index c3441d869..d7df02b89 100644
--- a/dev/constraints.h
+++ b/dev/constraints.h
@@ -218,28 +218,9 @@ namespace sqlite_orm {
      *  FOREIGN KEY constraint construction function that takes member pointer as argument
      *  Available in SQLite 3.6.19 or higher
      */
-    template<class O, class F>
-    constraints::foreign_key_intermediate_t<F O::*> foreign_key(F O::*m) {
-        return {m};
-    }
-    
-    /**
-     *  FOREIGN KEY constraint construction function that takes getter function pointer as argument
-     *  Available in SQLite 3.6.19 or higher
-     */
-    template<class O, class F>
-    constraints::foreign_key_intermediate_t<const F& (O::*)() const> foreign_key(const F& (O::*getter)() const) {
-        using ret_type = constraints::foreign_key_intermediate_t<const F& (O::*)() const>;
-        return ret_type(getter);
-    }
-    
-    /**
-     *  FOREIGN KEY constraint construction function that takes setter function pointer as argument
-     *  Available in SQLite 3.6.19 or higher
-     */
-    template<class O, class F>
-    constraints::foreign_key_intermediate_t<void (O::*)(F)> foreign_key(void (O::*setter)(F)) {
-        return {setter};
+    template<class ...Cs>
+    constraints::foreign_key_intermediate_t<Cs...> foreign_key(Cs ...columns) {
+        return {std::make_tuple(std::forward<Cs>(columns)...)};
     }
 #endif
     
diff --git a/dev/storage.h b/dev/storage.h
index 0127474ca..2ccb4fe7e 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -11,7 +11,7 @@
 #include <sstream>  //  std::stringstream
 #include <map>  //  std::map
 #include <vector>   //  std::vector
-#include <tuple>    //  std::tuple_size, std::tuple
+#include <tuple>    //  std::tuple_size, std::tuple, std::make_tuple
 #include <utility>  //  std::forward, std::pair
 #include <set>  //  std::set
 #include <algorithm>    //  std::find
diff --git a/examples/composite_key.cpp b/examples/composite_key.cpp
index 1d0aef2f8..8b858149b 100644
--- a/examples/composite_key.cpp
+++ b/examples/composite_key.cpp
@@ -1,4 +1,7 @@
-
+/**
+ *  This example shows you how to create a storage with a tablw with a composite primary key
+ *  and another table woth foreign key to first table's primary compisite key.
+ */
 #include <stdio.h>
 #include <string>
 #include <iostream>
@@ -32,7 +35,8 @@ int main() {
                                 make_table("visits",
                                            make_column("user_id", &UserVisit::userId),
                                            make_column("user_first_name", &UserVisit::userFirstName),
-                                           make_column("time", &UserVisit::time)));
+                                           make_column("time", &UserVisit::time),
+                                           foreign_key(&UserVisit::userId, &UserVisit::userFirstName).references(&User::id, &User::firstName)));
     storage.sync_schema();
     
     storage.replace(User{
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f2aef4f1e..ec7b0c610 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -618,28 +618,9 @@ namespace sqlite_orm {
      *  FOREIGN KEY constraint construction function that takes member pointer as argument
      *  Available in SQLite 3.6.19 or higher
      */
-    template<class O, class F>
-    constraints::foreign_key_intermediate_t<F O::*> foreign_key(F O::*m) {
-        return {m};
-    }
-    
-    /**
-     *  FOREIGN KEY constraint construction function that takes getter function pointer as argument
-     *  Available in SQLite 3.6.19 or higher
-     */
-    template<class O, class F>
-    constraints::foreign_key_intermediate_t<const F& (O::*)() const> foreign_key(const F& (O::*getter)() const) {
-        using ret_type = constraints::foreign_key_intermediate_t<const F& (O::*)() const>;
-        return ret_type(getter);
-    }
-    
-    /**
-     *  FOREIGN KEY constraint construction function that takes setter function pointer as argument
-     *  Available in SQLite 3.6.19 or higher
-     */
-    template<class O, class F>
-    constraints::foreign_key_intermediate_t<void (O::*)(F)> foreign_key(void (O::*setter)(F)) {
-        return {setter};
+    template<class ...Cs>
+    constraints::foreign_key_intermediate_t<Cs...> foreign_key(Cs ...columns) {
+        return {std::make_tuple(std::forward<Cs>(columns)...)};
     }
 #endif
     
@@ -5685,7 +5666,7 @@ namespace sqlite_orm {
 #include <sstream>  //  std::stringstream
 #include <map>  //  std::map
 #include <vector>   //  std::vector
-#include <tuple>    //  std::tuple_size, std::tuple
+#include <tuple>    //  std::tuple_size, std::tuple, std::make_tuple
 #include <utility>  //  std::forward, std::pair
 #include <set>  //  std::set
 #include <algorithm>    //  std::find

From fe2fbd5a2a187731538ff0c46d00e7539f15deda Mon Sep 17 00:00:00 2001
From: Yevgeniy Zakharov <fnc12@me.com>
Date: Sat, 15 Dec 2018 20:21:24 +0300
Subject: [PATCH 20/63] Update TODO.md

---
 TODO.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/TODO.md b/TODO.md
index aa257c0fa..1b0440f0f 100644
--- a/TODO.md
+++ b/TODO.md
@@ -18,5 +18,6 @@
 * query static check for correct order (e.g. `GROUP BY` after `WHERE`)
 * column alias
 * `FULL OUTER JOIN`
+* WINDOW
 
 Please feel free to add any feature that isn't listed here and not implemented yet.

From 3a56e38ef2dc2ee19da79b2d611fa7b995a6e05d Mon Sep 17 00:00:00 2001
From: Yevgeniy Zakharov <fnc12@me.com>
Date: Sat, 15 Dec 2018 20:43:42 +0300
Subject: [PATCH 21/63] Update TODO.md

---
 TODO.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/TODO.md b/TODO.md
index 1b0440f0f..c64f14363 100644
--- a/TODO.md
+++ b/TODO.md
@@ -18,6 +18,6 @@
 * query static check for correct order (e.g. `GROUP BY` after `WHERE`)
 * column alias
 * `FULL OUTER JOIN`
-* WINDOW
+* `WINDOW`
 
 Please feel free to add any feature that isn't listed here and not implemented yet.

From d39abc68b35eea7ab12520f98cd55f95b1d99de2 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sun, 16 Dec 2018 11:16:16 +0300
Subject: [PATCH 22/63] added simplest queries

---
 dev/column_result.h             | 16 ++++++++++++++
 dev/storage_impl.h              |  9 ++++++--
 include/sqlite_orm/sqlite_orm.h | 25 ++++++++++++++++++++--
 tests/tests.cpp                 | 38 ++++++++++++++++++++++++++++-----
 4 files changed, 79 insertions(+), 9 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index a3ab56cc3..64fb64a99 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -271,5 +271,21 @@ namespace sqlite_orm {
             static_assert(std::is_same<left_result, right_result>::value, "Compound subselect queries must return same types");
             using type = left_result;
         };
+        
+        /**
+         *  Result for the most simple queries like `SELECT 1`
+         */
+        template<class T>
+        struct column_result_t<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
+            using type = T;
+        };
+        
+        /**
+         *  Result for the most simple queries like `SELECT 'ototo'`
+         */
+        template<>
+        struct column_result_t<const char*, void> {
+            using type = std::string;
+        };
     }
 }
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 2cf744ce3..1e25163d4 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -161,12 +161,12 @@ namespace sqlite_orm {
             }
             
             template<class O, class HH = typename H::object_type>
-            std::string find_table_name(typename std::enable_if<std::is_same<O, HH>::value>::type * = nullptr) {
+            std::string find_table_name(typename std::enable_if<std::is_same<O, HH>::value>::type * = nullptr) const {
                 return this->table.name;
             }
             
             template<class O, class HH = typename H::object_type>
-            std::string find_table_name(typename std::enable_if<!std::is_same<O, HH>::value>::type * = nullptr) {
+            std::string find_table_name(typename std::enable_if<!std::is_same<O, HH>::value>::type * = nullptr) const {
                 return this->super::template find_table_name<O>();
             }
             
@@ -425,6 +425,11 @@ namespace sqlite_orm {
         template<>
         struct storage_impl<>{
             
+            template<class O>
+            std::string find_table_name() const {
+                return {};
+            }
+            
             template<class L>
             void for_each(L) {}
             
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index ec7b0c610..549f0ea18 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4597,6 +4597,22 @@ namespace sqlite_orm {
             static_assert(std::is_same<left_result, right_result>::value, "Compound subselect queries must return same types");
             using type = left_result;
         };
+        
+        /**
+         *  Result for the most simple queries like `SELECT 1`
+         */
+        template<class T>
+        struct column_result_t<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
+            using type = T;
+        };
+        
+        /**
+         *  Result for the most simple queries like `SELECT 'ototo'`
+         */
+        template<>
+        struct column_result_t<const char*, void> {
+            using type = std::string;
+        };
     }
 }
 #pragma once
@@ -5265,12 +5281,12 @@ namespace sqlite_orm {
             }
             
             template<class O, class HH = typename H::object_type>
-            std::string find_table_name(typename std::enable_if<std::is_same<O, HH>::value>::type * = nullptr) {
+            std::string find_table_name(typename std::enable_if<std::is_same<O, HH>::value>::type * = nullptr) const {
                 return this->table.name;
             }
             
             template<class O, class HH = typename H::object_type>
-            std::string find_table_name(typename std::enable_if<!std::is_same<O, HH>::value>::type * = nullptr) {
+            std::string find_table_name(typename std::enable_if<!std::is_same<O, HH>::value>::type * = nullptr) const {
                 return this->super::template find_table_name<O>();
             }
             
@@ -5529,6 +5545,11 @@ namespace sqlite_orm {
         template<>
         struct storage_impl<>{
             
+            template<class O>
+            std::string find_table_name() const {
+                return {};
+            }
+            
             template<class L>
             void for_each(L) {}
             
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 7ee17fa8c..21ab6f36f 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1,10 +1,9 @@
-
 #include <sqlite_orm/sqlite_orm.h>
 
-#include <cassert>
-#include <vector>
-#include <string>
-#include <iostream>
+#include <cassert>  //  assert
+#include <vector>   //  std::vector
+#include <string>   //  std::string
+#include <iostream> //  std::cout, std::endl
 #include <memory>
 #include <cstdio>   //  remove
 
@@ -13,6 +12,33 @@ using namespace sqlite_orm;
 using std::cout;
 using std::endl;
 
+void testSimpleQuery() {
+    cout << __func__ << endl;
+    
+    auto storage = make_storage("");
+    {
+        auto one = storage.select(1);
+        assert(one.size() == 1);
+        assert(one.front() == 1);
+    }
+    {
+        auto ototo = storage.select("ototo");
+        assert(ototo.size() == 1);
+        assert(ototo.front() == "ototo");
+    }
+    {
+        auto two = storage.select(c(1) + 1);
+        assert(two.size() == 1);
+        assert(two.front() == 2);
+    }
+    {
+        auto twoRows = storage.select(columns(1, 2));
+        assert(twoRows.size() == 1);
+        assert(std::get<0>(twoRows.front()) == 1);
+        assert(std::get<1>(twoRows.front()) == 2);
+    }
+}
+
 void testThreadsafe() {
     cout << __func__ << endl;
     
@@ -2315,4 +2341,6 @@ int main(int argc, char **argv) {
     testJournalMode();
     
     testEscapedIndexName();
+    
+    testSimpleQuery();
 }

From 99f39f842c21661ea0be92209d7b0ba9db41a3af Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Mon, 17 Dec 2018 15:37:21 +0300
Subject: [PATCH 23/63] added custom table aliased and updated self_join.cpp
 example

---
 dev/mapped_type_proxy.h         |  8 ++---
 examples/self_join.cpp          | 63 +++++++++++++++++++++++++--------
 include/sqlite_orm/sqlite_orm.h |  8 ++---
 3 files changed, 56 insertions(+), 23 deletions(-)

diff --git a/dev/mapped_type_proxy.h b/dev/mapped_type_proxy.h
index 6ca70b0b2..3d7158172 100644
--- a/dev/mapped_type_proxy.h
+++ b/dev/mapped_type_proxy.h
@@ -10,14 +10,14 @@ namespace sqlite_orm {
          *  If T is alias than mapped_type_proxy<T>::type is alias::type
          *  otherwise T is T.
          */
-        template<class T>
+        template<class T, class sfinae = void>
         struct mapped_type_proxy {
             using type = T;
         };
         
-        template<class T, char A>
-        struct mapped_type_proxy<alias<T, A>> {
-            using type = T;
+        template<class T>
+        struct mapped_type_proxy<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
+            using type = typename T::type;
         };
     }
 }
diff --git a/examples/self_join.cpp b/examples/self_join.cpp
index 533c23538..e59f2c2a5 100644
--- a/examples/self_join.cpp
+++ b/examples/self_join.cpp
@@ -27,6 +27,21 @@ struct Employee {
     std::string email;
 };
 
+/**
+ *  This is how custom alias is made:
+ *  1) it must have `type` alias which is equal to your mapped class
+ *  2) is must have static function with `get()` signature and return type with `operator<<`
+ */
+template<class T>
+struct custom_alias : sqlite_orm::alias_tag {
+    using type = T;
+    
+    static const std::string &get() {
+        static const std::string res = "emp";
+        return res;
+    }
+};
+
 int main() {
     using namespace sqlite_orm;
     auto storage = make_storage("self_join.sqlite",
@@ -109,23 +124,41 @@ int main() {
         "T1H 1Y8", "+1 (403) 467-3351", "+1 (403) 467-8772", "laura@chinookcorp.com"
     });
     storage.commit();
-    cout << "after commit" << endl;
     
-    //  SELECT  m.FirstName || ' ' || m.LastName,
-    //      employees.FirstName || ' ' || employees.LastName
-    //  FROM  employees
-    //  INNER JOIN  employees m
-    //  ON m.ReportsTo = employees.EmployeeId
-    using als = alias_m<Employee>;
-    auto firstNames = storage.select(columns(c(alias_column<als>(&Employee::firstName)) || " " || c(alias_column<als>(&Employee::lastName)),
-                                             c(&Employee::firstName) || " " || c(&Employee::lastName)),
-                                     inner_join<als>(on(alias_column<als>(&Employee::reportsTo) == c(&Employee::employeeId))));
-    cout << "firstNames count = " << firstNames.size() << endl;
-    for(auto &row : firstNames) {
-        cout << std::get<0>(row) << '\t' << std::get<1>(row) << endl;
+    {
+        //  SELECT m.FirstName || ' ' || m.LastName,
+        //      employees.FirstName || ' ' || employees.LastName
+        //  FROM employees
+        //  INNER JOIN employees m
+        //  ON m.ReportsTo = employees.EmployeeId
+        using als = alias_m<Employee>;
+        auto firstNames = storage.select(columns(c(alias_column<als>(&Employee::firstName)) || " " || c(alias_column<als>(&Employee::lastName)),
+                                                 c(&Employee::firstName) || " " || c(&Employee::lastName)),
+                                         inner_join<als>(on(alias_column<als>(&Employee::reportsTo) == c(&Employee::employeeId))));
+        cout << "firstNames count = " << firstNames.size() << endl;
+        for(auto &row : firstNames) {
+            cout << std::get<0>(row) << '\t' << std::get<1>(row) << endl;
+        }
+        
+        assert(storage.count<Employee>() == storage.count<alias_a<Employee>>());
+    }
+    {   //  same query with custom alias 'emp'
+        cout << endl;
+        
+        //  SELECT emp.FirstName || ' ' || emp.LastName,
+        //      employees.FirstName || ' ' || employees.LastName
+        //  FROM employees
+        //  INNER JOIN employees emp
+        //  ON emp.ReportsTo = employees.EmployeeId
+        using als = custom_alias<Employee>;
+        auto firstNames = storage.select(columns(c(alias_column<als>(&Employee::firstName)) || " " || c(alias_column<als>(&Employee::lastName)),
+                                                 c(&Employee::firstName) || " " || c(&Employee::lastName)),
+                                         inner_join<als>(on(alias_column<als>(&Employee::reportsTo) == c(&Employee::employeeId))));
+        cout << "firstNames count = " << firstNames.size() << endl;
+        for(auto &row : firstNames) {
+            cout << std::get<0>(row) << '\t' << std::get<1>(row) << endl;
+        }
     }
-    
-    assert(storage.count<Employee>() == storage.count<alias_a<Employee>>());
     
     return 0;
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 549f0ea18..41e027d3d 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4237,14 +4237,14 @@ namespace sqlite_orm {
          *  If T is alias than mapped_type_proxy<T>::type is alias::type
          *  otherwise T is T.
          */
-        template<class T>
+        template<class T, class sfinae = void>
         struct mapped_type_proxy {
             using type = T;
         };
         
-        template<class T, char A>
-        struct mapped_type_proxy<alias<T, A>> {
-            using type = T;
+        template<class T>
+        struct mapped_type_proxy<T, typename std::enable_if<std::is_base_of<alias_tag, T>::value>::type> {
+            using type = typename T::type;
         };
     }
 }

From 3aca1200d6696160304fe781173a3d663ef5e979 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 18 Dec 2018 14:42:50 +0300
Subject: [PATCH 24/63] added alias.cpp example

---
 dev/alias.h                     | 15 +++++-
 examples/custom_aliases.cpp     | 89 +++++++++++++++++++++++++++++++++
 include/sqlite_orm/sqlite_orm.h | 15 +++++-
 tests/tests.cpp                 | 19 +++++++
 4 files changed, 136 insertions(+), 2 deletions(-)
 create mode 100644 examples/custom_aliases.cpp

diff --git a/dev/alias.h b/dev/alias.h
index 26a866cd4..39c4584e7 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -1,12 +1,20 @@
 #pragma once
 
-#include <type_traits>  //  std::enable_if, std::is_base_of
+#include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
 #include <sstream>  //  std::stringstream
 
 namespace sqlite_orm {
     
+    /**
+     *  This is base class for every class which is used as a custom table alias.
+     *  For more information please look through self_join.cpp example
+     */
     struct alias_tag {};
     
+    /**
+     *  This is a common built-in class used for custom single character table aliases.
+     *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
+     */
     template<class T, char A>
     struct alias : alias_tag {
         using type = T;
@@ -50,8 +58,13 @@ namespace sqlite_orm {
         };
     }
     
+    /**
+     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
+     *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
+     */
     template<class T, class C>
     internal::alias_column_t<T, C> alias_column(C c) {
+        static_assert(std::is_member_pointer<C>::value, "alias_column argument must be a member pointer mapped to a storage");
         return {c};
     }
     
diff --git a/examples/custom_aliases.cpp b/examples/custom_aliases.cpp
new file mode 100644
index 000000000..3b4b8d1bc
--- /dev/null
+++ b/examples/custom_aliases.cpp
@@ -0,0 +1,89 @@
+//
+//  custom_aliases.cpp
+//  CPPTest
+//
+//  Created by John Zakharov on 12/18/18.
+//  Copyright © 2018 John Zakharov. All rights reserved.
+//
+
+#include <sqlite_orm/sqlite_orm.h>
+#include <string>
+#include <iostream>
+
+using std::cout;
+using std::endl;
+
+struct Employee {
+    int id = 0;
+    std::string name;
+    int age = 0;
+    std::string address;
+    float salary = 0;
+};
+
+struct Department {
+    int id = 0;
+    std::string dept;
+    int empId = 0;
+};
+
+int main() {
+    using namespace sqlite_orm;
+    auto storage = make_storage("custom_aliases.sqlite",
+                                make_table("COMPANY",
+                                           make_column("ID", &Employee::id, primary_key()),
+                                           make_column("NAME", &Employee::name),
+                                           make_column("AGE", &Employee::age),
+                                           make_column("ADDRESS", &Employee::address),
+                                           make_column("SALARY", &Employee::salary)),
+                                make_table("DEPARTMENT",
+                                           make_column("ID", &Department::id),
+                                           make_column("DEPT", &Department::dept),
+                                           make_column("EMP_ID", &Department::empId)));
+    storage.sync_schema();
+    storage.remove_all<Department>();
+    storage.remove_all<Employee>();
+    
+    //  insert initial values
+    storage.replace(Employee{ 1, "Paul", 32, "California", 20000.0 });
+    storage.replace(Employee{ 2, "Allen", 25, "Texas", 15000.0 });
+    storage.replace(Employee{ 3, "Teddy", 23, "Norway", 20000.0 });
+    storage.replace(Employee{ 4, "Mark", 25, "Rich-Mond", 65000.0 });
+    storage.replace(Employee{ 5, "David", 27, "Texas", 85000.0 });
+    storage.replace(Employee{ 6, "Kim", 22, "South-Hall", 45000.0 });
+    storage.replace(Employee{ 7, "James", 24, "Houston", 10000.0 });
+    
+    storage.replace(Department{1, "IT Billing", 1});
+    storage.replace(Department{2, "Engineering", 2});
+    storage.replace(Department{3, "Finance", 7});
+    storage.replace(Department{4, "Engineering", 3});
+    storage.replace(Department{5, "Finance", 4});
+    storage.replace(Department{6, "Engineering", 5});
+    storage.replace(Department{7, "Finance", 6});
+    
+    //  SELECT COMPANY.ID, COMPANY.NAME, COMPANY.AGE, DEPARTMENT.DEPT
+    //  FROM COMPANY, DEPARTMENT
+    //  WHERE COMPANY.ID = DEPARTMENT.EMP_ID;
+    auto simpleRows = storage.select(columns(&Employee::id, &Employee::name, &Employee::age, &Department::dept),
+                                     where(is_equal(&Employee::id, &Department::empId)));
+    assert(simpleRows.size() == 7);
+    
+    //  SELECT C.ID, C.NAME, C.AGE, D.DEPT
+    //  FROM COMPANY AS C, DEPARTMENT AS D
+    //  WHERE  C.ID = D.EMP_ID;
+    using als_c = sqlite_orm::alias_c<Employee>;
+    using als_d = sqlite_orm::alias_d<Department>;
+    auto rowsWithTableAliases = storage.select(columns(alias_column<als_c>(&Employee::id),
+                                                       alias_column<als_c>(&Employee::name),
+                                                       alias_column<als_c>(&Employee::age),
+                                                       alias_column<als_d>(&Department::dept)),
+                                               where(is_equal(alias_column<als_c>(&Employee::id), alias_column<als_d>(&Department::empId))));
+    assert(rowsWithTableAliases == simpleRows);
+    cout << "ID" << '\t' << "NAME" << '\t' << "AGE" << '\t' << "DEPT" << endl;
+    cout << "----------" << '\t' << "----------" << '\t' << "----------" << '\t' << "----------" << endl;
+    for(auto &row : rowsWithTableAliases) {
+        cout << std::get<0>(row) << '\t' << std::get<1>(row) << '\t' << std::get<2>(row) << '\t' << std::get<3>(row) << endl;
+    }
+    
+    return 0;
+}
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 41e027d3d..6c233d8e8 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2379,13 +2379,21 @@ namespace sqlite_orm {
 }
 #pragma once
 
-#include <type_traits>  //  std::enable_if, std::is_base_of
+#include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
 #include <sstream>  //  std::stringstream
 
 namespace sqlite_orm {
     
+    /**
+     *  This is base class for every class which is used as a custom table alias.
+     *  For more information please look through self_join.cpp example
+     */
     struct alias_tag {};
     
+    /**
+     *  This is a common built-in class used for custom single character table aliases.
+     *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
+     */
     template<class T, char A>
     struct alias : alias_tag {
         using type = T;
@@ -2429,8 +2437,13 @@ namespace sqlite_orm {
         };
     }
     
+    /**
+     *  @return column with table alias attached. Place it instead of a column statement in case you need to specify a
+     *  column with table alias prefix like 'a.column'. For more information please look through self_join.cpp example
+     */
     template<class T, class C>
     internal::alias_column_t<T, C> alias_column(C c) {
+        static_assert(std::is_member_pointer<C>::value, "alias_column argument must be a member pointer mapped to a storage");
         return {c};
     }
     
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 21ab6f36f..cc3af9390 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -12,6 +12,23 @@ using namespace sqlite_orm;
 using std::cout;
 using std::endl;
 
+void testColumnAlias() {
+    cout << __func__ << endl;
+    
+    struct User {
+        int id = 0;
+    };
+    
+    auto storage = make_storage("",
+                                make_table("users",
+                                           make_column("id", &User::id, primary_key())));
+    storage.sync_schema();
+    
+    storage.replace(User{1});
+    auto rows = storage.select(&User::id);
+    auto rows2 = storage.select(<#T m#>, <#Args args...#>)
+}
+
 void testSimpleQuery() {
     cout << __func__ << endl;
     
@@ -2343,4 +2360,6 @@ int main(int argc, char **argv) {
     testEscapedIndexName();
     
     testSimpleQuery();
+    
+    testColumnAlias();
 }

From e6cd931a3b3be7be9c4f7f6a502ab461c14f8b53 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 18 Dec 2018 15:25:07 +0300
Subject: [PATCH 25/63] fixed tests and renamed alias to table_alias

---
 dev/alias.h                     | 78 ++++++++++++++++-----------------
 examples/custom_aliases.cpp     | 13 +++---
 include/sqlite_orm/sqlite_orm.h | 78 ++++++++++++++++-----------------
 tests/tests.cpp                 | 19 --------
 4 files changed, 86 insertions(+), 102 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index 39c4584e7..e097e5be1 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -11,21 +11,21 @@ namespace sqlite_orm {
      */
     struct alias_tag {};
     
-    /**
-     *  This is a common built-in class used for custom single character table aliases.
-     *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
-     */
-    template<class T, char A>
-    struct alias : alias_tag {
-        using type = T;
-        
-        static char get() {
-            return A;
-        }
-    };
-    
     namespace internal {
         
+        /**
+         *  This is a common built-in class used for custom single character table aliases.
+         *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
+         */
+        template<class T, char A>
+        struct table_alias : alias_tag {
+            using type = T;
+            
+            static char get() {
+                return A;
+            }
+        };
+        
         template<class T, class C>
         struct alias_column_t {
             using alias_type = T;
@@ -68,30 +68,30 @@ namespace sqlite_orm {
         return {c};
     }
     
-    template<class T> using alias_a = alias<T, 'a'>;
-    template<class T> using alias_b = alias<T, 'b'>;
-    template<class T> using alias_c = alias<T, 'c'>;
-    template<class T> using alias_d = alias<T, 'd'>;
-    template<class T> using alias_e = alias<T, 'e'>;
-    template<class T> using alias_f = alias<T, 'f'>;
-    template<class T> using alias_g = alias<T, 'g'>;
-    template<class T> using alias_h = alias<T, 'h'>;
-    template<class T> using alias_i = alias<T, 'i'>;
-    template<class T> using alias_j = alias<T, 'j'>;
-    template<class T> using alias_k = alias<T, 'k'>;
-    template<class T> using alias_l = alias<T, 'l'>;
-    template<class T> using alias_m = alias<T, 'm'>;
-    template<class T> using alias_n = alias<T, 'n'>;
-    template<class T> using alias_o = alias<T, 'o'>;
-    template<class T> using alias_p = alias<T, 'p'>;
-    template<class T> using alias_q = alias<T, 'q'>;
-    template<class T> using alias_r = alias<T, 'r'>;
-    template<class T> using alias_s = alias<T, 's'>;
-    template<class T> using alias_t = alias<T, 't'>;
-    template<class T> using alias_u = alias<T, 'u'>;
-    template<class T> using alias_v = alias<T, 'v'>;
-    template<class T> using alias_w = alias<T, 'w'>;
-    template<class T> using alias_x = alias<T, 'x'>;
-    template<class T> using alias_y = alias<T, 'y'>;
-    template<class T> using alias_z = alias<T, 'z'>;
+    template<class T> using alias_a = internal::table_alias<T, 'a'>;
+    template<class T> using alias_b = internal::table_alias<T, 'b'>;
+    template<class T> using alias_c = internal::table_alias<T, 'c'>;
+    template<class T> using alias_d = internal::table_alias<T, 'd'>;
+    template<class T> using alias_e = internal::table_alias<T, 'e'>;
+    template<class T> using alias_f = internal::table_alias<T, 'f'>;
+    template<class T> using alias_g = internal::table_alias<T, 'g'>;
+    template<class T> using alias_h = internal::table_alias<T, 'h'>;
+    template<class T> using alias_i = internal::table_alias<T, 'i'>;
+    template<class T> using alias_j = internal::table_alias<T, 'j'>;
+    template<class T> using alias_k = internal::table_alias<T, 'k'>;
+    template<class T> using alias_l = internal::table_alias<T, 'l'>;
+    template<class T> using alias_m = internal::table_alias<T, 'm'>;
+    template<class T> using alias_n = internal::table_alias<T, 'n'>;
+    template<class T> using alias_o = internal::table_alias<T, 'o'>;
+    template<class T> using alias_p = internal::table_alias<T, 'p'>;
+    template<class T> using alias_q = internal::table_alias<T, 'q'>;
+    template<class T> using alias_r = internal::table_alias<T, 'r'>;
+    template<class T> using alias_s = internal::table_alias<T, 's'>;
+    template<class T> using alias_t = internal::table_alias<T, 't'>;
+    template<class T> using alias_u = internal::table_alias<T, 'u'>;
+    template<class T> using alias_v = internal::table_alias<T, 'v'>;
+    template<class T> using alias_w = internal::table_alias<T, 'w'>;
+    template<class T> using alias_x = internal::table_alias<T, 'x'>;
+    template<class T> using alias_y = internal::table_alias<T, 'y'>;
+    template<class T> using alias_z = internal::table_alias<T, 'z'>;
 }
diff --git a/examples/custom_aliases.cpp b/examples/custom_aliases.cpp
index 3b4b8d1bc..7df5ed155 100644
--- a/examples/custom_aliases.cpp
+++ b/examples/custom_aliases.cpp
@@ -68,6 +68,12 @@ int main() {
                                      where(is_equal(&Employee::id, &Department::empId)));
     assert(simpleRows.size() == 7);
     
+    cout << "ID" << '\t' << "NAME" << '\t' << "AGE" << '\t' << "DEPT" << endl;
+    cout << "----------" << '\t' << "----------" << '\t' << "----------" << '\t' << "----------" << endl;
+    for(auto &row : simpleRows) {
+        cout << std::get<0>(row) << '\t' << std::get<1>(row) << '\t' << std::get<2>(row) << '\t' << std::get<3>(row) << endl;
+    }
+    
     //  SELECT C.ID, C.NAME, C.AGE, D.DEPT
     //  FROM COMPANY AS C, DEPARTMENT AS D
     //  WHERE  C.ID = D.EMP_ID;
@@ -79,11 +85,8 @@ int main() {
                                                        alias_column<als_d>(&Department::dept)),
                                                where(is_equal(alias_column<als_c>(&Employee::id), alias_column<als_d>(&Department::empId))));
     assert(rowsWithTableAliases == simpleRows);
-    cout << "ID" << '\t' << "NAME" << '\t' << "AGE" << '\t' << "DEPT" << endl;
-    cout << "----------" << '\t' << "----------" << '\t' << "----------" << '\t' << "----------" << endl;
-    for(auto &row : rowsWithTableAliases) {
-        cout << std::get<0>(row) << '\t' << std::get<1>(row) << '\t' << std::get<2>(row) << '\t' << std::get<3>(row) << endl;
-    }
+    
+    
     
     return 0;
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 6c233d8e8..3cb91a738 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2390,21 +2390,21 @@ namespace sqlite_orm {
      */
     struct alias_tag {};
     
-    /**
-     *  This is a common built-in class used for custom single character table aliases.
-     *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
-     */
-    template<class T, char A>
-    struct alias : alias_tag {
-        using type = T;
-        
-        static char get() {
-            return A;
-        }
-    };
-    
     namespace internal {
         
+        /**
+         *  This is a common built-in class used for custom single character table aliases.
+         *  Also you can use language aliases `alias_a`, `alias_b` etc. instead
+         */
+        template<class T, char A>
+        struct table_alias : alias_tag {
+            using type = T;
+            
+            static char get() {
+                return A;
+            }
+        };
+        
         template<class T, class C>
         struct alias_column_t {
             using alias_type = T;
@@ -2447,32 +2447,32 @@ namespace sqlite_orm {
         return {c};
     }
     
-    template<class T> using alias_a = alias<T, 'a'>;
-    template<class T> using alias_b = alias<T, 'b'>;
-    template<class T> using alias_c = alias<T, 'c'>;
-    template<class T> using alias_d = alias<T, 'd'>;
-    template<class T> using alias_e = alias<T, 'e'>;
-    template<class T> using alias_f = alias<T, 'f'>;
-    template<class T> using alias_g = alias<T, 'g'>;
-    template<class T> using alias_h = alias<T, 'h'>;
-    template<class T> using alias_i = alias<T, 'i'>;
-    template<class T> using alias_j = alias<T, 'j'>;
-    template<class T> using alias_k = alias<T, 'k'>;
-    template<class T> using alias_l = alias<T, 'l'>;
-    template<class T> using alias_m = alias<T, 'm'>;
-    template<class T> using alias_n = alias<T, 'n'>;
-    template<class T> using alias_o = alias<T, 'o'>;
-    template<class T> using alias_p = alias<T, 'p'>;
-    template<class T> using alias_q = alias<T, 'q'>;
-    template<class T> using alias_r = alias<T, 'r'>;
-    template<class T> using alias_s = alias<T, 's'>;
-    template<class T> using alias_t = alias<T, 't'>;
-    template<class T> using alias_u = alias<T, 'u'>;
-    template<class T> using alias_v = alias<T, 'v'>;
-    template<class T> using alias_w = alias<T, 'w'>;
-    template<class T> using alias_x = alias<T, 'x'>;
-    template<class T> using alias_y = alias<T, 'y'>;
-    template<class T> using alias_z = alias<T, 'z'>;
+    template<class T> using alias_a = internal::table_alias<T, 'a'>;
+    template<class T> using alias_b = internal::table_alias<T, 'b'>;
+    template<class T> using alias_c = internal::table_alias<T, 'c'>;
+    template<class T> using alias_d = internal::table_alias<T, 'd'>;
+    template<class T> using alias_e = internal::table_alias<T, 'e'>;
+    template<class T> using alias_f = internal::table_alias<T, 'f'>;
+    template<class T> using alias_g = internal::table_alias<T, 'g'>;
+    template<class T> using alias_h = internal::table_alias<T, 'h'>;
+    template<class T> using alias_i = internal::table_alias<T, 'i'>;
+    template<class T> using alias_j = internal::table_alias<T, 'j'>;
+    template<class T> using alias_k = internal::table_alias<T, 'k'>;
+    template<class T> using alias_l = internal::table_alias<T, 'l'>;
+    template<class T> using alias_m = internal::table_alias<T, 'm'>;
+    template<class T> using alias_n = internal::table_alias<T, 'n'>;
+    template<class T> using alias_o = internal::table_alias<T, 'o'>;
+    template<class T> using alias_p = internal::table_alias<T, 'p'>;
+    template<class T> using alias_q = internal::table_alias<T, 'q'>;
+    template<class T> using alias_r = internal::table_alias<T, 'r'>;
+    template<class T> using alias_s = internal::table_alias<T, 's'>;
+    template<class T> using alias_t = internal::table_alias<T, 't'>;
+    template<class T> using alias_u = internal::table_alias<T, 'u'>;
+    template<class T> using alias_v = internal::table_alias<T, 'v'>;
+    template<class T> using alias_w = internal::table_alias<T, 'w'>;
+    template<class T> using alias_x = internal::table_alias<T, 'x'>;
+    template<class T> using alias_y = internal::table_alias<T, 'y'>;
+    template<class T> using alias_z = internal::table_alias<T, 'z'>;
 }
 #pragma once
 
diff --git a/tests/tests.cpp b/tests/tests.cpp
index cc3af9390..21ab6f36f 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -12,23 +12,6 @@ using namespace sqlite_orm;
 using std::cout;
 using std::endl;
 
-void testColumnAlias() {
-    cout << __func__ << endl;
-    
-    struct User {
-        int id = 0;
-    };
-    
-    auto storage = make_storage("",
-                                make_table("users",
-                                           make_column("id", &User::id, primary_key())));
-    storage.sync_schema();
-    
-    storage.replace(User{1});
-    auto rows = storage.select(&User::id);
-    auto rows2 = storage.select(<#T m#>, <#Args args...#>)
-}
-
 void testSimpleQuery() {
     cout << __func__ << endl;
     
@@ -2360,6 +2343,4 @@ int main(int argc, char **argv) {
     testEscapedIndexName();
     
     testSimpleQuery();
-    
-    testColumnAlias();
 }

From 185ee95e991ba18e3103670afc7a1d62e72811df Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 18 Dec 2018 20:54:48 +0300
Subject: [PATCH 26/63] added column alias

---
 dev/alias.h                     | 27 ++++++++++++++++++++
 dev/column_result.h             |  7 +++--
 dev/storage.h                   | 11 ++++++++
 examples/custom_aliases.cpp     | 43 ++++++++++++++++++++++++++++---
 include/sqlite_orm/sqlite_orm.h | 45 +++++++++++++++++++++++++++++++--
 tests/static_tests.cpp          | 13 ++++++++++
 6 files changed, 138 insertions(+), 8 deletions(-)

diff --git a/dev/alias.h b/dev/alias.h
index e097e5be1..d75d5620e 100644
--- a/dev/alias.h
+++ b/dev/alias.h
@@ -2,6 +2,7 @@
 
 #include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
 #include <sstream>  //  std::stringstream
+#include <string>   //  std::string
 
 namespace sqlite_orm {
     
@@ -26,6 +27,9 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  Column expression with table alias attached like 'C.ID'. This is not a column alias
+         */
         template<class T, class C>
         struct alias_column_t {
             using alias_type = T;
@@ -56,6 +60,19 @@ namespace sqlite_orm {
                 return {};
             }
         };
+        
+        template<class T, class E>
+        struct as_t {
+            using alias_type = T;
+            using expression_type = E;
+            
+            expression_type expression;
+        };
+        
+        template<class T>
+        struct alias_holder {
+            using type = T;
+        };
     }
     
     /**
@@ -68,6 +85,16 @@ namespace sqlite_orm {
         return {c};
     }
     
+    template<class T, class E>
+    internal::as_t<T, E> as(E expression) {
+        return {std::move(expression)};
+    }
+    
+    template<class T>
+    internal::alias_holder<T> get() {
+        return {};
+    }
+    
     template<class T> using alias_a = internal::table_alias<T, 'a'>;
     template<class T> using alias_b = internal::table_alias<T, 'b'>;
     template<class T> using alias_c = internal::table_alias<T, 'c'>;
diff --git a/dev/column_result.h b/dev/column_result.h
index 64fb64a99..ed02c69ee 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <type_traits>  //  std::enable_if, std::is_same
+#include <type_traits>  //  std::enable_if, std::is_same, std::decay
 #include <tuple>    //  std::tuple
 
 #include "core_functions.h"
@@ -256,7 +256,7 @@ namespace sqlite_orm {
         
         template<class ...Args>
         struct column_result_t<columns_t<Args...>, void> {
-            using type = std::tuple<typename column_result_t<Args>::type...>;
+            using type = std::tuple<typename column_result_t<typename std::decay<Args>::type>::type...>;
         };
         
         template<class T, class ...Args>
@@ -287,5 +287,8 @@ namespace sqlite_orm {
         struct column_result_t<const char*, void> {
             using type = std::string;
         };
+        
+        template<class T, class E>
+        struct column_result_t<as_t<T, E>, void> : column_result_t<typename std::decay<E>::type, void> {};
     }
 }
diff --git a/dev/storage.h b/dev/storage.h
index 2ccb4fe7e..e83a52f6b 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -454,6 +454,17 @@ namespace sqlite_orm {
                 }
             }
             
+            template<class T>
+            std::string string_from_expression(const alias_holder<T> &holder, bool noTableName = false, bool /*escape*/ = false) {
+                return T::get();
+            }
+            
+            template<class T, class E>
+            std::string string_from_expression(const as_t<T, E> &als, bool noTableName = false, bool /*escape*/ = false) {
+                auto tableAliasString = alias_extractor<T>::get();
+                return this->string_from_expression(als.expression) + " AS " + tableAliasString;
+            }
+            
             template<class T, class C>
             std::string string_from_expression(const alias_column_t<T, C> &als, bool noTableName = false, bool /*escape*/ = false) {
                 std::stringstream ss;
diff --git a/examples/custom_aliases.cpp b/examples/custom_aliases.cpp
index 7df5ed155..8584df727 100644
--- a/examples/custom_aliases.cpp
+++ b/examples/custom_aliases.cpp
@@ -27,8 +27,25 @@ struct Department {
     int empId = 0;
 };
 
-int main() {
-    using namespace sqlite_orm;
+using namespace sqlite_orm;
+
+struct EmployeeIdAlias : alias_tag {
+    static const std::string &get() {
+        static const std::string res = "COMPANY_ID";
+        return res;
+    }
+};
+
+struct CompanyNameAlias : alias_tag {
+    static const std::string &get() {
+        static const std::string res = "COMPANY_NAME";
+        return res;
+    }
+};
+
+int main(int argc, char* argv[]) {
+    cout << argv[0] << endl;
+    
     auto storage = make_storage("custom_aliases.sqlite",
                                 make_table("COMPANY",
                                            make_column("ID", &Employee::id, primary_key()),
@@ -77,8 +94,8 @@ int main() {
     //  SELECT C.ID, C.NAME, C.AGE, D.DEPT
     //  FROM COMPANY AS C, DEPARTMENT AS D
     //  WHERE  C.ID = D.EMP_ID;
-    using als_c = sqlite_orm::alias_c<Employee>;
-    using als_d = sqlite_orm::alias_d<Department>;
+    using als_c = alias_c<Employee>;
+    using als_d = alias_d<Department>;
     auto rowsWithTableAliases = storage.select(columns(alias_column<als_c>(&Employee::id),
                                                        alias_column<als_c>(&Employee::name),
                                                        alias_column<als_c>(&Employee::age),
@@ -86,7 +103,25 @@ int main() {
                                                where(is_equal(alias_column<als_c>(&Employee::id), alias_column<als_d>(&Department::empId))));
     assert(rowsWithTableAliases == simpleRows);
     
+    //  SELECT COMPANY.ID as COMPANY_ID, COMPANY.NAME AS COMPANY_NAME, COMPANY.AGE, DEPARTMENT.DEPT
+    //  FROM COMPANY, DEPARTMENT
+    //  WHERE COMPANY_ID = DEPARTMENT.EMP_ID;
+    auto rowsWithColumnAliases = storage.select(columns(as<EmployeeIdAlias>(&Employee::id),
+                                                        as<CompanyNameAlias>(&Employee::name),
+                                                        &Employee::age,
+                                                        &Department::dept),
+                                                where(is_equal(get<EmployeeIdAlias>(), &Department::empId)));
+    assert(rowsWithColumnAliases == rowsWithTableAliases);
     
+    //  SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
+    //  FROM COMPANY AS C, DEPARTMENT AS D
+    //  WHERE  C.ID = D.EMP_ID;
+    auto rowsWithBothTableAndColumnAliases = storage.select(columns(as<EmployeeIdAlias>(alias_column<als_c>(&Employee::id)),
+                                                                    as<CompanyNameAlias>(alias_column<als_c>(&Employee::name)),
+                                                                    alias_column<als_c>(&Employee::age),
+                                                                    alias_column<als_d>(&Department::dept)),
+                                                            where(is_equal(alias_column<als_c>(&Employee::id), alias_column<als_d>(&Department::empId))));
+    assert(rowsWithBothTableAndColumnAliases == rowsWithBothTableAndColumnAliases);
     
     return 0;
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 3cb91a738..e0ccbed23 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2381,6 +2381,7 @@ namespace sqlite_orm {
 
 #include <type_traits>  //  std::enable_if, std::is_base_of, std::is_member_pointer
 #include <sstream>  //  std::stringstream
+#include <string>   //  std::string
 
 namespace sqlite_orm {
     
@@ -2405,6 +2406,9 @@ namespace sqlite_orm {
             }
         };
         
+        /**
+         *  Column expression with table alias attached like 'C.ID'. This is not a column alias
+         */
         template<class T, class C>
         struct alias_column_t {
             using alias_type = T;
@@ -2435,6 +2439,19 @@ namespace sqlite_orm {
                 return {};
             }
         };
+        
+        template<class T, class E>
+        struct as_t {
+            using alias_type = T;
+            using expression_type = E;
+            
+            expression_type expression;
+        };
+        
+        template<class T>
+        struct alias_holder {
+            using type = T;
+        };
     }
     
     /**
@@ -2447,6 +2464,16 @@ namespace sqlite_orm {
         return {c};
     }
     
+    template<class T, class E>
+    internal::as_t<T, E> as(E expression) {
+        return {std::move(expression)};
+    }
+    
+    template<class T>
+    internal::alias_holder<T> get() {
+        return {};
+    }
+    
     template<class T> using alias_a = internal::table_alias<T, 'a'>;
     template<class T> using alias_b = internal::table_alias<T, 'b'>;
     template<class T> using alias_c = internal::table_alias<T, 'c'>;
@@ -4332,7 +4359,7 @@ namespace sqlite_orm {
 }
 #pragma once
 
-#include <type_traits>  //  std::enable_if, std::is_same
+#include <type_traits>  //  std::enable_if, std::is_same, std::decay
 #include <tuple>    //  std::tuple
 
 // #include "core_functions.h"
@@ -4595,7 +4622,7 @@ namespace sqlite_orm {
         
         template<class ...Args>
         struct column_result_t<columns_t<Args...>, void> {
-            using type = std::tuple<typename column_result_t<Args>::type...>;
+            using type = std::tuple<typename column_result_t<typename std::decay<Args>::type>::type...>;
         };
         
         template<class T, class ...Args>
@@ -4626,6 +4653,9 @@ namespace sqlite_orm {
         struct column_result_t<const char*, void> {
             using type = std::string;
         };
+        
+        template<class T, class E>
+        struct column_result_t<as_t<T, E>, void> : column_result_t<typename std::decay<E>::type, void> {};
     }
 }
 #pragma once
@@ -6486,6 +6516,17 @@ namespace sqlite_orm {
                 }
             }
             
+            template<class T>
+            std::string string_from_expression(const alias_holder<T> &holder, bool noTableName = false, bool /*escape*/ = false) {
+                return T::get();
+            }
+            
+            template<class T, class E>
+            std::string string_from_expression(const as_t<T, E> &als, bool noTableName = false, bool /*escape*/ = false) {
+                auto tableAliasString = alias_extractor<T>::get();
+                return this->string_from_expression(als.expression) + " AS " + tableAliasString;
+            }
+            
             template<class T, class C>
             std::string string_from_expression(const alias_column_t<T, C> &als, bool noTableName = false, bool /*escape*/ = false) {
                 std::stringstream ss;
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 387392233..f0f139b35 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -241,6 +241,19 @@ int main() {
         using IdsTuple = SelectVectorTuple::value_type;
         static_assert(std::tuple_size<IdsTuple>::value == 1, "Incorrect tuple size");
     }
+    {
+        auto columnAlias = as(&User::id, "userId");
+        using ExpressionType = decltype(columnAlias)::expression_type;
+        static_assert(std::is_same<ExpressionType, decltype(&User::id)>::value, "Incorrect extression type");
+        {
+            using ResultsType = internal::column_result_t<decltype(columnAlias)>::type;
+            static_assert(std::is_same<ResultsType, int>::value, "Incorrect column alias result type");
+        }
+        {
+            auto cols = columns(columnAlias);
+            using ResultsType = internal::column_result_t<decltype(cols)>::type;
+        }
+    }
     
     
     return 0;

From 2c98eded613892f1e1a117e59294948ce5701015 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 18 Dec 2018 21:00:05 +0300
Subject: [PATCH 27/63] fixed static tests

---
 tests/static_tests.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index f0f139b35..387392233 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -241,19 +241,6 @@ int main() {
         using IdsTuple = SelectVectorTuple::value_type;
         static_assert(std::tuple_size<IdsTuple>::value == 1, "Incorrect tuple size");
     }
-    {
-        auto columnAlias = as(&User::id, "userId");
-        using ExpressionType = decltype(columnAlias)::expression_type;
-        static_assert(std::is_same<ExpressionType, decltype(&User::id)>::value, "Incorrect extression type");
-        {
-            using ResultsType = internal::column_result_t<decltype(columnAlias)>::type;
-            static_assert(std::is_same<ResultsType, int>::value, "Incorrect column alias result type");
-        }
-        {
-            auto cols = columns(columnAlias);
-            using ResultsType = internal::column_result_t<decltype(cols)>::type;
-        }
-    }
     
     
     return 0;

From e5ade5dab4a62483f7bb2b239309524734f56b1a Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 18 Dec 2018 22:59:27 +0300
Subject: [PATCH 28/63] added storage type is mapped traits

---
 dev/column_result.h                |  2 +-
 dev/storage.h                      | 10 +++----
 dev/storage_impl.h                 |  2 +-
 dev/storage_traits.h               | 24 +++++++++++++++
 examples/blob.cpp                  | 10 ++-----
 examples/custom_aliases.cpp        | 10 ++-----
 examples/distinct.cpp              | 16 ++++------
 examples/group_by.cpp              | 20 +++++--------
 examples/in_memory.cpp             |  7 ++---
 examples/index.cpp                 |  9 ++----
 examples/insert.cpp                | 16 ++++------
 examples/iteration.cpp             | 10 ++-----
 examples/key_value.cpp             |  7 ++---
 examples/natural_join.cpp          | 29 ++++++------------
 examples/nullable_enum_binding.cpp | 10 ++-----
 examples/self_join.cpp             | 47 ++++++++++--------------------
 examples/synchronous.cpp           |  3 +-
 examples/unique.cpp                | 12 ++------
 examples/update.cpp                | 16 ++++------
 include/sqlite_orm/sqlite_orm.h    | 38 +++++++++++++++++++-----
 tests/static_tests.cpp             |  7 ++++-
 third_party/amalgamate/config.json |  3 +-
 22 files changed, 140 insertions(+), 168 deletions(-)
 create mode 100644 dev/storage_traits.h

diff --git a/dev/column_result.h b/dev/column_result.h
index ed02c69ee..261362f0c 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -22,7 +22,7 @@ namespace sqlite_orm {
          *  LENGTH returns INTEGER in sqlite. Every column_result_t must have `type` type that equals
          *  c++ SELECT return type for T
          *  T - C++ type
-         *  Ts - tables pack from storage. Rarely used. Required in asterisk to define columns mapped for a type
+         *  SFINAE - sfinae argument
          */
         template<class T, class SFINAE = void>
         struct column_result_t;
diff --git a/dev/storage.h b/dev/storage.h
index e83a52f6b..0f74b3df1 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -54,7 +54,7 @@ namespace sqlite_orm {
          */
         template<class ...Ts>
         struct storage_t {
-            using storage_type = storage_t<Ts...>;
+            using self = storage_t<Ts...>;
             using impl_type = storage_impl<Ts...>;
             
             template<class T, class ...Args>
@@ -208,7 +208,7 @@ namespace sqlite_orm {
             
             std::function<void(sqlite3*)> on_open;
             
-            transaction_guard_t<storage_type> transaction_guard() {
+            transaction_guard_t<self> transaction_guard() {
                 this->begin_transaction();
                 return {*this};
             }
@@ -221,7 +221,7 @@ namespace sqlite_orm {
              */
             storage_t(const std::string &filename_, impl_type impl_):
             filename(filename_),
-            impl(impl_),
+            impl(std::move(impl_)),
             inMemory(filename_.empty() || filename_ == ":memory:"),
             pragma(*this),
             limit(*this){
@@ -3150,12 +3150,12 @@ namespace sqlite_orm {
                 }
             }
             
-            using pragma_type = pragma_t<storage_type>;
+            using pragma_type = pragma_t<self>;
             
             friend pragma_type;
         public:
             pragma_type pragma;
-            limit_accesor<storage_type> limit;
+            limit_accesor<self> limit;
         };
     }
     
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 1e25163d4..b79ae4daf 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -35,6 +35,7 @@ namespace sqlite_orm {
         template<class H, class ...Ts>
         struct storage_impl<H, Ts...> : public storage_impl<Ts...> {
             using table_type = H;
+            using super = storage_impl<Ts...>;
             
             storage_impl(H h, Ts ...ts) : super(std::forward<Ts>(ts)...), table(std::move(h)) {}
             
@@ -418,7 +419,6 @@ namespace sqlite_orm {
             
             
         private:
-            using super = storage_impl<Ts...>;
             using self = storage_impl<H, Ts...>;
         };
         
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
new file mode 100644
index 000000000..043c62ce3
--- /dev/null
+++ b/dev/storage_traits.h
@@ -0,0 +1,24 @@
+#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type
+
+namespace sqlite_orm {
+    
+    namespace internal {
+        
+        template<class S, class T, class SFINAE = void>
+        struct type_is_mapped_impl;
+        
+        template<class S, class T>
+        struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
+        
+        template<class T>
+        struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
+        
+        template<class S, class T>
+        struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
+        
+        template<class S, class T>
+        struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
+        : type_is_mapped_impl<typename S::super, T> {};
+
+    }
+}
diff --git a/examples/blob.cpp b/examples/blob.cpp
index 74377ee60..d4c84422d 100644
--- a/examples/blob.cpp
+++ b/examples/blob.cpp
@@ -18,13 +18,9 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("blob.sqlite",
                                 make_table("users",
-                                           make_column("id",
-                                                       &User::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &User::name),
-                                           make_column("hash",
-                                                       &User::hash)));
+                                           make_column("id", &User::id, primary_key()),
+                                           make_column("name", &User::name),
+                                           make_column("hash", &User::hash)));
     storage.sync_schema();
     storage.remove_all<User>();
 
diff --git a/examples/custom_aliases.cpp b/examples/custom_aliases.cpp
index 8584df727..6003769cf 100644
--- a/examples/custom_aliases.cpp
+++ b/examples/custom_aliases.cpp
@@ -1,10 +1,6 @@
-//
-//  custom_aliases.cpp
-//  CPPTest
-//
-//  Created by John Zakharov on 12/18/18.
-//  Copyright © 2018 John Zakharov. All rights reserved.
-//
+/**
+ *  Example is taken from here https://www.tutorialspoint.com/sqlite/sqlite_alias_syntax.htm
+ */
 
 #include <sqlite_orm/sqlite_orm.h>
 #include <string>
diff --git a/examples/distinct.cpp b/examples/distinct.cpp
index df1eaab16..6d1af04db 100644
--- a/examples/distinct.cpp
+++ b/examples/distinct.cpp
@@ -20,17 +20,11 @@ auto initStorage(const std::string &path) {
     using namespace sqlite_orm;
     return make_storage(path,
                         make_table("COMPANY",
-                                   make_column("ID",
-                                               &Employee::id,
-                                               primary_key()),
-                                   make_column("NAME",
-                                               &Employee::name),
-                                   make_column("AGE",
-                                               &Employee::age),
-                                   make_column("ADDRESS",
-                                               &Employee::address),
-                                   make_column("SALARY",
-                                               &Employee::salary)));
+                                   make_column("ID", &Employee::id, primary_key()),
+                                   make_column("NAME", &Employee::name),
+                                   make_column("AGE", &Employee::age),
+                                   make_column("ADDRESS", &Employee::address),
+                                   make_column("SALARY", &Employee::salary)));
 }
 using Storage = decltype(initStorage(""));
 
diff --git a/examples/group_by.cpp b/examples/group_by.cpp
index 8934fa39a..26a7e21d0 100644
--- a/examples/group_by.cpp
+++ b/examples/group_by.cpp
@@ -22,17 +22,11 @@ int main(int argc, char **argv) {
     
     auto storage = make_storage("group_by.sqlite",
                                 make_table("COMPANY",
-                                           make_column("ID",
-                                                       &Employee::id,
-                                                       primary_key()),
-                                           make_column("NAME",
-                                                       &Employee::name),
-                                           make_column("AGE",
-                                                       &Employee::age),
-                                           make_column("ADDRESS",
-                                                       &Employee::address),
-                                           make_column("SALARY",
-                                                       &Employee::salary)));
+                                           make_column("ID", &Employee::id, primary_key()),
+                                           make_column("NAME", &Employee::name),
+                                           make_column("AGE", &Employee::age),
+                                           make_column("ADDRESS", &Employee::address),
+                                           make_column("SALARY", &Employee::salary)));
     storage.sync_schema();
     storage.remove_all<Employee>();
     
@@ -45,7 +39,9 @@ int main(int argc, char **argv) {
     storage.insert(Employee{ -1, "James", 24, "Houston", 10000.0});
     
     //  If you want to know the total amount of salary on each customer, then GROUP BY query would be as follows:
-    //  SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;
+    //  SELECT NAME, SUM(SALARY)
+    //  FROM COMPANY
+    //  GROUP BY NAME;
     auto salaryName = storage.select(columns(&Employee::name, sum(&Employee::salary)),
                                      group_by(&Employee::name));
     for(auto &t : salaryName) {
diff --git a/examples/in_memory.cpp b/examples/in_memory.cpp
index 53ff4f341..ee41ef635 100644
--- a/examples/in_memory.cpp
+++ b/examples/in_memory.cpp
@@ -19,11 +19,8 @@ int main(int argc, char **argv) {
     
     auto storage = make_storage(":memory:",
                                 make_table("rap_artists",
-                                           make_column("id",
-                                                       &RapArtist::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &RapArtist::name)));
+                                           make_column("id", &RapArtist::id, primary_key()),
+                                           make_column("name", &RapArtist::name)));
     cout << "in memory db opened" << endl;
     storage.sync_schema();
     
diff --git a/examples/index.cpp b/examples/index.cpp
index 2b88b0339..8c9c2a23a 100644
--- a/examples/index.cpp
+++ b/examples/index.cpp
@@ -21,12 +21,9 @@ auto storage = make_storage("index.sqlite",
                             make_index("idx_contacts_name", &Contract::firstName, &Contract::lastName),
                             make_unique_index("idx_contacts_email", &Contract::email),
                             make_table("contacts",
-                                       make_column("first_name",
-                                                   &Contract::firstName),
-                                       make_column("last_name",
-                                                   &Contract::lastName),
-                                       make_column("email",
-                                                   &Contract::email)));
+                                       make_column("first_name", &Contract::firstName),
+                                       make_column("last_name", &Contract::lastName),
+                                       make_column("email", &Contract::email)));
 
 int main(int argc, char **argv) {
     
diff --git a/examples/insert.cpp b/examples/insert.cpp
index 616a3e2d0..d06809063 100644
--- a/examples/insert.cpp
+++ b/examples/insert.cpp
@@ -28,17 +28,11 @@ int main(int argc, char **argv) {
     
     auto storage = make_storage("insert.sqlite",
                                 make_table("COMPANY",
-                                           make_column("ID",
-                                                       &Employee::id,
-                                                       primary_key()),
-                                           make_column("NAME",
-                                                       &Employee::name),
-                                           make_column("AGE",
-                                                       &Employee::age),
-                                           make_column("ADDRESS",
-                                                       &Employee::address),
-                                           make_column("SALARY",
-                                                       &Employee::salary)));
+                                           make_column("ID", &Employee::id, primary_key()),
+                                           make_column("NAME", &Employee::name),
+                                           make_column("AGE", &Employee::age),
+                                           make_column("ADDRESS", &Employee::address),
+                                           make_column("SALARY", &Employee::salary)));
     storage.sync_schema();
     storage.remove_all<Employee>();
     
diff --git a/examples/iteration.cpp b/examples/iteration.cpp
index e16a29edc..c3bcadcee 100644
--- a/examples/iteration.cpp
+++ b/examples/iteration.cpp
@@ -16,13 +16,9 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("iteration.sqlite",
                                 make_table("marvel",
-                                           make_column("id",
-                                                       &MarvelHero::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &MarvelHero::name),
-                                           make_column("abilities",
-                                                       &MarvelHero::abilities)));
+                                           make_column("id", &MarvelHero::id, primary_key()),
+                                           make_column("name", &MarvelHero::name),
+                                           make_column("abilities", &MarvelHero::abilities)));
     storage.sync_schema();
     
     storage.remove_all<MarvelHero>();
diff --git a/examples/key_value.cpp b/examples/key_value.cpp
index 1e6ebbdb8..a9643fb8b 100644
--- a/examples/key_value.cpp
+++ b/examples/key_value.cpp
@@ -32,11 +32,8 @@ auto& getStorage() {
     using namespace sqlite_orm;
     static auto storage = make_storage("key_value_example.sqlite",
                                        make_table("key_value",
-                                                  make_column("key",
-                                                              &KeyValue::key,
-                                                              primary_key()),
-                                                  make_column("value",
-                                                              &KeyValue::value)));
+                                                  make_column("key", &KeyValue::key, primary_key()),
+                                                  make_column("value", &KeyValue::value)));
     return storage;
 }
 
diff --git a/examples/natural_join.cpp b/examples/natural_join.cpp
index e208c811f..3028a7ef2 100644
--- a/examples/natural_join.cpp
+++ b/examples/natural_join.cpp
@@ -32,28 +32,17 @@ int main(){
     
     auto storage = make_storage("natural_join.sqlite",
                                 make_table("doctors",
-                                           make_column("doctor_id",
-                                                       &Doctor::doctor_id,
-                                                       primary_key()),
-                                           make_column("doctor_name",
-                                                       &Doctor::doctor_name),
-                                           make_column("degree",
-                                                       &Doctor::degree)),
+                                           make_column("doctor_id", &Doctor::doctor_id, primary_key()),
+                                           make_column("doctor_name", &Doctor::doctor_name),
+                                           make_column("degree", &Doctor::degree)),
                                 make_table("speciality",
-                                           make_column("spl_id",
-                                                       &Speciality::spl_id,
-                                                       primary_key()),
-                                           make_column("spl_descrip",
-                                                       &Speciality::spl_descrip),
-                                           make_column("doctor_id",
-                                                       &Speciality::doctor_id)),
+                                           make_column("spl_id", &Speciality::spl_id, primary_key()),
+                                           make_column("spl_descrip", &Speciality::spl_descrip),
+                                           make_column("doctor_id", &Speciality::doctor_id)),
                                 make_table("visits",
-                                           make_column("doctor_id",
-                                                       &Visit::doctor_id),
-                                           make_column("patient_name",
-                                                       &Visit::patient_name),
-                                           make_column("vdate",
-                                                       &Visit::vdate)));
+                                           make_column("doctor_id", &Visit::doctor_id),
+                                           make_column("patient_name", &Visit::patient_name),
+                                           make_column("vdate", &Visit::vdate)));
     storage.sync_schema();
     storage.remove_all<Doctor>();
     storage.remove_all<Speciality>();
diff --git a/examples/nullable_enum_binding.cpp b/examples/nullable_enum_binding.cpp
index eef5dc2dc..36dcd1515 100644
--- a/examples/nullable_enum_binding.cpp
+++ b/examples/nullable_enum_binding.cpp
@@ -108,13 +108,9 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("nullable_enum.sqlite",
                                 make_table("users",
-                                           make_column("id",
-                                                       &User::id,
-                                                       primary_key()),
-                                           make_column("name",
-                                                       &User::name),
-                                           make_column("gender",
-                                                       &User::gender)));
+                                           make_column("id", &User::id, primary_key()),
+                                           make_column("name", &User::name),
+                                           make_column("gender", &User::gender)));
     storage.sync_schema();
     storage.remove_all<User>();
 
diff --git a/examples/self_join.cpp b/examples/self_join.cpp
index e59f2c2a5..ce07ebfb7 100644
--- a/examples/self_join.cpp
+++ b/examples/self_join.cpp
@@ -46,38 +46,21 @@ int main() {
     using namespace sqlite_orm;
     auto storage = make_storage("self_join.sqlite",
                                 make_table("employees",
-                                           make_column("EmployeeId",
-                                                       &Employee::employeeId,
-                                                       autoincrement(),
-                                                       primary_key()),
-                                           make_column("LastName",
-                                                       &Employee::lastName),
-                                           make_column("FirstName",
-                                                       &Employee::firstName),
-                                           make_column("Title",
-                                                       &Employee::title),
-                                           make_column("ReportsTo",
-                                                       &Employee::reportsTo),
-                                           make_column("BirthDate",
-                                                       &Employee::birthDate),
-                                           make_column("HireDate",
-                                                       &Employee::hireDate),
-                                           make_column("Address",
-                                                       &Employee::address),
-                                           make_column("City",
-                                                       &Employee::city),
-                                           make_column("State",
-                                                       &Employee::state),
-                                           make_column("Country",
-                                                       &Employee::country),
-                                           make_column("PostalCode",
-                                                       &Employee::postalCode),
-                                           make_column("Phone",
-                                                       &Employee::phone),
-                                           make_column("Fax",
-                                                       &Employee::fax),
-                                           make_column("Email",
-                                                       &Employee::email),
+                                           make_column("EmployeeId", &Employee::employeeId, autoincrement(), primary_key()),
+                                           make_column("LastName", &Employee::lastName),
+                                           make_column("FirstName", &Employee::firstName),
+                                           make_column("Title", &Employee::title),
+                                           make_column("ReportsTo", &Employee::reportsTo),
+                                           make_column("BirthDate", &Employee::birthDate),
+                                           make_column("HireDate", &Employee::hireDate),
+                                           make_column("Address", &Employee::address),
+                                           make_column("City", &Employee::city),
+                                           make_column("State", &Employee::state),
+                                           make_column("Country", &Employee::country),
+                                           make_column("PostalCode", &Employee::postalCode),
+                                           make_column("Phone", &Employee::phone),
+                                           make_column("Fax", &Employee::fax),
+                                           make_column("Email", &Employee::email),
                                            foreign_key(&Employee::reportsTo).references(&Employee::employeeId)));
     storage.sync_schema();
     storage.remove_all<Employee>();
diff --git a/examples/synchronous.cpp b/examples/synchronous.cpp
index 5d60848b2..7676850ff 100644
--- a/examples/synchronous.cpp
+++ b/examples/synchronous.cpp
@@ -25,8 +25,7 @@ int main(int argc, char** argv) {
                                            make_column("type", &Query::type),
                                            make_column("src_ip", &Query::src_ip),
                                            make_column("src_port", &Query::src_port),
-                                           make_column("txn_id", &Query::txn_id))
-                                );
+                                           make_column("txn_id", &Query::txn_id)));
     storage.sync_schema();
     storage.pragma.synchronous(0);
     storage.remove_all<Query>();
diff --git a/examples/unique.cpp b/examples/unique.cpp
index 905379687..2fbee915c 100644
--- a/examples/unique.cpp
+++ b/examples/unique.cpp
@@ -18,15 +18,9 @@ int main(int argc, char **argv) {
     using namespace sqlite_orm;
     auto storage = make_storage("unique.sqlite",
                                 make_table("unique_test",
-                                           make_column("id",
-                                                       &Entry::id,
-                                                       autoincrement(),
-                                                       primary_key()),
-                                           make_column("unique_text",
-                                                       &Entry::uniqueColumn,
-                                                       unique()),
-                                           make_column("nullable_text",
-                                                       &Entry::nullableColumn)));
+                                           make_column("id", &Entry::id, autoincrement(), primary_key()),
+                                           make_column("unique_text", &Entry::uniqueColumn, unique()),
+                                           make_column("nullable_text", &Entry::nullableColumn)));
     storage.sync_schema();
     storage.remove_all<Entry>();
     
diff --git a/examples/update.cpp b/examples/update.cpp
index b35c082eb..3e44f065e 100644
--- a/examples/update.cpp
+++ b/examples/update.cpp
@@ -21,17 +21,11 @@ inline auto initStorage(const std::string &path) {
     using namespace sqlite_orm;
     return make_storage(path,
                         make_table("COMPANY",
-                                   make_column("ID",
-                                               &Employee::id,
-                                               primary_key()),
-                                   make_column("NAME",
-                                               &Employee::name),
-                                   make_column("AGE",
-                                               &Employee::age),
-                                   make_column("ADDRESS",
-                                               &Employee::address),
-                                   make_column("SALARY",
-                                               &Employee::salary)));
+                                   make_column("ID", &Employee::id, primary_key()),
+                                   make_column("NAME", &Employee::name),
+                                   make_column("AGE", &Employee::age),
+                                   make_column("ADDRESS", &Employee::address),
+                                   make_column("SALARY", &Employee::salary)));
 }
 
 using Storage = decltype(initStorage(""));
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index e0ccbed23..bcbcb3483 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4388,7 +4388,7 @@ namespace sqlite_orm {
          *  LENGTH returns INTEGER in sqlite. Every column_result_t must have `type` type that equals
          *  c++ SELECT return type for T
          *  T - C++ type
-         *  Ts - tables pack from storage. Rarely used. Required in asterisk to define columns mapped for a type
+         *  SFINAE - sfinae argument
          */
         template<class T, class SFINAE = void>
         struct column_result_t;
@@ -5198,6 +5198,7 @@ namespace sqlite_orm {
         template<class H, class ...Ts>
         struct storage_impl<H, Ts...> : public storage_impl<Ts...> {
             using table_type = H;
+            using super = storage_impl<Ts...>;
             
             storage_impl(H h, Ts ...ts) : super(std::forward<Ts>(ts)...), table(std::move(h)) {}
             
@@ -5581,7 +5582,6 @@ namespace sqlite_orm {
             
             
         private:
-            using super = storage_impl<Ts...>;
             using self = storage_impl<H, Ts...>;
         };
         
@@ -6116,7 +6116,7 @@ namespace sqlite_orm {
          */
         template<class ...Ts>
         struct storage_t {
-            using storage_type = storage_t<Ts...>;
+            using self = storage_t<Ts...>;
             using impl_type = storage_impl<Ts...>;
             
             template<class T, class ...Args>
@@ -6270,7 +6270,7 @@ namespace sqlite_orm {
             
             std::function<void(sqlite3*)> on_open;
             
-            transaction_guard_t<storage_type> transaction_guard() {
+            transaction_guard_t<self> transaction_guard() {
                 this->begin_transaction();
                 return {*this};
             }
@@ -6283,7 +6283,7 @@ namespace sqlite_orm {
              */
             storage_t(const std::string &filename_, impl_type impl_):
             filename(filename_),
-            impl(impl_),
+            impl(std::move(impl_)),
             inMemory(filename_.empty() || filename_ == ":memory:"),
             pragma(*this),
             limit(*this){
@@ -9212,12 +9212,12 @@ namespace sqlite_orm {
                 }
             }
             
-            using pragma_type = pragma_t<storage_type>;
+            using pragma_type = pragma_t<self>;
             
             friend pragma_type;
         public:
             pragma_type pragma;
-            limit_accesor<storage_type> limit;
+            limit_accesor<self> limit;
         };
     }
     
@@ -9245,3 +9245,27 @@ __pragma(pop_macro("max"))
 # undef __RESTORE_MAX__
 # endif
 #endif // defined(_MSC_VER)
+#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type
+
+namespace sqlite_orm {
+    
+    namespace internal {
+        
+        template<class S, class T, class SFINAE = void>
+        struct type_is_mapped_impl;
+        
+        template<class S, class T>
+        struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
+        
+        template<class T>
+        struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
+        
+        template<class S, class T>
+        struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
+        
+        template<class S, class T>
+        struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
+        : type_is_mapped_impl<typename S::super, T> {};
+
+    }
+}
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 387392233..986db0f05 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -241,7 +241,12 @@ int main() {
         using IdsTuple = SelectVectorTuple::value_type;
         static_assert(std::tuple_size<IdsTuple>::value == 1, "Incorrect tuple size");
     }
-    
+    {
+        //  test storage traits
+        struct Visit {};
+        static_assert(internal::type_is_mapped<decltype(storage), User>::value, "User must be mapped to a storage");
+        static_assert(!internal::type_is_mapped<decltype(storage), Visit>::value, "User must be mapped to a storage");
+    }
     
     return 0;
 }
diff --git a/third_party/amalgamate/config.json b/third_party/amalgamate/config.json
index d2800e210..63f95d24e 100755
--- a/third_party/amalgamate/config.json
+++ b/third_party/amalgamate/config.json
@@ -39,7 +39,8 @@
 		"dev/table.h",
 		"dev/storage_impl.h",
 		"dev/storage.h",
-		"dev/finish_macros.h"
+		"dev/finish_macros.h",
+        "dev/storage_traits.h"
 	],
 	"include_paths": ["dev"]
 }

From 88706fc7eccaf6a8b9823a602a41d421dfb4e4c5 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Fri, 21 Dec 2018 11:42:15 +0300
Subject: [PATCH 29/63] added storage traits

---
 .travis.yml                     |  2 ++
 dev/storage.h                   |  8 ++++-
 dev/storage_impl.h              |  8 ++++-
 dev/storage_traits.h            | 44 ++++++++++++++----------
 include/sqlite_orm/sqlite_orm.h | 60 ++++++++++++++++++++++-----------
 tests/static_tests.cpp          | 10 ++++--
 6 files changed, 92 insertions(+), 40 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index cba25a916..bf1cc60f9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -77,3 +77,5 @@ script:
   - ./a.out
   - clang++ -std=c++1y examples/except_intersection.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
   - ./a.out
+  - clang++ -std=c++1y examples/custom_aliases.cpp sqlite.static -I include/ -I sqlite_amalgamation/ -ldl -lpthread -o a.out
+  - ./a.out
diff --git a/dev/storage.h b/dev/storage.h
index 0f74b3df1..e2f6535b7 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -3,7 +3,7 @@
 #include <memory>   //  std::shared_ptr, std::make_shared
 #include <string>   //  std::string
 #include <sqlite3.h>
-#include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay
+#include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay, std::false_type, std::true_type
 #include <cstddef>  //  std::ptrdiff_t
 #include <iterator> //  std::input_iterator_tag, std::iterator_traits, std::distance
 #include <system_error> //  std::system_error
@@ -3157,6 +3157,12 @@ namespace sqlite_orm {
             pragma_type pragma;
             limit_accesor<self> limit;
         };
+        
+        template<class T>
+        struct is_storage : std::false_type {};
+        
+        template<class ...Ts>
+        struct is_storage<storage_t<Ts...>> : std::true_type {};
     }
     
     template<class ...Ts>
diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index b79ae4daf..8a702da57 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -6,7 +6,7 @@
 #include <system_error> //  std::system_error, std::error_code
 #include <sstream>  //  std::stringstream
 #include <cstdlib>  //  std::atoi
-#include <type_traits>  //  std::forward, std::enable_if, std::is_same, std::remove_reference
+#include <type_traits>  //  std::forward, std::enable_if, std::is_same, std::remove_reference, std::false_type, std::true_type
 #include <utility>  //  std::pair, std::make_pair
 #include <vector>   //  std::vector
 #include <algorithm>    //  std::find_if
@@ -552,5 +552,11 @@ namespace sqlite_orm {
                 return res;
             }
         };
+        
+        template<class T>
+        struct is_storage_impl : std::false_type {};
+        
+        template<class ...Ts>
+        struct is_storage_impl<storage_impl<Ts...>> : std::true_type {};
     }
 }
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 043c62ce3..41592719c 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -1,24 +1,34 @@
-#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type
+#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
 
 namespace sqlite_orm {
     
     namespace internal {
         
-        template<class S, class T, class SFINAE = void>
-        struct type_is_mapped_impl;
-        
-        template<class S, class T>
-        struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
-        
-        template<class T>
-        struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
-        
-        template<class S, class T>
-        struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
-        
-        template<class S, class T>
-        struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-        : type_is_mapped_impl<typename S::super, T> {};
-
+        namespace storage_traits {
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct type_is_mapped_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
+            
+            template<class T>
+            struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
+            
+            template<class S, class T>
+            struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
+            
+            template<class S, class T>
+            struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
+            : type_is_mapped_impl<typename S::super, T> {};
+        }
     }
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index bcbcb3483..2dc31f65e 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -5131,7 +5131,7 @@ namespace sqlite_orm {
 #include <system_error> //  std::system_error, std::error_code
 #include <sstream>  //  std::stringstream
 #include <cstdlib>  //  std::atoi
-#include <type_traits>  //  std::forward, std::enable_if, std::is_same, std::remove_reference
+#include <type_traits>  //  std::forward, std::enable_if, std::is_same, std::remove_reference, std::false_type, std::true_type
 #include <utility>  //  std::pair, std::make_pair
 #include <vector>   //  std::vector
 #include <algorithm>    //  std::find_if
@@ -5715,6 +5715,12 @@ namespace sqlite_orm {
                 return res;
             }
         };
+        
+        template<class T>
+        struct is_storage_impl : std::false_type {};
+        
+        template<class ...Ts>
+        struct is_storage_impl<storage_impl<Ts...>> : std::true_type {};
     }
 }
 #pragma once
@@ -5722,7 +5728,7 @@ namespace sqlite_orm {
 #include <memory>   //  std::shared_ptr, std::make_shared
 #include <string>   //  std::string
 #include <sqlite3.h>
-#include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay
+#include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay, std::false_type, std::true_type
 #include <cstddef>  //  std::ptrdiff_t
 #include <iterator> //  std::input_iterator_tag, std::iterator_traits, std::distance
 #include <system_error> //  std::system_error
@@ -9219,6 +9225,12 @@ namespace sqlite_orm {
             pragma_type pragma;
             limit_accesor<self> limit;
         };
+        
+        template<class T>
+        struct is_storage : std::false_type {};
+        
+        template<class ...Ts>
+        struct is_storage<storage_t<Ts...>> : std::true_type {};
     }
     
     template<class ...Ts>
@@ -9245,27 +9257,37 @@ __pragma(pop_macro("max"))
 # undef __RESTORE_MAX__
 # endif
 #endif // defined(_MSC_VER)
-#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type
+#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
 
 namespace sqlite_orm {
     
     namespace internal {
         
-        template<class S, class T, class SFINAE = void>
-        struct type_is_mapped_impl;
-        
-        template<class S, class T>
-        struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
-        
-        template<class T>
-        struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
-        
-        template<class S, class T>
-        struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
-        
-        template<class S, class T>
-        struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-        : type_is_mapped_impl<typename S::super, T> {};
-
+        namespace storage_traits {
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct type_is_mapped_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
+            
+            template<class T>
+            struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
+            
+            template<class S, class T>
+            struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
+            
+            template<class S, class T>
+            struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
+            : type_is_mapped_impl<typename S::super, T> {};
+        }
     }
 }
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 986db0f05..10142ab6b 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -244,8 +244,14 @@ int main() {
     {
         //  test storage traits
         struct Visit {};
-        static_assert(internal::type_is_mapped<decltype(storage), User>::value, "User must be mapped to a storage");
-        static_assert(!internal::type_is_mapped<decltype(storage), Visit>::value, "User must be mapped to a storage");
+        using namespace sqlite_orm::internal::storage_traits;
+        static_assert(type_is_mapped<decltype(storage), User>::value, "User must be mapped to a storage");
+        static_assert(!type_is_mapped<decltype(storage), Visit>::value, "User must be mapped to a storage");
+        
+        static_assert(internal::is_storage<decltype(storage)>::value, "is_storage works incorrectly");
+        static_assert(!internal::is_storage<User>::value, "is_storage works incorrectly");
+        static_assert(!internal::is_storage<int>::value, "is_storage works incorrectly");
+        static_assert(!internal::is_storage<void>::value, "is_storage works incorrectly");
     }
     
     return 0;

From 1c92340ee70548a3e07f9adfa4c1716036301907 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 25 Dec 2018 00:17:13 +0300
Subject: [PATCH 30/63] added storage_columns_count and refactored
 columns_count in table

---
 dev/storage.h                   |  2 +-
 dev/storage_traits.h            | 30 ++++++++++++++++
 dev/table.h                     |  8 ++---
 dev/table_impl.h                | 20 +++++------
 dev/table_type.h                |  1 +
 include/sqlite_orm/sqlite_orm.h | 61 ++++++++++++++++++++++++---------
 tests/static_tests.cpp          |  7 ++++
 7 files changed, 97 insertions(+), 32 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index e2f6535b7..5b553499c 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -352,7 +352,7 @@ namespace sqlite_orm {
             void create_table(sqlite3 *db, const std::string &tableName, I *impl) {
                 std::stringstream ss;
                 ss << "CREATE TABLE '" << tableName << "' ( ";
-                auto columnsCount = impl->table.columns_count();
+                auto columnsCount = impl->table.columns_count;
                 auto index = 0;
                 impl->table.for_each_column_with_constraints([columnsCount, &index, &ss, this] (auto c) {
                     ss << this->serialize_column_schema(c);
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 41592719c..291b11d3f 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -20,6 +20,9 @@ namespace sqlite_orm {
             template<class S, class T>
             struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
             
+            /**
+             *  Final specialisation
+             */
             template<class T>
             struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
             
@@ -29,6 +32,33 @@ namespace sqlite_orm {
             template<class S, class T>
             struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
             : type_is_mapped_impl<typename S::super, T> {};
+            
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct storage_columns_count_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct storage_columns_count_impl<storage_impl<>, T, void> : std::integral_constant<int, 0> {};
+            
+            template<class S, class T>
+            struct storage_columns_count_impl<S, T,  typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::integral_constant<int, S::table_type::columns_count> {};
+            
+            template<class S, class T>
+            struct storage_columns_count_impl<S, T,  typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_columns_count_impl<typename S::super, T> {};
         }
     }
 }
diff --git a/dev/table.h b/dev/table.h
index 4e6db22ec..7d5d71630 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -28,6 +28,8 @@ namespace sqlite_orm {
             using impl_type = table_impl<Cs...>;
             using object_type = T;
             
+            static constexpr const int columns_count = impl_type::columns_count;
+            
             /**
              *  Table name.
              */
@@ -127,10 +129,6 @@ namespace sqlite_orm {
                 return res;
             }
             
-            int columns_count() const {
-                return this->impl.columns_count();
-            }
-            
             /**
              *  Searches column name by class member pointer passed as first argument.
              *  @return column name or empty string if nothing found.
@@ -238,7 +236,7 @@ namespace sqlite_orm {
             
             std::vector<table_info> get_table_info() {
                 std::vector<table_info> res;
-                res.reserve(size_t(this->columns_count()));
+                res.reserve(size_t(this->columns_count));
                 this->for_each_column([&res](auto &col){
                     std::string dft;
                     using field_type = typename std::remove_reference<decltype(col)>::type::field_type;
diff --git a/dev/table_impl.h b/dev/table_impl.h
index 71c356fda..44b77b3c5 100644
--- a/dev/table_impl.h
+++ b/dev/table_impl.h
@@ -19,9 +19,14 @@ namespace sqlite_orm {
         template<typename... Args>
         struct table_impl;
         
+        /**
+         *  Final superclass for table_impl.
+         */
         template<>
         struct table_impl<>{
             
+            static constexpr const int columns_count = 0;
+            
             std::vector<std::string> column_names() {
                 return {};
             }
@@ -54,24 +59,22 @@ namespace sqlite_orm {
             template<class L>
             void for_each_primary_key(L) {}
             
-            int columns_count() const {
-                return 0;
-            }
-            
         };
         
+        /**
+         *  Regular table_impl class.
+         */
         template<typename H, typename... T>
         struct table_impl<H, T...> : private table_impl<T...> {
             using column_type = H;
             using tail_types = std::tuple<T...>;
+            using super = table_impl<T...>;
             
             table_impl(H h, T ...t) : super(t...), col(h) {}
             
             column_type col;
             
-            int columns_count() const {
-                return 1 + this->super::columns_count();
-            }
+            static constexpr const int columns_count = 1 + super::columns_count;
             
             /**
              *  column_names_with implementation. Notice that result will be reversed.
@@ -148,9 +151,6 @@ namespace sqlite_orm {
             
             template<class L>
             void apply_to_col_if(L&, std::false_type) {}
-            
-        private:
-            using super = table_impl<T...>;
         };
     }
 }
diff --git a/dev/table_type.h b/dev/table_type.h
index 46d94b584..b235cd2f5 100644
--- a/dev/table_type.h
+++ b/dev/table_type.h
@@ -11,6 +11,7 @@ namespace sqlite_orm {
         
         /**
          *  Trait class used to define table mapped type by setter/getter/member
+         *  T - member pointer
          */
         template<class T, class SFINAE = void>
         struct table_type;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 2dc31f65e..b211d08af 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3545,6 +3545,7 @@ namespace sqlite_orm {
         
         /**
          *  Trait class used to define table mapped type by setter/getter/member
+         *  T - member pointer
          */
         template<class T, class SFINAE = void>
         struct table_type;
@@ -4682,9 +4683,14 @@ namespace sqlite_orm {
         template<typename... Args>
         struct table_impl;
         
+        /**
+         *  Final superclass for table_impl.
+         */
         template<>
         struct table_impl<>{
             
+            static constexpr const int columns_count = 0;
+            
             std::vector<std::string> column_names() {
                 return {};
             }
@@ -4717,24 +4723,22 @@ namespace sqlite_orm {
             template<class L>
             void for_each_primary_key(L) {}
             
-            int columns_count() const {
-                return 0;
-            }
-            
         };
         
+        /**
+         *  Regular table_impl class.
+         */
         template<typename H, typename... T>
         struct table_impl<H, T...> : private table_impl<T...> {
             using column_type = H;
             using tail_types = std::tuple<T...>;
+            using super = table_impl<T...>;
             
             table_impl(H h, T ...t) : super(t...), col(h) {}
             
             column_type col;
             
-            int columns_count() const {
-                return 1 + this->super::columns_count();
-            }
+            static constexpr const int columns_count = 1 + super::columns_count;
             
             /**
              *  column_names_with implementation. Notice that result will be reversed.
@@ -4811,9 +4815,6 @@ namespace sqlite_orm {
             
             template<class L>
             void apply_to_col_if(L&, std::false_type) {}
-            
-        private:
-            using super = table_impl<T...>;
         };
     }
 }
@@ -4856,6 +4857,8 @@ namespace sqlite_orm {
             using impl_type = table_impl<Cs...>;
             using object_type = T;
             
+            static constexpr const int columns_count = impl_type::columns_count;
+            
             /**
              *  Table name.
              */
@@ -4955,10 +4958,6 @@ namespace sqlite_orm {
                 return res;
             }
             
-            int columns_count() const {
-                return this->impl.columns_count();
-            }
-            
             /**
              *  Searches column name by class member pointer passed as first argument.
              *  @return column name or empty string if nothing found.
@@ -5066,7 +5065,7 @@ namespace sqlite_orm {
             
             std::vector<table_info> get_table_info() {
                 std::vector<table_info> res;
-                res.reserve(size_t(this->columns_count()));
+                res.reserve(size_t(this->columns_count));
                 this->for_each_column([&res](auto &col){
                     std::string dft;
                     using field_type = typename std::remove_reference<decltype(col)>::type::field_type;
@@ -6420,7 +6419,7 @@ namespace sqlite_orm {
             void create_table(sqlite3 *db, const std::string &tableName, I *impl) {
                 std::stringstream ss;
                 ss << "CREATE TABLE '" << tableName << "' ( ";
-                auto columnsCount = impl->table.columns_count();
+                auto columnsCount = impl->table.columns_count;
                 auto index = 0;
                 impl->table.for_each_column_with_constraints([columnsCount, &index, &ss, this] (auto c) {
                     ss << this->serialize_column_schema(c);
@@ -9279,6 +9278,9 @@ namespace sqlite_orm {
             template<class S, class T>
             struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
             
+            /**
+             *  Final specialisation
+             */
             template<class T>
             struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
             
@@ -9288,6 +9290,33 @@ namespace sqlite_orm {
             template<class S, class T>
             struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
             : type_is_mapped_impl<typename S::super, T> {};
+            
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct storage_columns_count_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct storage_columns_count_impl<storage_impl<>, T, void> : std::integral_constant<int, 0> {};
+            
+            template<class S, class T>
+            struct storage_columns_count_impl<S, T,  typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::integral_constant<int, S::table_type::columns_count> {};
+            
+            template<class S, class T>
+            struct storage_columns_count_impl<S, T,  typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_columns_count_impl<typename S::super, T> {};
         }
     }
 }
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 10142ab6b..14e64ff0e 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -245,13 +245,20 @@ int main() {
         //  test storage traits
         struct Visit {};
         using namespace sqlite_orm::internal::storage_traits;
+        
+        //  test type_is_mapped
         static_assert(type_is_mapped<decltype(storage), User>::value, "User must be mapped to a storage");
         static_assert(!type_is_mapped<decltype(storage), Visit>::value, "User must be mapped to a storage");
         
+        //  test is_storage
         static_assert(internal::is_storage<decltype(storage)>::value, "is_storage works incorrectly");
         static_assert(!internal::is_storage<User>::value, "is_storage works incorrectly");
         static_assert(!internal::is_storage<int>::value, "is_storage works incorrectly");
         static_assert(!internal::is_storage<void>::value, "is_storage works incorrectly");
+        
+        //  test storage_columns_count
+        static_assert(storage_columns_count<decltype(storage), User>::value == 1, "Incorrect storage columns count value");
+        static_assert(storage_columns_count<decltype(storage), Visit>::value == 0, "Incorrect storage columns count value");
     }
     
     return 0;

From 6390e9c3df17409079e3745638369dfde2e479fb Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 25 Dec 2018 01:06:19 +0300
Subject: [PATCH 31/63] added storage_mapped_columns

---
 dev/storage_traits.h            | 50 +++++++++++++++++++++++++++++++++
 include/sqlite_orm/sqlite_orm.h | 50 +++++++++++++++++++++++++++++++++
 tests/static_tests.cpp          | 21 +++++++++++++-
 3 files changed, 120 insertions(+), 1 deletion(-)

diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index 291b11d3f..c75722db7 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -1,4 +1,5 @@
 #include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
+#include <tuple>    //  std::tuple
 
 namespace sqlite_orm {
     
@@ -59,6 +60,55 @@ namespace sqlite_orm {
             
             template<class S, class T>
             struct storage_columns_count_impl<S, T,  typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_columns_count_impl<typename S::super, T> {};
+            
+            
+            /**
+             *  T - table_impl type.
+             */
+            template<class T>
+            struct table_impl_types;
+            
+            /**
+             *  type is std::tuple of field types of mapped colums.
+             */
+            template<typename... Args>
+            struct table_impl_types<table_impl<Args...>> {
+                using type = std::tuple<typename Args::field_type...>;
+            };
+            
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct storage_mapped_columns_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct storage_mapped_columns_impl<storage_impl<>, T, void> {
+                using type = std::tuple<>;
+            };
+            
+            template<class S, class T>
+            struct storage_mapped_columns_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> {
+                using table_type = typename S::table_type;
+                using table_impl_type = typename table_type::impl_type;
+                using type = typename table_impl_types<table_impl_type>::type;
+            };
+            
+            template<class S, class T>
+            struct storage_mapped_columns_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_mapped_columns_impl<typename S::super, T> {};
+            
         }
     }
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index b211d08af..114137bbd 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -9257,6 +9257,7 @@ __pragma(pop_macro("max"))
 # endif
 #endif // defined(_MSC_VER)
 #include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
+#include <tuple>    //  std::tuple
 
 namespace sqlite_orm {
     
@@ -9317,6 +9318,55 @@ namespace sqlite_orm {
             
             template<class S, class T>
             struct storage_columns_count_impl<S, T,  typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_columns_count_impl<typename S::super, T> {};
+            
+            
+            /**
+             *  T - table_impl type.
+             */
+            template<class T>
+            struct table_impl_types;
+            
+            /**
+             *  type is std::tuple of field types of mapped colums.
+             */
+            template<typename... Args>
+            struct table_impl_types<table_impl<Args...>> {
+                using type = std::tuple<typename Args::field_type...>;
+            };
+            
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct storage_mapped_columns_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct storage_mapped_columns_impl<storage_impl<>, T, void> {
+                using type = std::tuple<>;
+            };
+            
+            template<class S, class T>
+            struct storage_mapped_columns_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> {
+                using table_type = typename S::table_type;
+                using table_impl_type = typename table_type::impl_type;
+                using type = typename table_impl_types<table_impl_type>::type;
+            };
+            
+            template<class S, class T>
+            struct storage_mapped_columns_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_mapped_columns_impl<typename S::super, T> {};
+            
         }
     }
 }
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 14e64ff0e..5f01dae25 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -243,7 +243,10 @@ int main() {
     }
     {
         //  test storage traits
-        struct Visit {};
+        struct Visit {
+            int id;
+            std::string date;
+        };
         using namespace sqlite_orm::internal::storage_traits;
         
         //  test type_is_mapped
@@ -256,9 +259,25 @@ int main() {
         static_assert(!internal::is_storage<int>::value, "is_storage works incorrectly");
         static_assert(!internal::is_storage<void>::value, "is_storage works incorrectly");
         
+        auto storage2 = make_storage("",
+                                     make_table("visits",
+                                                make_column("id", &Visit::id, primary_key()),
+                                                make_column("date", &Visit::date)));
+        
         //  test storage_columns_count
         static_assert(storage_columns_count<decltype(storage), User>::value == 1, "Incorrect storage columns count value");
         static_assert(storage_columns_count<decltype(storage), Visit>::value == 0, "Incorrect storage columns count value");
+        static_assert(storage_columns_count<decltype(storage2), Visit>::value == 2, "Incorrect storage columns count value");
+        
+        //  test storage mapped columns
+        using UserColumnsTuple = storage_mapped_columns<decltype(storage), User>::type;
+        static_assert(std::is_same<UserColumnsTuple, std::tuple<int>>::value, "Incorrect storage_mapped_columns result");
+        
+        using VisitColumsEmptyType = storage_mapped_columns<decltype(storage), Visit>::type;
+        static_assert(std::is_same<VisitColumsEmptyType, std::tuple<>>::value, "Incorrect storage_mapped_columns result");
+        
+        using VisitColumnTypes = storage_mapped_columns<decltype(storage2), Visit>::type;
+        static_assert(std::is_same<VisitColumnTypes, std::tuple<int, std::string>>::value, "Incorrect storage_mapped_columns result");
     }
     
     return 0;

From 5eaa84d402bc9bc349fbc9bd35747047cbbf724a Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Wed, 26 Dec 2018 18:33:30 +0300
Subject: [PATCH 32/63] added asterisk select support finally

---
 dev/column_result.h                | 224 +++++++-------
 dev/storage.h                      |  12 +-
 dev/storage_traits.h               |   6 +
 dev/table.h                        |   3 +-
 examples/select.cpp                |  20 ++
 include/sqlite_orm/sqlite_orm.h    | 474 +++++++++++++++--------------
 tests/static_tests.cpp             |  10 +
 tests/tests.cpp                    |  22 ++
 third_party/amalgamate/config.json |   3 +-
 9 files changed, 424 insertions(+), 350 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index 261362f0c..ee31a7fa0 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -10,6 +10,7 @@
 #include "rowid.h"
 #include "alias.h"
 #include "column.h"
+#include "storage_traits.h"
 
 namespace sqlite_orm {
     
@@ -24,250 +25,250 @@ namespace sqlite_orm {
          *  T - C++ type
          *  SFINAE - sfinae argument
          */
-        template<class T, class SFINAE = void>
+        template<class St, class T, class SFINAE = void>
         struct column_result_t;
         
-        template<class O, class F>
-        struct column_result_t<F O::*, typename std::enable_if<std::is_member_pointer<F O::*>::value && !std::is_member_function_pointer<F O::*>::value>::type> {
+        template<class St, class O, class F>
+        struct column_result_t<St, F O::*, typename std::enable_if<std::is_member_pointer<F O::*>::value && !std::is_member_function_pointer<F O::*>::value>::type> {
             using type = F;
         };
         
         /**
          *  Common case for all getter types. Getter types are defined in column.h file
          */
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<is_getter<T>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_getter<T>::value>::type> {
             using type = typename getter_traits<T>::field_type;
         };
         
         /**
          *  Common case for all setter types. Setter types are defined in column.h file
          */
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<is_setter<T>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_setter<T>::value>::type> {
             using type = typename setter_traits<T>::field_type;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::length_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::length_t<T>, void> {
             using type = int;
         };
         
 #if SQLITE_VERSION_NUMBER >= 3007016
         
-        template<class ...Args>
-        struct column_result_t<core_functions::char_t_<Args...>, void> {
+        template<class St, class ...Args>
+        struct column_result_t<St, core_functions::char_t_<Args...>, void> {
             using type = std::string;
         };
 #endif
         
-        template<>
-        struct column_result_t<core_functions::random_t, void> {
+        template<class St>
+        struct column_result_t<St, core_functions::random_t, void> {
             using type = int;
         };
         
-        template<>
-        struct column_result_t<core_functions::changes_t, void> {
+        template<class St>
+        struct column_result_t<St, core_functions::changes_t, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::abs_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::abs_t<T>, void> {
             using type = std::shared_ptr<double>;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::lower_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::lower_t<T>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::upper_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::upper_t<T>, void> {
             using type = std::string;
         };
         
-        template<class X>
-        struct column_result_t<core_functions::trim_single_t<X>, void> {
+        template<class St, class X>
+        struct column_result_t<St, core_functions::trim_single_t<X>, void> {
             using type = std::string;
         };
         
-        template<class X, class Y>
-        struct column_result_t<core_functions::trim_double_t<X, Y>, void> {
+        template<class St, class X, class Y>
+        struct column_result_t<St, core_functions::trim_double_t<X, Y>, void> {
             using type = std::string;
         };
         
-        template<class X>
-        struct column_result_t<core_functions::ltrim_single_t<X>, void> {
+        template<class St, class X>
+        struct column_result_t<St, core_functions::ltrim_single_t<X>, void> {
             using type = std::string;
         };
         
-        template<class X, class Y>
-        struct column_result_t<core_functions::ltrim_double_t<X, Y>, void> {
+        template<class St, class X, class Y>
+        struct column_result_t<St, core_functions::ltrim_double_t<X, Y>, void> {
             using type = std::string;
         };
         
-        template<class X>
-        struct column_result_t<core_functions::rtrim_single_t<X>, void> {
+        template<class St, class X>
+        struct column_result_t<St, core_functions::rtrim_single_t<X>, void> {
             using type = std::string;
         };
         
-        template<class X, class Y>
-        struct column_result_t<core_functions::rtrim_double_t<X, Y>, void> {
+        template<class St, class X, class Y>
+        struct column_result_t<St, core_functions::rtrim_double_t<X, Y>, void> {
             using type = std::string;
         };
         
-        template<class T, class ...Args>
-        struct column_result_t<core_functions::date_t<T, Args...>, void> {
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, core_functions::date_t<T, Args...>, void> {
             using type = std::string;
         };
         
-        template<class T, class ...Args>
-        struct column_result_t<core_functions::datetime_t<T, Args...>, void> {
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, core_functions::datetime_t<T, Args...>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::avg_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::avg_t<T>, void> {
             using type = double;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::count_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::count_t<T>, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::count_asterisk_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::count_asterisk_t<T>, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::sum_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::sum_t<T>, void> {
             using type = std::shared_ptr<double>;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::total_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::total_t<T>, void> {
             using type = double;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::group_concat_single_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::group_concat_single_t<T>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::group_concat_double_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::group_concat_double_t<T>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::max_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<T>::type>;
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::max_t<T>, void> {
+            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::min_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<T>::type>;
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::min_t<T>, void> {
+            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
         };
         
-        template<>
-        struct column_result_t<aggregate_functions::count_asterisk_without_type, void> {
+        template<class St>
+        struct column_result_t<St, aggregate_functions::count_asterisk_without_type, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<distinct_t<T>, void> {
-            using type = typename column_result_t<T>::type;
+        template<class St, class T>
+        struct column_result_t<St, distinct_t<T>, void> {
+            using type = typename column_result_t<St, T>::type;
         };
         
-        template<class T>
-        struct column_result_t<all_t<T>, void> {
-            using type = typename column_result_t<T>::type;
+        template<class St, class T>
+        struct column_result_t<St, all_t<T>, void> {
+            using type = typename column_result_t<St, T>::type;
         };
         
-        template<class L, class R>
-        struct column_result_t<conc_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, conc_t<L, R>, void> {
             using type = std::string;
         };
         
-        template<class L, class R>
-        struct column_result_t<add_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, add_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<sub_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, sub_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<mul_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, mul_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<div_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, internal::div_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<mod_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, mod_t<L, R>, void> {
             using type = double;
         };
         
-        template<>
-        struct column_result_t<rowid_t, void> {
+        template<class St>
+        struct column_result_t<St, rowid_t, void> {
             using type = int64;
         };
         
-        template<>
-        struct column_result_t<oid_t, void> {
+        template<class St>
+        struct column_result_t<St, oid_t, void> {
             using type = int64;
         };
         
-        template<>
-        struct column_result_t<_rowid_t, void> {
+        template<class St>
+        struct column_result_t<St, _rowid_t, void> {
             using type = int64;
         };
         
-        template<class T>
-        struct column_result_t<table_rowid_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, table_rowid_t<T>, void> {
             using type = int64;
         };
         
-        template<class T>
-        struct column_result_t<table_oid_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, table_oid_t<T>, void> {
             using type = int64;
         };
         
-        template<class T>
-        struct column_result_t<table__rowid_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, table__rowid_t<T>, void> {
             using type = int64;
         };
         
-        template<class T, class C>
-        struct column_result_t<alias_column_t<T, C>, void> {
-            using type = typename column_result_t<C>::type;
+        template<class St, class T, class C>
+        struct column_result_t<St, alias_column_t<T, C>, void> {
+            using type = typename column_result_t<St, C>::type;
         };
         
-        template<class T, class F>
-        struct column_result_t<column_pointer<T, F>> : column_result_t<F, void> {};
+        template<class St, class T, class F>
+        struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F, void> {};
         
-        template<class ...Args>
-        struct column_result_t<columns_t<Args...>, void> {
-            using type = std::tuple<typename column_result_t<typename std::decay<Args>::type>::type...>;
+        template<class St, class ...Args>
+        struct column_result_t<St, columns_t<Args...>, void> {
+            using type = std::tuple<typename column_result_t<St, typename std::decay<Args>::type>::type...>;
         };
         
-        template<class T, class ...Args>
-        struct column_result_t<select_t<T, Args...>> : column_result_t<T, void> {};
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, select_t<T, Args...>> : column_result_t<St, T, void> {};
         
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
             using left_type = typename T::left_type;
             using right_type = typename T::right_type;
-            using left_result = typename column_result_t<left_type>::type;
-            using right_result = typename column_result_t<right_type>::type;
+            using left_result = typename column_result_t<St, left_type>::type;
+            using right_result = typename column_result_t<St, right_type>::type;
             static_assert(std::is_same<left_result, right_result>::value, "Compound subselect queries must return same types");
             using type = left_result;
         };
@@ -275,20 +276,25 @@ namespace sqlite_orm {
         /**
          *  Result for the most simple queries like `SELECT 1`
          */
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
             using type = T;
         };
         
         /**
          *  Result for the most simple queries like `SELECT 'ototo'`
          */
-        template<>
-        struct column_result_t<const char*, void> {
+        template<class St>
+        struct column_result_t<St, const char*, void> {
             using type = std::string;
         };
         
-        template<class T, class E>
-        struct column_result_t<as_t<T, E>, void> : column_result_t<typename std::decay<E>::type, void> {};
+        template<class St, class T, class E>
+        struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type, void> {};
+        
+        template<class St, class T>
+        struct column_result_t<St, asterisk_t<T>, void> {
+            using type = typename storage_traits::storage_mapped_columns<St, T>::type;
+        };
     }
 }
diff --git a/dev/storage.h b/dev/storage.h
index 5b553499c..5c84e78a1 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -2167,7 +2167,7 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::shared_ptr with max value or null if sqlite engine returned null.
              */
-            template<class F, class O, class ...Args, class Ret = typename column_result_t<F O::*>::type>
+            template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
             std::shared_ptr<Ret> max(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
@@ -2206,7 +2206,7 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::shared_ptr with min value or null if sqlite engine returned null.
              */
-            template<class F, class O, class ...Args, class Ret = typename column_result_t<F O::*>::type>
+            template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
             std::shared_ptr<Ret> min(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
@@ -2245,7 +2245,7 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::shared_ptr with sum value or null if sqlite engine returned null.
              */
-            template<class F, class O, class ...Args, class Ret = typename column_result_t<F O::*>::type>
+            template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
             std::shared_ptr<Ret> sum(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
@@ -2333,7 +2333,7 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename column_result_t<T>::type,
+            class R = typename column_result_t<self, T>::type,
             typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr>
             std::vector<R> select(T m, Args ...args) {
                 using select_type = select_t<T, Args...>;
@@ -2365,7 +2365,7 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class Ret = typename column_result_t<T>::type,
+            class Ret = typename column_result_t<self, T>::type,
             typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
             std::vector<Ret> select(T op, Args ...args) {
                 std::stringstream ss;
@@ -2583,7 +2583,7 @@ namespace sqlite_orm {
                     auto index = 1;
                     cols.for_each([&o, &index, &stmt, &impl] (auto &m) {
                         using column_type = typename std::decay<decltype(m)>::type;
-                        using field_type = typename column_result_t<column_type>::type;
+                        using field_type = typename column_result_t<self, column_type>::type;
                         const field_type *value = impl.table.template get_object_field_pointer<field_type>(o, m);
                         statement_binder<field_type>().bind(stmt, index++, *value);
                     });
diff --git a/dev/storage_traits.h b/dev/storage_traits.h
index c75722db7..ab807bb86 100644
--- a/dev/storage_traits.h
+++ b/dev/storage_traits.h
@@ -5,6 +5,12 @@ namespace sqlite_orm {
     
     namespace internal {
         
+        template<class ...Ts>
+        struct storage_impl;
+        
+        template<typename... Args>
+        struct table_impl;
+        
         namespace storage_traits {
             
             /**
diff --git a/dev/table.h b/dev/table.h
index 7d5d71630..b55b67c61 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -56,8 +56,7 @@ namespace sqlite_orm {
             template<class F, class C>
             const F* get_object_field_pointer(const object_type &obj, C c) {
                 const F *res = nullptr;
-                using field_type = typename internal::column_result_t<C>::type;
-                this->for_each_column_with_field_type<field_type>([&res, &c, &obj, this](auto &col){
+                this->for_each_column_with_field_type<F>([&res, &c, &obj, this](auto &col){
                     using namespace static_magic;
                     using column_type = typename std::remove_reference<decltype(col)>::type;
                     using member_pointer_t = typename column_type::member_pointer_t;
diff --git a/examples/select.cpp b/examples/select.cpp
index c27a554eb..2bf13fe28 100644
--- a/examples/select.cpp
+++ b/examples/select.cpp
@@ -77,4 +77,24 @@ int main(int argc, char **argv) {
         }
         cout << endl;
     }
+    
+    cout << endl;
+    
+    auto allEmployeesTuples = storage.select(asterisk<Employee>());
+    cout << "allEmployeesTuples count = " << allEmployeesTuples.size() << endl;
+    for(auto &row : allEmployeesTuples) {   //  row is std::tuple<int, std::string, int, std::shared_ptr<std::string>, std::shared_ptr<double>>
+        cout << std::get<0>(row) << '\t' << std::get<1>(row) << '\t' << std::get<2>(row) << '\t';
+        if(auto &value = std::get<3>(row)){
+            cout << *value;
+        }else{
+            cout << "null";
+        }
+        cout << '\t';
+        if(auto &value = std::get<4>(row)){
+            cout << *value;
+        }else{
+            cout << "null";
+        }
+        cout << '\t' << endl;
+    }
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 114137bbd..f9447ff96 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4377,6 +4377,128 @@ namespace sqlite_orm {
 
 // #include "column.h"
 
+// #include "storage_traits.h"
+#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
+#include <tuple>    //  std::tuple
+
+namespace sqlite_orm {
+    
+    namespace internal {
+        
+        template<class ...Ts>
+        struct storage_impl;
+        
+        template<typename... Args>
+        struct table_impl;
+        
+        namespace storage_traits {
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct type_is_mapped_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
+            
+            template<class S, class T>
+            struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
+            
+            template<class S, class T>
+            struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
+            : type_is_mapped_impl<typename S::super, T> {};
+            
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct storage_columns_count_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct storage_columns_count_impl<storage_impl<>, T, void> : std::integral_constant<int, 0> {};
+            
+            template<class S, class T>
+            struct storage_columns_count_impl<S, T,  typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::integral_constant<int, S::table_type::columns_count> {};
+            
+            template<class S, class T>
+            struct storage_columns_count_impl<S, T,  typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_columns_count_impl<typename S::super, T> {};
+            
+            
+            /**
+             *  T - table_impl type.
+             */
+            template<class T>
+            struct table_impl_types;
+            
+            /**
+             *  type is std::tuple of field types of mapped colums.
+             */
+            template<typename... Args>
+            struct table_impl_types<table_impl<Args...>> {
+                using type = std::tuple<typename Args::field_type...>;
+            };
+            
+            
+            /**
+             *  S - storage_impl type
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T, class SFINAE = void>
+            struct storage_mapped_columns_impl;
+            
+            /**
+             *  S - storage
+             *  T - mapped or not mapped data type
+             */
+            template<class S, class T>
+            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, T> {};
+            
+            /**
+             *  Final specialisation
+             */
+            template<class T>
+            struct storage_mapped_columns_impl<storage_impl<>, T, void> {
+                using type = std::tuple<>;
+            };
+            
+            template<class S, class T>
+            struct storage_mapped_columns_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> {
+                using table_type = typename S::table_type;
+                using table_impl_type = typename table_type::impl_type;
+                using type = typename table_impl_types<table_impl_type>::type;
+            };
+            
+            template<class S, class T>
+            struct storage_mapped_columns_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_mapped_columns_impl<typename S::super, T> {};
+            
+        }
+    }
+}
+
 
 namespace sqlite_orm {
     
@@ -4391,250 +4513,250 @@ namespace sqlite_orm {
          *  T - C++ type
          *  SFINAE - sfinae argument
          */
-        template<class T, class SFINAE = void>
+        template<class St, class T, class SFINAE = void>
         struct column_result_t;
         
-        template<class O, class F>
-        struct column_result_t<F O::*, typename std::enable_if<std::is_member_pointer<F O::*>::value && !std::is_member_function_pointer<F O::*>::value>::type> {
+        template<class St, class O, class F>
+        struct column_result_t<St, F O::*, typename std::enable_if<std::is_member_pointer<F O::*>::value && !std::is_member_function_pointer<F O::*>::value>::type> {
             using type = F;
         };
         
         /**
          *  Common case for all getter types. Getter types are defined in column.h file
          */
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<is_getter<T>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_getter<T>::value>::type> {
             using type = typename getter_traits<T>::field_type;
         };
         
         /**
          *  Common case for all setter types. Setter types are defined in column.h file
          */
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<is_setter<T>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_setter<T>::value>::type> {
             using type = typename setter_traits<T>::field_type;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::length_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::length_t<T>, void> {
             using type = int;
         };
         
 #if SQLITE_VERSION_NUMBER >= 3007016
         
-        template<class ...Args>
-        struct column_result_t<core_functions::char_t_<Args...>, void> {
+        template<class St, class ...Args>
+        struct column_result_t<St, core_functions::char_t_<Args...>, void> {
             using type = std::string;
         };
 #endif
         
-        template<>
-        struct column_result_t<core_functions::random_t, void> {
+        template<class St>
+        struct column_result_t<St, core_functions::random_t, void> {
             using type = int;
         };
         
-        template<>
-        struct column_result_t<core_functions::changes_t, void> {
+        template<class St>
+        struct column_result_t<St, core_functions::changes_t, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::abs_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::abs_t<T>, void> {
             using type = std::shared_ptr<double>;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::lower_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::lower_t<T>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<core_functions::upper_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, core_functions::upper_t<T>, void> {
             using type = std::string;
         };
         
-        template<class X>
-        struct column_result_t<core_functions::trim_single_t<X>, void> {
+        template<class St, class X>
+        struct column_result_t<St, core_functions::trim_single_t<X>, void> {
             using type = std::string;
         };
         
-        template<class X, class Y>
-        struct column_result_t<core_functions::trim_double_t<X, Y>, void> {
+        template<class St, class X, class Y>
+        struct column_result_t<St, core_functions::trim_double_t<X, Y>, void> {
             using type = std::string;
         };
         
-        template<class X>
-        struct column_result_t<core_functions::ltrim_single_t<X>, void> {
+        template<class St, class X>
+        struct column_result_t<St, core_functions::ltrim_single_t<X>, void> {
             using type = std::string;
         };
         
-        template<class X, class Y>
-        struct column_result_t<core_functions::ltrim_double_t<X, Y>, void> {
+        template<class St, class X, class Y>
+        struct column_result_t<St, core_functions::ltrim_double_t<X, Y>, void> {
             using type = std::string;
         };
         
-        template<class X>
-        struct column_result_t<core_functions::rtrim_single_t<X>, void> {
+        template<class St, class X>
+        struct column_result_t<St, core_functions::rtrim_single_t<X>, void> {
             using type = std::string;
         };
         
-        template<class X, class Y>
-        struct column_result_t<core_functions::rtrim_double_t<X, Y>, void> {
+        template<class St, class X, class Y>
+        struct column_result_t<St, core_functions::rtrim_double_t<X, Y>, void> {
             using type = std::string;
         };
         
-        template<class T, class ...Args>
-        struct column_result_t<core_functions::date_t<T, Args...>, void> {
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, core_functions::date_t<T, Args...>, void> {
             using type = std::string;
         };
         
-        template<class T, class ...Args>
-        struct column_result_t<core_functions::datetime_t<T, Args...>, void> {
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, core_functions::datetime_t<T, Args...>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::avg_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::avg_t<T>, void> {
             using type = double;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::count_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::count_t<T>, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::count_asterisk_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::count_asterisk_t<T>, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::sum_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::sum_t<T>, void> {
             using type = std::shared_ptr<double>;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::total_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::total_t<T>, void> {
             using type = double;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::group_concat_single_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::group_concat_single_t<T>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::group_concat_double_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::group_concat_double_t<T>, void> {
             using type = std::string;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::max_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<T>::type>;
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::max_t<T>, void> {
+            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
         };
         
-        template<class T>
-        struct column_result_t<aggregate_functions::min_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<T>::type>;
+        template<class St, class T>
+        struct column_result_t<St, aggregate_functions::min_t<T>, void> {
+            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
         };
         
-        template<>
-        struct column_result_t<aggregate_functions::count_asterisk_without_type, void> {
+        template<class St>
+        struct column_result_t<St, aggregate_functions::count_asterisk_without_type, void> {
             using type = int;
         };
         
-        template<class T>
-        struct column_result_t<distinct_t<T>, void> {
-            using type = typename column_result_t<T>::type;
+        template<class St, class T>
+        struct column_result_t<St, distinct_t<T>, void> {
+            using type = typename column_result_t<St, T>::type;
         };
         
-        template<class T>
-        struct column_result_t<all_t<T>, void> {
-            using type = typename column_result_t<T>::type;
+        template<class St, class T>
+        struct column_result_t<St, all_t<T>, void> {
+            using type = typename column_result_t<St, T>::type;
         };
         
-        template<class L, class R>
-        struct column_result_t<conc_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, conc_t<L, R>, void> {
             using type = std::string;
         };
         
-        template<class L, class R>
-        struct column_result_t<add_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, add_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<sub_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, sub_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<mul_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, mul_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<div_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, internal::div_t<L, R>, void> {
             using type = double;
         };
         
-        template<class L, class R>
-        struct column_result_t<mod_t<L, R>, void> {
+        template<class St, class L, class R>
+        struct column_result_t<St, mod_t<L, R>, void> {
             using type = double;
         };
         
-        template<>
-        struct column_result_t<rowid_t, void> {
+        template<class St>
+        struct column_result_t<St, rowid_t, void> {
             using type = int64;
         };
         
-        template<>
-        struct column_result_t<oid_t, void> {
+        template<class St>
+        struct column_result_t<St, oid_t, void> {
             using type = int64;
         };
         
-        template<>
-        struct column_result_t<_rowid_t, void> {
+        template<class St>
+        struct column_result_t<St, _rowid_t, void> {
             using type = int64;
         };
         
-        template<class T>
-        struct column_result_t<table_rowid_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, table_rowid_t<T>, void> {
             using type = int64;
         };
         
-        template<class T>
-        struct column_result_t<table_oid_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, table_oid_t<T>, void> {
             using type = int64;
         };
         
-        template<class T>
-        struct column_result_t<table__rowid_t<T>, void> {
+        template<class St, class T>
+        struct column_result_t<St, table__rowid_t<T>, void> {
             using type = int64;
         };
         
-        template<class T, class C>
-        struct column_result_t<alias_column_t<T, C>, void> {
-            using type = typename column_result_t<C>::type;
+        template<class St, class T, class C>
+        struct column_result_t<St, alias_column_t<T, C>, void> {
+            using type = typename column_result_t<St, C>::type;
         };
         
-        template<class T, class F>
-        struct column_result_t<column_pointer<T, F>> : column_result_t<F, void> {};
+        template<class St, class T, class F>
+        struct column_result_t<St, column_pointer<T, F>> : column_result_t<St, F, void> {};
         
-        template<class ...Args>
-        struct column_result_t<columns_t<Args...>, void> {
-            using type = std::tuple<typename column_result_t<typename std::decay<Args>::type>::type...>;
+        template<class St, class ...Args>
+        struct column_result_t<St, columns_t<Args...>, void> {
+            using type = std::tuple<typename column_result_t<St, typename std::decay<Args>::type>::type...>;
         };
         
-        template<class T, class ...Args>
-        struct column_result_t<select_t<T, Args...>> : column_result_t<T, void> {};
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, select_t<T, Args...>> : column_result_t<St, T, void> {};
         
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type> {
             using left_type = typename T::left_type;
             using right_type = typename T::right_type;
-            using left_result = typename column_result_t<left_type>::type;
-            using right_result = typename column_result_t<right_type>::type;
+            using left_result = typename column_result_t<St, left_type>::type;
+            using right_result = typename column_result_t<St, right_type>::type;
             static_assert(std::is_same<left_result, right_result>::value, "Compound subselect queries must return same types");
             using type = left_result;
         };
@@ -4642,21 +4764,26 @@ namespace sqlite_orm {
         /**
          *  Result for the most simple queries like `SELECT 1`
          */
-        template<class T>
-        struct column_result_t<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
+        template<class St, class T>
+        struct column_result_t<St, T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
             using type = T;
         };
         
         /**
          *  Result for the most simple queries like `SELECT 'ototo'`
          */
-        template<>
-        struct column_result_t<const char*, void> {
+        template<class St>
+        struct column_result_t<St, const char*, void> {
             using type = std::string;
         };
         
-        template<class T, class E>
-        struct column_result_t<as_t<T, E>, void> : column_result_t<typename std::decay<E>::type, void> {};
+        template<class St, class T, class E>
+        struct column_result_t<St, as_t<T, E>, void> : column_result_t<St, typename std::decay<E>::type, void> {};
+        
+        template<class St, class T>
+        struct column_result_t<St, asterisk_t<T>, void> {
+            using type = typename storage_traits::storage_mapped_columns<St, T>::type;
+        };
     }
 }
 #pragma once
@@ -4885,8 +5012,7 @@ namespace sqlite_orm {
             template<class F, class C>
             const F* get_object_field_pointer(const object_type &obj, C c) {
                 const F *res = nullptr;
-                using field_type = typename internal::column_result_t<C>::type;
-                this->for_each_column_with_field_type<field_type>([&res, &c, &obj, this](auto &col){
+                this->for_each_column_with_field_type<F>([&res, &c, &obj, this](auto &col){
                     using namespace static_magic;
                     using column_type = typename std::remove_reference<decltype(col)>::type;
                     using member_pointer_t = typename column_type::member_pointer_t;
@@ -8234,7 +8360,7 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::shared_ptr with max value or null if sqlite engine returned null.
              */
-            template<class F, class O, class ...Args, class Ret = typename column_result_t<F O::*>::type>
+            template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
             std::shared_ptr<Ret> max(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
@@ -8273,7 +8399,7 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::shared_ptr with min value or null if sqlite engine returned null.
              */
-            template<class F, class O, class ...Args, class Ret = typename column_result_t<F O::*>::type>
+            template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
             std::shared_ptr<Ret> min(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
@@ -8312,7 +8438,7 @@ namespace sqlite_orm {
              *  @param m is a class member pointer (the same you passed into make_column).
              *  @return std::shared_ptr with sum value or null if sqlite engine returned null.
              */
-            template<class F, class O, class ...Args, class Ret = typename column_result_t<F O::*>::type>
+            template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
             std::shared_ptr<Ret> sum(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
@@ -8400,7 +8526,7 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename column_result_t<T>::type,
+            class R = typename column_result_t<self, T>::type,
             typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr>
             std::vector<R> select(T m, Args ...args) {
                 using select_type = select_t<T, Args...>;
@@ -8432,7 +8558,7 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class Ret = typename column_result_t<T>::type,
+            class Ret = typename column_result_t<self, T>::type,
             typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
             std::vector<Ret> select(T op, Args ...args) {
                 std::stringstream ss;
@@ -8650,7 +8776,7 @@ namespace sqlite_orm {
                     auto index = 1;
                     cols.for_each([&o, &index, &stmt, &impl] (auto &m) {
                         using column_type = typename std::decay<decltype(m)>::type;
-                        using field_type = typename column_result_t<column_type>::type;
+                        using field_type = typename column_result_t<self, column_type>::type;
                         const field_type *value = impl.table.template get_object_field_pointer<field_type>(o, m);
                         statement_binder<field_type>().bind(stmt, index++, *value);
                     });
@@ -9256,117 +9382,3 @@ __pragma(pop_macro("max"))
 # undef __RESTORE_MAX__
 # endif
 #endif // defined(_MSC_VER)
-#include <type_traits>  //  std::is_same, std::enable_if, std::true_type, std::false_type, std::integral_constant
-#include <tuple>    //  std::tuple
-
-namespace sqlite_orm {
-    
-    namespace internal {
-        
-        namespace storage_traits {
-            
-            /**
-             *  S - storage_impl type
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T, class SFINAE = void>
-            struct type_is_mapped_impl;
-            
-            /**
-             *  S - storage
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T>
-            struct type_is_mapped : type_is_mapped_impl<typename S::impl_type, T> {};
-            
-            /**
-             *  Final specialisation
-             */
-            template<class T>
-            struct type_is_mapped_impl<storage_impl<>, T, void> : std::false_type {};
-            
-            template<class S, class T>
-            struct type_is_mapped_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::true_type {};
-            
-            template<class S, class T>
-            struct type_is_mapped_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type>
-            : type_is_mapped_impl<typename S::super, T> {};
-            
-            
-            /**
-             *  S - storage_impl type
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T, class SFINAE = void>
-            struct storage_columns_count_impl;
-            
-            /**
-             *  S - storage
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T>
-            struct storage_columns_count : storage_columns_count_impl<typename S::impl_type, T> {};
-            
-            /**
-             *  Final specialisation
-             */
-            template<class T>
-            struct storage_columns_count_impl<storage_impl<>, T, void> : std::integral_constant<int, 0> {};
-            
-            template<class S, class T>
-            struct storage_columns_count_impl<S, T,  typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> : std::integral_constant<int, S::table_type::columns_count> {};
-            
-            template<class S, class T>
-            struct storage_columns_count_impl<S, T,  typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_columns_count_impl<typename S::super, T> {};
-            
-            
-            /**
-             *  T - table_impl type.
-             */
-            template<class T>
-            struct table_impl_types;
-            
-            /**
-             *  type is std::tuple of field types of mapped colums.
-             */
-            template<typename... Args>
-            struct table_impl_types<table_impl<Args...>> {
-                using type = std::tuple<typename Args::field_type...>;
-            };
-            
-            
-            /**
-             *  S - storage_impl type
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T, class SFINAE = void>
-            struct storage_mapped_columns_impl;
-            
-            /**
-             *  S - storage
-             *  T - mapped or not mapped data type
-             */
-            template<class S, class T>
-            struct storage_mapped_columns : storage_mapped_columns_impl<typename S::impl_type, T> {};
-            
-            /**
-             *  Final specialisation
-             */
-            template<class T>
-            struct storage_mapped_columns_impl<storage_impl<>, T, void> {
-                using type = std::tuple<>;
-            };
-            
-            template<class S, class T>
-            struct storage_mapped_columns_impl<S, T, typename std::enable_if<std::is_same<T, typename S::table_type::object_type>::value>::type> {
-                using table_type = typename S::table_type;
-                using table_impl_type = typename table_type::impl_type;
-                using type = typename table_impl_types<table_impl_type>::type;
-            };
-            
-            template<class S, class T>
-            struct storage_mapped_columns_impl<S, T, typename std::enable_if<!std::is_same<T, typename S::table_type::object_type>::value>::type> : storage_mapped_columns_impl<typename S::super, T> {};
-            
-        }
-    }
-}
diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 5f01dae25..78a7159d9 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -279,6 +279,16 @@ int main() {
         using VisitColumnTypes = storage_mapped_columns<decltype(storage2), Visit>::type;
         static_assert(std::is_same<VisitColumnTypes, std::tuple<int, std::string>>::value, "Incorrect storage_mapped_columns result");
     }
+    {
+        static_assert(std::is_same<internal::column_result_t<decltype(add(1, 2))>::type, double>::value, "Incorrect add result");
+        static_assert(std::is_same<internal::column_result_t<decltype(sub(2, 1))>::type, double>::value, "Incorrect sub result");
+        static_assert(std::is_same<internal::column_result_t<decltype(mul(2, 3))>::type, double>::value, "Incorrect mul result");
+        static_assert(std::is_same<internal::column_result_t<decltype(sqlite_orm::div(2, 3))>::type, double>::value, "Incorrect div result");
+    }
+    {
+        auto cols = storage.select(asterisk<User>());
+        ff
+    }
     
     return 0;
 }
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 21ab6f36f..8a5057c06 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -17,26 +17,48 @@ void testSimpleQuery() {
     
     auto storage = make_storage("");
     {
+        //  SELECT 1
         auto one = storage.select(1);
         assert(one.size() == 1);
         assert(one.front() == 1);
     }
     {
+        //  SELECT 'ototo'
         auto ototo = storage.select("ototo");
         assert(ototo.size() == 1);
         assert(ototo.front() == "ototo");
     }
     {
+        //  SELECT 1 + 1
         auto two = storage.select(c(1) + 1);
         assert(two.size() == 1);
         assert(two.front() == 2);
+        
+        auto twoAgain = storage.select(add(1, 1));
+        assert(two == twoAgain);
+    }
+    {
+        //  SELECT 10 / 5, 2 * 4
+        auto math = storage.select(columns(sqlite_orm::div(10, 5), mul(2, 4)));
+        assert(math.size() == 1);
+        assert(math.front() == std::make_tuple(2, 8));
     }
     {
+        //  SELECT 1, 2
         auto twoRows = storage.select(columns(1, 2));
         assert(twoRows.size() == 1);
         assert(std::get<0>(twoRows.front()) == 1);
         assert(std::get<1>(twoRows.front()) == 2);
     }
+    {
+        //  SELECT 1, 2
+        //  UNION ALL
+        //  SELECT 3, 4;
+        auto twoRowsUnion = storage.select(union_all(select(columns(1, 2)), select(columns(3, 4))));
+        assert(twoRowsUnion.size() == 2);
+        assert(twoRowsUnion[0] == std::make_tuple(1, 2));
+        assert(twoRowsUnion[1] == std::make_tuple(3, 4));
+    }
 }
 
 void testThreadsafe() {
diff --git a/third_party/amalgamate/config.json b/third_party/amalgamate/config.json
index 63f95d24e..d2800e210 100755
--- a/third_party/amalgamate/config.json
+++ b/third_party/amalgamate/config.json
@@ -39,8 +39,7 @@
 		"dev/table.h",
 		"dev/storage_impl.h",
 		"dev/storage.h",
-		"dev/finish_macros.h",
-        "dev/storage_traits.h"
+		"dev/finish_macros.h"
 	],
 	"include_paths": ["dev"]
 }

From 75805c14b5b5e3ab2e53ade5ed8cbd2a00a5a683 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Wed, 26 Dec 2018 20:18:33 +0300
Subject: [PATCH 33/63] fixed static tests

---
 tests/static_tests.cpp | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/tests/static_tests.cpp b/tests/static_tests.cpp
index 78a7159d9..67bbfadf2 100644
--- a/tests/static_tests.cpp
+++ b/tests/static_tests.cpp
@@ -111,7 +111,7 @@ int main() {
         using field_type = column_type::field_type;
         static_assert(std::is_same<field_type, decltype(&Object::id)>::value, "Incorrect field type");
         static_assert(std::is_same<internal::table_type<field_type>::type, Object>::value, "Incorrect mapped type");
-        static_assert(std::is_same<internal::column_result_t<field_type>::type, int>::value, "Incorrect field type");
+        static_assert(std::is_same<internal::column_result_t<internal::storage_t<>, field_type>::type, int>::value, "Incorrect field type");
         static_assert(std::is_member_pointer<field_type>::value, "Field type is not a member pointer");
         static_assert(!std::is_member_function_pointer<field_type>::value, "Field type is not a member pointer");
     }
@@ -280,14 +280,10 @@ int main() {
         static_assert(std::is_same<VisitColumnTypes, std::tuple<int, std::string>>::value, "Incorrect storage_mapped_columns result");
     }
     {
-        static_assert(std::is_same<internal::column_result_t<decltype(add(1, 2))>::type, double>::value, "Incorrect add result");
-        static_assert(std::is_same<internal::column_result_t<decltype(sub(2, 1))>::type, double>::value, "Incorrect sub result");
-        static_assert(std::is_same<internal::column_result_t<decltype(mul(2, 3))>::type, double>::value, "Incorrect mul result");
-        static_assert(std::is_same<internal::column_result_t<decltype(sqlite_orm::div(2, 3))>::type, double>::value, "Incorrect div result");
-    }
-    {
-        auto cols = storage.select(asterisk<User>());
-        ff
+        static_assert(std::is_same<internal::column_result_t<internal::storage_t<>, decltype(add(1, 2))>::type, double>::value, "Incorrect add result");
+        static_assert(std::is_same<internal::column_result_t<internal::storage_t<>, decltype(sub(2, 1))>::type, double>::value, "Incorrect sub result");
+        static_assert(std::is_same<internal::column_result_t<internal::storage_t<>, decltype(mul(2, 3))>::type, double>::value, "Incorrect mul result");
+        static_assert(std::is_same<internal::column_result_t<internal::storage_t<>, decltype(sqlite_orm::div(2, 3))>::type, double>::value, "Incorrect div result");
     }
     
     return 0;

From 29c28e40db7c7519d99e76943ee9604d9f5ca4db Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Fri, 28 Dec 2018 17:14:54 +0300
Subject: [PATCH 34/63] added on update and on delete actions

---
 dev/constraints.h               | 136 +++++++++++++++-
 dev/storage.h                   |   6 +
 examples/foreign_key.cpp        | 278 ++++++++++++++++++++++----------
 include/sqlite_orm/sqlite_orm.h | 142 +++++++++++++++-
 4 files changed, 478 insertions(+), 84 deletions(-)

diff --git a/dev/constraints.h b/dev/constraints.h
index d7df02b89..f42ebab67 100644
--- a/dev/constraints.h
+++ b/dev/constraints.h
@@ -4,6 +4,7 @@
 #include <tuple>    //  std::tuple, std::make_tuple
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::is_base_of, std::false_type, std::true_type
+#include <ostream>  //  std::ostream
 
 namespace sqlite_orm {
     
@@ -113,17 +114,150 @@ namespace sqlite_orm {
         template<class A, class B>
         struct foreign_key_t;
         
+        enum class foreign_key_action {
+            none,   //  not specified
+            no_action,
+            restrict_,
+            set_null,
+            set_default,
+            cascade,
+        };
+        
+        inline std::ostream &operator<<(std::ostream &os, foreign_key_action action) {
+            switch(action){
+                case decltype(action)::no_action:
+                    os << "NO ACTION";
+                    break;
+                case decltype(action)::restrict_:
+                    os << "RESTRICT";
+                    break;
+                case decltype(action)::set_null:
+                    os << "SET NULL";
+                    break;
+                case decltype(action)::set_default:
+                    os << "SET DEFAULT";
+                    break;
+                case decltype(action)::cascade:
+                    os << "CASCADE";
+                    break;
+                case decltype(action)::none:
+                    break;
+            }
+            return os;
+        }
+        
+        /**
+         *  F - foreign key class
+         */
+        template<class F>
+        struct on_update_delete_t {
+            using foreign_key_type = F;
+            
+            const foreign_key_type &fk;
+            const bool update;  //  true if update and false if delete
+            
+            on_update_delete_t(decltype(fk) fk_, decltype(update) update_, foreign_key_action action_) : fk(fk_), update(update_), _action(action_) {}
+            
+            foreign_key_action _action = foreign_key_action::none;
+            
+            foreign_key_type no_action() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::no_action;
+                }else{
+                    res.on_delete._action = foreign_key_action::no_action;
+                }
+                return res;
+            }
+            
+            foreign_key_type restrict_() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::restrict_;
+                }else{
+                    res.on_delete._action = foreign_key_action::restrict_;
+                }
+                return res;
+            }
+            
+            foreign_key_type set_null() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::set_null;
+                }else{
+                    res.on_delete._action = foreign_key_action::set_null;
+                }
+                return res;
+            }
+            
+            foreign_key_type set_default() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::set_default;
+                }else{
+                    res.on_delete._action = foreign_key_action::set_default;
+                }
+                return res;
+            }
+            
+            foreign_key_type cascade() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::cascade;
+                }else{
+                    res.on_delete._action = foreign_key_action::cascade;
+                }
+                return res;
+            }
+            
+            operator bool() const {
+                return this->_action != decltype(this->_action)::none;
+            }
+            
+            operator std::string() const {
+                if(this->update){
+                    return "ON UPDATE";
+                }else{
+                    return "ON DELETE";
+                }
+            }
+        };
+        
         template<class ...Cs, class ...Rs>
         struct foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> {
             using columns_type = std::tuple<Cs...>;
             using references_type = std::tuple<Rs...>;
+            using self = foreign_key_t<columns_type, references_type>;
             
             columns_type columns;
             references_type references;
             
+            on_update_delete_t<self> on_update;
+            on_update_delete_t<self> on_delete;
+            
             static_assert(std::tuple_size<columns_type>::value == std::tuple_size<references_type>::value, "Columns size must be equal to references tuple");
             
-            foreign_key_t(columns_type columns_, references_type references_): columns(std::move(columns_)), references(std::move(references_)) {}
+            foreign_key_t(columns_type columns_, references_type references_):
+            columns(std::move(columns_)),
+            references(std::move(references_)),
+            on_update(*this, true, foreign_key_action::none),
+            on_delete(*this, false, foreign_key_action::none)
+            {}
+            
+            foreign_key_t(const self &other):
+            columns(other.columns),
+            references(other.references),
+            on_update(*this, true, other.on_update._action),
+            on_delete(*this, false, other.on_delete._action)
+            {}
+            
+            self &operator=(const self &other) {
+                this->columns = other.columns;
+                this->references = other.references;
+                this->on_update = {*this, true, other.on_update._action};
+                this->on_delete = {*this, false, other.on_delete._action};
+                return *this;
+            }
             
             using field_type = void;    //  for column iteration. Better be deleted
             using constraints_type = std::tuple<>;
diff --git a/dev/storage.h b/dev/storage.h
index 5c84e78a1..8c807f6c4 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -344,6 +344,12 @@ namespace sqlite_orm {
                     ss << " ";
                 }
                 ss << ") ";
+                if(fk.on_update){
+                    ss << static_cast<std::string>(fk.on_update) << " " << fk.on_update._action << " ";
+                }
+                if(fk.on_delete){
+                    ss << static_cast<std::string>(fk.on_delete) << " " << fk.on_delete._action << " ";
+                }
                 return ss.str();
             }
 #endif
diff --git a/examples/foreign_key.cpp b/examples/foreign_key.cpp
index bf0ac07cf..b90d9ae58 100644
--- a/examples/foreign_key.cpp
+++ b/examples/foreign_key.cpp
@@ -27,92 +27,206 @@ int main(int argc, char **argv) {
     cout << "path = " << argv[0] << endl;
     
     using namespace sqlite_orm;
-    auto storage = make_storage("foreign_key.sqlite",
-                                make_table("artist",
-                                           make_column("artistid", &Artist::artistId, primary_key()),
-                                           make_column("artistname", &Artist::artistName)),
-                                make_table("track",
-                                           make_column("trackid", &Track::trackId, primary_key()),
-                                           make_column("trackname", &Track::trackName),
-                                           make_column("trackartist", &Track::trackArtist),
-                                           foreign_key(&Track::trackArtist).references(&Artist::artistId)));
-    auto syncSchemaRes = storage.sync_schema();
-    for(auto &p : syncSchemaRes) {
-        cout << p.first << " " << p.second << endl;
-    }
-    
-    storage.remove_all<Track>();
-    storage.remove_all<Artist>();
-    
-    storage.replace(Artist{ 1, "Dean Martin" });
-    storage.replace(Artist{ 2, "Frank Sinatra" });
-    
-    storage.replace(Track{ 11, "That's Amore", std::make_shared<int>(1) });
-    storage.replace(Track{ 12, "Christmas Blues", std::make_shared<int>(1) });
-    storage.replace(Track{ 13, "My Way", std::make_shared<int>(2) });
-    
-    try{
-        //  This fails because value inserted into the trackartist column (3)
-        //  does not correspond to row in the artist table.
-        storage.replace(Track{ 14, "Mr. Bojangles", std::make_shared<int>(3) });
-        assert(0);
-    }catch(std::system_error e) {
-        cout << e.what() << endl;
-    }
-    
-    //  This succeeds because a NULL is inserted into trackartist. A
-    //  corresponding row in the artist table is not required in this case.
-    storage.replace(Track{ 14, "Mr. Bojangles", nullptr });
-    
-    //  Trying to modify the trackartist field of the record after it has
-    //  been inserted does not work either, since the new value of trackartist (3)
-    //  still does not correspond to any row in the artist table.
-    try{
+    {   //  simple case with foreign key to a single column without actions
+        auto storage = make_storage("foreign_key.sqlite",
+                                    make_table("artist",
+                                               make_column("artistid", &Artist::artistId, primary_key()),
+                                               make_column("artistname", &Artist::artistName)),
+                                    make_table("track",
+                                               make_column("trackid", &Track::trackId, primary_key()),
+                                               make_column("trackname", &Track::trackName),
+                                               make_column("trackartist", &Track::trackArtist),
+                                               foreign_key(&Track::trackArtist).references(&Artist::artistId)));
+        auto syncSchemaRes = storage.sync_schema();
+        for(auto &p : syncSchemaRes) {
+            cout << p.first << " " << p.second << endl;
+        }
+        
+        storage.remove_all<Track>();
+        storage.remove_all<Artist>();
+        
+        storage.replace(Artist{ 1, "Dean Martin" });
+        storage.replace(Artist{ 2, "Frank Sinatra" });
+        
+        storage.replace(Track{ 11, "That's Amore", std::make_shared<int>(1) });
+        storage.replace(Track{ 12, "Christmas Blues", std::make_shared<int>(1) });
+        storage.replace(Track{ 13, "My Way", std::make_shared<int>(2) });
+        
+        try{
+            //  This fails because value inserted into the trackartist column (3)
+            //  does not correspond to row in the artist table.
+            storage.replace(Track{ 14, "Mr. Bojangles", std::make_shared<int>(3) });
+            assert(0);
+        }catch(std::system_error e) {
+            cout << e.what() << endl;
+        }
+        
+        //  This succeeds because a NULL is inserted into trackartist. A
+        //  corresponding row in the artist table is not required in this case.
+        storage.replace(Track{ 14, "Mr. Bojangles", nullptr });
+        
+        //  Trying to modify the trackartist field of the record after it has
+        //  been inserted does not work either, since the new value of trackartist (3)
+        //  still does not correspond to any row in the artist table.
+        try{
+            storage.update_all(set(assign(&Track::trackArtist, 3)), where(is_equal(&Track::trackName, "Mr. Bojangles")));
+            assert(0);
+        }catch(std::system_error e) {
+            cout << e.what() << endl;
+        }
+        
+        //  Insert the required row into the artist table. It is then possible to
+        //  update the inserted row to set trackartist to 3 (since a corresponding
+        //  row in the artist table now exists).
+        storage.replace(Artist{ 3, "Sammy Davis Jr." });
         storage.update_all(set(assign(&Track::trackArtist, 3)), where(is_equal(&Track::trackName, "Mr. Bojangles")));
-        assert(0);
-    }catch(std::system_error e) {
-        cout << e.what() << endl;
-    }
-    
-    //  Insert the required row into the artist table. It is then possible to
-    //  update the inserted row to set trackartist to 3 (since a corresponding
-    //  row in the artist table now exists).
-    storage.replace(Artist{ 3, "Sammy Davis Jr." });
-    storage.update_all(set(assign(&Track::trackArtist, 3)), where(is_equal(&Track::trackName, "Mr. Bojangles")));
-    
-    //  Now that "Sammy Davis Jr." (artistid = 3) has been added to the database,
-    //  it is possible to INSERT new tracks using this artist without violating
-    //  the foreign key constraint:
-    storage.replace(Track{ 15, "Boogie Woogie", std::make_shared<int>(3) });
-    
-    try{
-        //  Attempting to delete the artist record for "Frank Sinatra" fails, since
-        //  the track table contains a row that refer to it.
+        
+        //  Now that "Sammy Davis Jr." (artistid = 3) has been added to the database,
+        //  it is possible to INSERT new tracks using this artist without violating
+        //  the foreign key constraint:
+        storage.replace(Track{ 15, "Boogie Woogie", std::make_shared<int>(3) });
+        
+        try{
+            //  Attempting to delete the artist record for "Frank Sinatra" fails, since
+            //  the track table contains a row that refer to it.
+            storage.remove_all<Artist>(where(is_equal(&Artist::artistName, "Frank Sinatra")));
+            assert(0);
+        }catch(std::system_error e) {
+            cout << e.what() << endl;
+        }
+        
+        //  Delete all the records from the track table that refer to the artist
+        //  "Frank Sinatra". Only then is it possible to delete the artist.
+        storage.remove_all<Track>(where(is_equal(&Track::trackName, "My Way")));
         storage.remove_all<Artist>(where(is_equal(&Artist::artistName, "Frank Sinatra")));
-        assert(0);
-    }catch(std::system_error e) {
-        cout << e.what() << endl;
+        
+        try{
+            //  Try to update the artistid of a row in the artist table while there
+            //  exists records in the track table that refer to it.
+            storage.update_all(set(assign(&Artist::artistId, 4)), where(is_equal(&Artist::artistName, "Dean Martin")));
+            assert(0);
+        }catch(std::system_error e) {
+            cout << e.what() << endl;
+        }
+        
+        //  Once all the records that refer to a row in the artist table have
+        //  been deleted, it is possible to modify the artistid of the row.
+        storage.remove_all<Track>(where(in(&Track::trackName, {"That''s Amore", "Christmas Blues"})));
+        storage.update_all(set(c(&Artist::artistId) = 4),
+                           where(c(&Artist::artistName) == "Dean Martin"));
     }
-    
-    //  Delete all the records from the track table that refer to the artist
-    //  "Frank Sinatra". Only then is it possible to delete the artist.
-    storage.remove_all<Track>(where(is_equal(&Track::trackName, "My Way")));
-    storage.remove_all<Artist>(where(is_equal(&Artist::artistName, "Frank Sinatra")));
-    
-    try{
-        //  Try to update the artistid of a row in the artist table while there
-        //  exists records in the track table that refer to it.
-        storage.update_all(set(assign(&Artist::artistId, 4)), where(is_equal(&Artist::artistName, "Dean Martin")));
-        assert(0);
-    }catch(std::system_error e) {
-        cout << e.what() << endl;
+    {   //  case with ON UPDATE CASCADE
+        auto storage = make_storage("foreign_key2.sqlite",
+                                    make_table("artist",
+                                               make_column("artistid", &Artist::artistId, primary_key()),
+                                               make_column("artistname", &Artist::artistName)),
+                                    make_table("track",
+                                               make_column("trackid", &Track::trackId, primary_key()),
+                                               make_column("trackname", &Track::trackName),
+                                               make_column("trackartist", &Track::trackArtist),
+                                               foreign_key(&Track::trackArtist).references(&Artist::artistId).on_update.cascade()));
+        auto syncSchemaRes = storage.sync_schema();
+        for(auto &p : syncSchemaRes) {
+            cout << p.first << " " << p.second << endl;
+        }
+        
+        storage.remove_all<Track>();
+        storage.remove_all<Artist>();
+        
+        storage.replace(Artist{ 1, "Dean Martin" });
+        storage.replace(Artist{ 2, "Frank Sinatra" });
+        
+        storage.replace(Track{ 11, "That's Amore", std::make_shared<int>(1) });
+        storage.replace(Track{ 12, "Christmas Blues", std::make_shared<int>(1) });
+        storage.replace(Track{ 13, "My Way", std::make_shared<int>(2) });
+        
+        //  Update the artistid column of the artist record for "Dean Martin".
+        //  Normally, this would raise a constraint, as it would orphan the two
+        //  dependent records in the track table. However, the ON UPDATE CASCADE clause
+        //  attached to the foreign key definition causes the update to "cascade"
+        //  to the child table, preventing the foreign key constraint violation.
+        //  UPDATE artist SET artistid = 100 WHERE artistname = 'Dean Martin';
+        storage.update_all(set(c(&Artist::artistId) = 100), where(c(&Artist::artistName) == "Dean Martin"));
+        
+        cout << "artists:" << endl;
+        for(auto &artist : storage.iterate<Artist>()){
+            cout << artist.artistId << '\t' << artist.artistName << endl;
+        }
+        cout << endl;
+        
+        cout << "tracks:" << endl;
+        for(auto &track : storage.iterate<Track>()){
+            cout << track.trackId << '\t' << track.trackName << '\t';
+            if(track.trackArtist){
+                cout << *track.trackArtist;
+            }else{
+                cout << "null";
+            }
+            cout << endl;
+        }
+        cout << endl;
+        
+    }
+    {   //  case with ON DELETE SET DEFAULT
+        auto storage = make_storage("foreign_key3.sqlite",
+                                    make_table("artist",
+                                               make_column("artistid", &Artist::artistId, primary_key()),
+                                               make_column("artistname", &Artist::artistName)),
+                                    make_table("track",
+                                               make_column("trackid", &Track::trackId, primary_key()),
+                                               make_column("trackname", &Track::trackName),
+                                               make_column("trackartist", &Track::trackArtist, default_value(0)),
+                                               foreign_key(&Track::trackArtist).references(&Artist::artistId).on_delete.set_default()));
+        auto syncSchemaRes = storage.sync_schema();
+        for(auto &p : syncSchemaRes) {
+            cout << p.first << " " << p.second << endl;
+        }
+        
+        storage.remove_all<Track>();
+        storage.remove_all<Artist>();
+        
+        storage.replace(Artist{ 3, "Sammy Davis Jr." });
+        
+        storage.replace(Track{ 14, "Mr. Bojangles", std::make_shared<int>(3) });
+        
+        //  Deleting the row from the parent table causes the child key
+        //  value of the dependent row to be set to integer value 0. However, this
+        //  value does not correspond to any row in the parent table. Therefore
+        //  the foreign key constraint is violated and an is exception thrown.
+        //  DELETE FROM artist WHERE artistname = 'Sammy Davis Jr.';
+        try{
+            storage.remove_all<Artist>(where(c(&Artist::artistName) == "Sammy Davis Jr."));
+            assert(0);
+        }catch(std::system_error e) {
+            cout << e.what() << endl;
+        }
+        
+        //  This time, the value 0 does correspond to a parent table row. And
+        //  so the DELETE statement does not violate the foreign key constraint
+        //  and no exception is thrown.
+        //  INSERT INTO artist VALUES(0, 'Unknown Artist');
+        //  DELETE FROM artist WHERE artistname = 'Sammy Davis Jr.'
+        storage.replace(Artist{0, "Unknown Artist"});
+        storage.remove_all<Artist>(where(c(&Artist::artistName) == "Sammy Davis Jr."));
+        
+        cout << "artists:" << endl;
+        for(auto &artist : storage.iterate<Artist>()){
+            cout << artist.artistId << '\t' << artist.artistName << endl;
+        }
+        cout << endl;
+        
+        cout << "tracks:" << endl;
+        for(auto &track : storage.iterate<Track>()){
+            cout << track.trackId << '\t' << track.trackName << '\t';
+            if(track.trackArtist){
+                cout << *track.trackArtist;
+            }else{
+                cout << "null";
+            }
+            cout << endl;
+        }
+        cout << endl;
     }
-    
-    //  Once all the records that refer to a row in the artist table have
-    //  been deleted, it is possible to modify the artistid of the row.
-    storage.remove_all<Track>(where(in(&Track::trackName, {"That''s Amore", "Christmas Blues"})));
-    storage.update_all(set(c(&Artist::artistId) = 4),
-                       where(c(&Artist::artistName) == "Dean Martin"));
     
     return 0;
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f9447ff96..37a902696 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -404,6 +404,7 @@ namespace sqlite_orm {
 #include <tuple>    //  std::tuple, std::make_tuple
 #include <sstream>  //  std::stringstream
 #include <type_traits>  //  std::is_base_of, std::false_type, std::true_type
+#include <ostream>  //  std::ostream
 
 namespace sqlite_orm {
     
@@ -513,17 +514,150 @@ namespace sqlite_orm {
         template<class A, class B>
         struct foreign_key_t;
         
+        enum class foreign_key_action {
+            none,   //  not specified
+            no_action,
+            restrict_,
+            set_null,
+            set_default,
+            cascade,
+        };
+        
+        inline std::ostream &operator<<(std::ostream &os, foreign_key_action action) {
+            switch(action){
+                case decltype(action)::no_action:
+                    os << "NO ACTION";
+                    break;
+                case decltype(action)::restrict_:
+                    os << "RESTRICT";
+                    break;
+                case decltype(action)::set_null:
+                    os << "SET NULL";
+                    break;
+                case decltype(action)::set_default:
+                    os << "SET DEFAULT";
+                    break;
+                case decltype(action)::cascade:
+                    os << "CASCADE";
+                    break;
+                case decltype(action)::none:
+                    break;
+            }
+            return os;
+        }
+        
+        /**
+         *  F - foreign key class
+         */
+        template<class F>
+        struct on_update_delete_t {
+            using foreign_key_type = F;
+            
+            const foreign_key_type &fk;
+            const bool update;  //  true if update and false if delete
+            
+            on_update_delete_t(decltype(fk) fk_, decltype(update) update_, foreign_key_action action_) : fk(fk_), update(update_), _action(action_) {}
+            
+            foreign_key_action _action = foreign_key_action::none;
+            
+            foreign_key_type no_action() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::no_action;
+                }else{
+                    res.on_delete._action = foreign_key_action::no_action;
+                }
+                return res;
+            }
+            
+            foreign_key_type restrict_() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::restrict_;
+                }else{
+                    res.on_delete._action = foreign_key_action::restrict_;
+                }
+                return res;
+            }
+            
+            foreign_key_type set_null() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::set_null;
+                }else{
+                    res.on_delete._action = foreign_key_action::set_null;
+                }
+                return res;
+            }
+            
+            foreign_key_type set_default() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::set_default;
+                }else{
+                    res.on_delete._action = foreign_key_action::set_default;
+                }
+                return res;
+            }
+            
+            foreign_key_type cascade() const {
+                auto res = this->fk;
+                if(update){
+                    res.on_update._action = foreign_key_action::cascade;
+                }else{
+                    res.on_delete._action = foreign_key_action::cascade;
+                }
+                return res;
+            }
+            
+            operator bool() const {
+                return this->_action != decltype(this->_action)::none;
+            }
+            
+            operator std::string() const {
+                if(this->update){
+                    return "ON UPDATE";
+                }else{
+                    return "ON DELETE";
+                }
+            }
+        };
+        
         template<class ...Cs, class ...Rs>
         struct foreign_key_t<std::tuple<Cs...>, std::tuple<Rs...>> {
             using columns_type = std::tuple<Cs...>;
             using references_type = std::tuple<Rs...>;
+            using self = foreign_key_t<columns_type, references_type>;
             
             columns_type columns;
             references_type references;
             
+            on_update_delete_t<self> on_update;
+            on_update_delete_t<self> on_delete;
+            
             static_assert(std::tuple_size<columns_type>::value == std::tuple_size<references_type>::value, "Columns size must be equal to references tuple");
             
-            foreign_key_t(columns_type columns_, references_type references_): columns(std::move(columns_)), references(std::move(references_)) {}
+            foreign_key_t(columns_type columns_, references_type references_):
+            columns(std::move(columns_)),
+            references(std::move(references_)),
+            on_update(*this, true, foreign_key_action::none),
+            on_delete(*this, false, foreign_key_action::none)
+            {}
+            
+            foreign_key_t(const self &other):
+            columns(other.columns),
+            references(other.references),
+            on_update(*this, true, other.on_update._action),
+            on_delete(*this, false, other.on_delete._action)
+            {}
+            
+            self &operator=(const self &other) {
+                this->columns = other.columns;
+                this->references = other.references;
+                this->on_update = {*this, true, other.on_update._action};
+                this->on_delete = {*this, false, other.on_delete._action};
+                return *this;
+            }
             
             using field_type = void;    //  for column iteration. Better be deleted
             using constraints_type = std::tuple<>;
@@ -6537,6 +6671,12 @@ namespace sqlite_orm {
                     ss << " ";
                 }
                 ss << ") ";
+                if(fk.on_update){
+                    ss << static_cast<std::string>(fk.on_update) << " " << fk.on_update._action << " ";
+                }
+                if(fk.on_delete){
+                    ss << static_cast<std::string>(fk.on_delete) << " " << fk.on_delete._action << " ";
+                }
                 return ss.str();
             }
 #endif

From 25635bf9f878468a9ec113fc4cfa6cc1f51bdd70 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Mon, 31 Dec 2018 13:30:22 +0300
Subject: [PATCH 35/63] added CAST(... AS ...) feature and unit tests for it

---
 dev/column_result.h             |  5 +++++
 dev/conditions.h                | 17 +++++++++++++++++
 dev/storage.h                   | 12 ++++++++++++
 include/sqlite_orm/sqlite_orm.h | 34 +++++++++++++++++++++++++++++++++
 tests/tests.cpp                 | 29 ++++++++++++++++++++++++++++
 5 files changed, 97 insertions(+)

diff --git a/dev/column_result.h b/dev/column_result.h
index ee31a7fa0..08bac0850 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -296,5 +296,10 @@ namespace sqlite_orm {
         struct column_result_t<St, asterisk_t<T>, void> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
+        
+        template<class St, class T, class E>
+        struct column_result_t<St, conditions::cast_t<T, E>, void> {
+            using type = T;
+        };
     }
 }
diff --git a/dev/conditions.h b/dev/conditions.h
index d57fdc0d3..d4c47963f 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -674,6 +674,18 @@ namespace sqlite_orm {
             }
         };
         
+        template<class T, class E>
+        struct cast_t {
+            using to_type = T;
+            using expression_type = E;
+            
+            expression_type expression;
+            
+            operator std::string() const {
+                return "CAST";
+            }
+        };
+        
     }
     
     /**
@@ -1042,4 +1054,9 @@ namespace sqlite_orm {
     conditions::having_t<T> having(T t) {
         return {t};
     }
+    
+    template<class T, class E>
+    conditions::cast_t<T, E> cast(E e) {
+        return {e};
+    }
 }
diff --git a/dev/storage.h b/dev/storage.h
index 8c807f6c4..dcd1a1a91 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -942,6 +942,13 @@ namespace sqlite_orm {
                 }
                 return ss.str();
             }
+            
+            template<class T, class E>
+            std::string string_from_expression(const conditions::cast_t<T, E> &c, bool /*noTableName*/ = false, bool /*escape*/ = false) {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ( " << this->string_from_expression(c.expression) << " AS " << type_printer<T>().print() << ") ";
+                return ss.str();
+            }
              
             template<class T>
             std::string process_where(const conditions::is_null_t<T> &c) {
@@ -1769,6 +1776,11 @@ namespace sqlite_orm {
                 return {std::make_pair(std::move(tableName), "")};
             }
             
+            template<class T, class E>
+            std::set<std::pair<std::string, std::string>> parse_table_name(const conditions::cast_t<T, E> &c) {
+                return this->parse_table_name(c.expression);
+            }
+            
             template<class ...Args>
             std::set<std::pair<std::string, std::string>> parse_table_names(Args...) {
                 return {};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 37a902696..c420c7c61 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2142,6 +2142,18 @@ namespace sqlite_orm {
             }
         };
         
+        template<class T, class E>
+        struct cast_t {
+            using to_type = T;
+            using expression_type = E;
+            
+            expression_type expression;
+            
+            operator std::string() const {
+                return "CAST";
+            }
+        };
+        
     }
     
     /**
@@ -2510,6 +2522,11 @@ namespace sqlite_orm {
     conditions::having_t<T> having(T t) {
         return {t};
     }
+    
+    template<class T, class E>
+    conditions::cast_t<T, E> cast(E e) {
+        return {e};
+    }
 }
 #pragma once
 
@@ -4918,6 +4935,11 @@ namespace sqlite_orm {
         struct column_result_t<St, asterisk_t<T>, void> {
             using type = typename storage_traits::storage_mapped_columns<St, T>::type;
         };
+        
+        template<class St, class T, class E>
+        struct column_result_t<St, conditions::cast_t<T, E>, void> {
+            using type = T;
+        };
     }
 }
 #pragma once
@@ -7269,6 +7291,13 @@ namespace sqlite_orm {
                 }
                 return ss.str();
             }
+            
+            template<class T, class E>
+            std::string string_from_expression(const conditions::cast_t<T, E> &c, bool /*noTableName*/ = false, bool /*escape*/ = false) {
+                std::stringstream ss;
+                ss << static_cast<std::string>(c) << " ( " << this->string_from_expression(c.expression) << " AS " << type_printer<T>().print() << ") ";
+                return ss.str();
+            }
              
             template<class T>
             std::string process_where(const conditions::is_null_t<T> &c) {
@@ -8096,6 +8125,11 @@ namespace sqlite_orm {
                 return {std::make_pair(std::move(tableName), "")};
             }
             
+            template<class T, class E>
+            std::set<std::pair<std::string, std::string>> parse_table_name(const conditions::cast_t<T, E> &c) {
+                return this->parse_table_name(c.expression);
+            }
+            
             template<class ...Args>
             std::set<std::pair<std::string, std::string>> parse_table_names(Args...) {
                 return {};
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 8a5057c06..3a05fa22b 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -12,6 +12,33 @@ using namespace sqlite_orm;
 using std::cout;
 using std::endl;
 
+void testCast() {
+    cout << __func__ << endl;
+    
+    struct Student {
+        int id;
+        float scoreFloat;
+        std::string scoreString;
+    };
+    
+    auto storage = make_storage("",
+                                make_table("students",
+                                           make_column("id", &Student::id, primary_key()),
+                                           make_column("score_float", &Student::scoreFloat),
+                                           make_column("score_str", &Student::scoreString)));
+    storage.sync_schema();
+    
+    storage.replace(Student{1, 10.1, "14.5"});
+    
+    {
+        auto rows = storage.select(columns(cast<int>(&Student::scoreFloat), cast<int>(&Student::scoreString)));
+        assert(rows.size() == 1);
+        auto &row = rows.front();
+        assert(std::get<0>(row) == 10);
+        assert(std::get<1>(row) == 14);
+    }
+}
+
 void testSimpleQuery() {
     cout << __func__ << endl;
     
@@ -2365,4 +2392,6 @@ int main(int argc, char **argv) {
     testEscapedIndexName();
     
     testSimpleQuery();
+    
+    testCast();
 }

From 9c6b1eae2e0ed7f1c5f0ce318356d3e5dae262b8 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Mon, 31 Dec 2018 15:35:12 +0300
Subject: [PATCH 36/63] added julian day

---
 dev/column_result.h             |   5 +
 dev/core_functions.h            |  72 +++++++++++++-
 dev/operators.h                 |  70 +++++++++++---
 dev/storage.h                   |  12 +++
 examples/date_time.cpp          |  20 ++++
 include/sqlite_orm/sqlite_orm.h | 160 ++++++++++++++++++++++++++++----
 6 files changed, 299 insertions(+), 40 deletions(-)

diff --git a/dev/column_result.h b/dev/column_result.h
index 08bac0850..6a3195ce1 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -122,6 +122,11 @@ namespace sqlite_orm {
             using type = std::string;
         };
         
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, core_functions::julianday_t<T, Args...>, void> {
+            using type = double;
+        };
+        
         template<class St, class T, class ...Args>
         struct column_result_t<St, core_functions::datetime_t<T, Args...>, void> {
             using type = std::string;
diff --git a/dev/core_functions.h b/dev/core_functions.h
index 7bb4b47eb..ce1e3d9f9 100644
--- a/dev/core_functions.h
+++ b/dev/core_functions.h
@@ -5,6 +5,7 @@
 #include <type_traits>  //  std::forward, std::is_base_of, std::enable_if
 
 #include "conditions.h"
+#include "operators.h"
 
 namespace sqlite_orm {
     
@@ -210,7 +211,7 @@ namespace sqlite_orm {
             }
         };
         
-        struct random_t : public core_function_t {
+        struct random_t : core_function_t, internal::arithmetic_t {
             
             operator std::string() const {
                 return "RANDOM";
@@ -219,7 +220,7 @@ namespace sqlite_orm {
         
 #endif
         template<class T, class ...Args>
-        struct date_t : public core_function_t {
+        struct date_t : core_function_t {
             using modifiers_type = std::tuple<Args...>;
             
             T timestring;
@@ -235,7 +236,7 @@ namespace sqlite_orm {
         };
         
         template<class T, class ...Args>
-        struct datetime_t : public core_function_t {
+        struct datetime_t : core_function_t {
             using modifiers_type = std::tuple<Args...>;
             
             T timestring;
@@ -249,6 +250,22 @@ namespace sqlite_orm {
                 return "DATETIME";
             }
         };
+        
+        template<class T, class ...Args>
+        struct julianday_t : core_function_t, internal::arithmetic_t {
+            using modifiers_type = std::tuple<Args...>;
+            
+            T timestring;
+            modifiers_type modifiers;
+            
+            julianday_t() = default;
+            
+            julianday_t(T timestring_, modifiers_type modifiers_): timestring(timestring_), modifiers(modifiers_) {}
+            
+            operator std::string() const {
+                return "JULIANDAY";
+            }
+        };
     }
     
     /**
@@ -309,12 +326,17 @@ namespace sqlite_orm {
     
     template<class T, class ...Args, class Res = core_functions::date_t<T, Args...>>
     Res date(T timestring, Args ...modifiers) {
-        return Res(timestring, std::make_tuple(modifiers...));
+        return Res(timestring, std::make_tuple(std::forward<Args>(modifiers)...));
     }
     
     template<class T, class ...Args, class Res = core_functions::datetime_t<T, Args...>>
     Res datetime(T timestring, Args ...modifiers) {
-        return Res(timestring, std::make_tuple(modifiers...));
+        return Res(timestring, std::make_tuple(std::forward<Args>(modifiers)...));
+    }
+    
+    template<class T, class ...Args, class Res = core_functions::julianday_t<T, Args...>>
+    Res julianday(T timestring, Args ...modifiers) {
+        return Res(timestring, std::make_tuple(std::forward<Args>(modifiers)...));
     }
     
 #if SQLITE_VERSION_NUMBER >= 3007016
@@ -382,4 +404,44 @@ namespace sqlite_orm {
     Res upper(T t) {
         return Res(t);
     }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::add_t<L, R> operator+(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::sub_t<L, R> operator-(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::mul_t<L, R> operator*(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::div_t<L, R> operator/(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::mod_t<L, R> operator%(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
 }
diff --git a/dev/operators.h b/dev/operators.h
index 64c0e060a..8fc002ece 100644
--- a/dev/operators.h
+++ b/dev/operators.h
@@ -6,6 +6,11 @@ namespace sqlite_orm {
     
     namespace internal {
         
+        /**
+         *  Inherit this class to support arithmetic types overloading
+         */
+        struct arithmetic_t {};
+        
         /**
          *  Result of concatenation || operator
          */
@@ -19,45 +24,80 @@ namespace sqlite_orm {
          *  Result of addition + operator
          */
         template<class L, class R>
-        struct add_t {
-            L l;
-            R r;
+        struct add_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            add_t() = default;
+            
+            add_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of subscribe - operator
          */
         template<class L, class R>
-        struct sub_t {
-            L l;
-            R r;
+        struct sub_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            sub_t() = default;
+            
+            sub_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of multiply * operator
          */
         template<class L, class R>
-        struct mul_t {
-            L l;
-            R r;
+        struct mul_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            mul_t() = default;
+            
+            mul_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of divide / operator
          */
         template<class L, class R>
-        struct div_t {
-            L l;
-            R r;
+        struct div_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            div_t() = default;
+            
+            div_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of mod % operator
          */
         template<class L, class R>
-        struct mod_t {
-            L l;
-            R r;
+        struct mod_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            mod_t() = default;
+            
+            mod_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
diff --git a/dev/storage.h b/dev/storage.h
index dcd1a1a91..f38eabc94 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -788,6 +788,18 @@ namespace sqlite_orm {
                 return ss.str();
             }
             
+            template<class T, class ...Args>
+            std::string string_from_expression(const core_functions::julianday_t<T, Args...> &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
+                std::stringstream ss;
+                ss << static_cast<std::string>(f) << "(" << this->string_from_expression(f.timestring);
+                using tuple_t = std::tuple<Args...>;
+                tuple_helper::iterator<std::tuple_size<tuple_t>::value - 1, Args...>()(f.modifiers, [&ss, this](auto &v){
+                    ss << ", " << this->string_from_expression(v);
+                }, false);
+                ss << ") ";
+                return ss.str();
+            }
+            
             std::string string_from_expression(const core_functions::random_t &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
                 std::stringstream ss;
                 ss << static_cast<std::string>(f) << "() ";
diff --git a/examples/date_time.cpp b/examples/date_time.cpp
index 4492a9a67..b91d476d5 100644
--- a/examples/date_time.cpp
+++ b/examples/date_time.cpp
@@ -54,5 +54,25 @@ int main() {
     auto nowWithOffset2 = storage.select(date("now", "+2 day")).front();
     cout << "SELECT date('now','+2 day') = " << nowWithOffset2 << endl;
     
+    //  SELECT julianday('now')
+    auto juliandayNow = storage.select(julianday("now")).front();
+    cout << "SELECT julianday('now') = " << juliandayNow << endl;
+    
+    //  SELECT julianday('1776-07-04')
+    auto oldJulianday = storage.select(julianday("1776-07-04")).front();
+    cout << "SELECT julianday('1776-07-04') = " << oldJulianday << endl;
+    
+    //  SELECT julianday('now') + julianday('1776-07-04')
+    auto julianSum = storage.select(julianday("now") + julianday("1776-07-04")).front();
+    cout << "SELECT julianday('now') + julianday('1776-07-04') = " << julianSum << endl;
+    
+    //  SELECT julianday('now') - julianday('1776-07-04')
+    auto julianDiff = storage.select(julianday("now") - julianday("1776-07-04")).front();
+    cout << "SELECT julianday('now') - julianday('1776-07-04') = " << julianDiff << endl;
+    
+    //  SELECT (julianday('now') - 2440587.5)*86400.0;
+    auto julianConverted = storage.select((julianday("now") - 2440587.5) * 86400.0);
+    
+    
     return 0;
 }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index c420c7c61..43c46d69d 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -905,6 +905,11 @@ namespace sqlite_orm {
     
     namespace internal {
         
+        /**
+         *  Inherit this class to support arithmetic types overloading
+         */
+        struct arithmetic_t {};
+        
         /**
          *  Result of concatenation || operator
          */
@@ -918,45 +923,80 @@ namespace sqlite_orm {
          *  Result of addition + operator
          */
         template<class L, class R>
-        struct add_t {
-            L l;
-            R r;
+        struct add_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            add_t() = default;
+            
+            add_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of subscribe - operator
          */
         template<class L, class R>
-        struct sub_t {
-            L l;
-            R r;
+        struct sub_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            sub_t() = default;
+            
+            sub_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of multiply * operator
          */
         template<class L, class R>
-        struct mul_t {
-            L l;
-            R r;
+        struct mul_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            mul_t() = default;
+            
+            mul_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of divide / operator
          */
         template<class L, class R>
-        struct div_t {
-            L l;
-            R r;
+        struct div_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            div_t() = default;
+            
+            div_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
          *  Result of mod % operator
          */
         template<class L, class R>
-        struct mod_t {
-            L l;
-            R r;
+        struct mod_t : arithmetic_t {
+            using left_type = L;
+            using right_type = R;
+            
+            left_type l;
+            right_type r;
+            
+            mod_t() = default;
+            
+            mod_t(left_type l_, right_type r_) : l(std::move(l_)), r(std::move(r_)) {}
         };
         
         /**
@@ -2779,6 +2819,8 @@ namespace sqlite_orm {
 
 // #include "conditions.h"
 
+// #include "operators.h"
+
 
 namespace sqlite_orm {
     
@@ -2984,7 +3026,7 @@ namespace sqlite_orm {
             }
         };
         
-        struct random_t : public core_function_t {
+        struct random_t : core_function_t, internal::arithmetic_t {
             
             operator std::string() const {
                 return "RANDOM";
@@ -2993,7 +3035,7 @@ namespace sqlite_orm {
         
 #endif
         template<class T, class ...Args>
-        struct date_t : public core_function_t {
+        struct date_t : core_function_t {
             using modifiers_type = std::tuple<Args...>;
             
             T timestring;
@@ -3009,7 +3051,7 @@ namespace sqlite_orm {
         };
         
         template<class T, class ...Args>
-        struct datetime_t : public core_function_t {
+        struct datetime_t : core_function_t {
             using modifiers_type = std::tuple<Args...>;
             
             T timestring;
@@ -3023,6 +3065,22 @@ namespace sqlite_orm {
                 return "DATETIME";
             }
         };
+        
+        template<class T, class ...Args>
+        struct julianday_t : core_function_t, internal::arithmetic_t {
+            using modifiers_type = std::tuple<Args...>;
+            
+            T timestring;
+            modifiers_type modifiers;
+            
+            julianday_t() = default;
+            
+            julianday_t(T timestring_, modifiers_type modifiers_): timestring(timestring_), modifiers(modifiers_) {}
+            
+            operator std::string() const {
+                return "JULIANDAY";
+            }
+        };
     }
     
     /**
@@ -3083,12 +3141,17 @@ namespace sqlite_orm {
     
     template<class T, class ...Args, class Res = core_functions::date_t<T, Args...>>
     Res date(T timestring, Args ...modifiers) {
-        return Res(timestring, std::make_tuple(modifiers...));
+        return Res(timestring, std::make_tuple(std::forward<Args>(modifiers)...));
     }
     
     template<class T, class ...Args, class Res = core_functions::datetime_t<T, Args...>>
     Res datetime(T timestring, Args ...modifiers) {
-        return Res(timestring, std::make_tuple(modifiers...));
+        return Res(timestring, std::make_tuple(std::forward<Args>(modifiers)...));
+    }
+    
+    template<class T, class ...Args, class Res = core_functions::julianday_t<T, Args...>>
+    Res julianday(T timestring, Args ...modifiers) {
+        return Res(timestring, std::make_tuple(std::forward<Args>(modifiers)...));
     }
     
 #if SQLITE_VERSION_NUMBER >= 3007016
@@ -3156,6 +3219,46 @@ namespace sqlite_orm {
     Res upper(T t) {
         return Res(t);
     }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::add_t<L, R> operator+(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::sub_t<L, R> operator-(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::mul_t<L, R> operator*(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::div_t<L, R> operator/(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
+    
+    template<
+    class L,
+    class R,
+    typename = typename std::enable_if<(std::is_base_of<internal::arithmetic_t, L>::value + std::is_base_of<internal::arithmetic_t, R>::value > 0)>::type>
+    internal::mod_t<L, R> operator%(L l, R r) {
+        return {std::move(l), std::move(r)};
+    }
 }
 #pragma once
 
@@ -4761,6 +4864,11 @@ namespace sqlite_orm {
             using type = std::string;
         };
         
+        template<class St, class T, class ...Args>
+        struct column_result_t<St, core_functions::julianday_t<T, Args...>, void> {
+            using type = double;
+        };
+        
         template<class St, class T, class ...Args>
         struct column_result_t<St, core_functions::datetime_t<T, Args...>, void> {
             using type = std::string;
@@ -7137,6 +7245,18 @@ namespace sqlite_orm {
                 return ss.str();
             }
             
+            template<class T, class ...Args>
+            std::string string_from_expression(const core_functions::julianday_t<T, Args...> &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
+                std::stringstream ss;
+                ss << static_cast<std::string>(f) << "(" << this->string_from_expression(f.timestring);
+                using tuple_t = std::tuple<Args...>;
+                tuple_helper::iterator<std::tuple_size<tuple_t>::value - 1, Args...>()(f.modifiers, [&ss, this](auto &v){
+                    ss << ", " << this->string_from_expression(v);
+                }, false);
+                ss << ") ";
+                return ss.str();
+            }
+            
             std::string string_from_expression(const core_functions::random_t &f, bool /*noTableName*/ = false, bool /*escape*/ = false) {
                 std::stringstream ss;
                 ss << static_cast<std::string>(f) << "() ";

From 4947be2e8e4269f879a18e4a05ec16a807a8b3da Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Thu, 10 Jan 2019 14:30:26 +0300
Subject: [PATCH 37/63] unified select member function

---
 dev/storage.h                   | 66 ++++++++++++---------------------
 include/sqlite_orm/sqlite_orm.h | 52 ++++++++++++++++----------
 2 files changed, 55 insertions(+), 63 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index f38eabc94..f7af6aafa 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -438,7 +438,7 @@ namespace sqlite_orm {
             }
             
             template<class T>
-            std::string string_from_expression(T t, bool /*noTableName*/ = false, bool escape = false) {
+            typename std::enable_if<!is_base_of_template<T, compound_operator>::value, std::string>::type string_from_expression(T t, bool /*noTableName*/ = false, bool escape = false) {
                 auto isNullable = type_is_nullable<T>::value;
                 if(isNullable && !type_is_nullable<T>()(t)){
                     return "NULL";
@@ -906,10 +906,12 @@ namespace sqlite_orm {
             template<class T, class ...Args>
             std::string string_from_expression(const internal::select_t<T, Args...> &sel, bool /*noTableName*/ = false, bool /*escape*/ = false) {
                 std::stringstream ss;
-                if(!sel.highest_level){
-                    ss << "( ";
+                if(!is_base_of_template<T, compound_operator>::value){
+                    if(!sel.highest_level){
+                        ss << "( ";
+                    }
+                    ss << "SELECT ";
                 }
-                ss << "SELECT ";
                 if(get_distinct(sel.col)) {
                     ss << static_cast<std::string>(distinct(0)) << " ";
                 }
@@ -949,8 +951,10 @@ namespace sqlite_orm {
                 tuple_helper::iterator<std::tuple_size<tuple_t>::value - 1, Args...>()(sel.conditions, [&ss, this](auto &v){
                     this->process_single_condition(ss, v);
                 }, false);
-                if(!sel.highest_level){
-                    ss << ") ";
+                if(!is_base_of_template<T, compound_operator>::value){
+                    if(!sel.highest_level){
+                        ss << ") ";
+                    }
                 }
                 return ss.str();
             }
@@ -961,6 +965,16 @@ namespace sqlite_orm {
                 ss << static_cast<std::string>(c) << " ( " << this->string_from_expression(c.expression) << " AS " << type_printer<T>().print() << ") ";
                 return ss.str();
             }
+            
+            template<class T>
+            typename std::enable_if<is_base_of_template<T, compound_operator>::value, std::string>::type string_from_expression(const T &op, bool /*noTableName*/ = false, bool /*escape*/ = false)
+            {
+                std::stringstream ss;
+                ss << this->string_from_expression(op.left) << " ";
+                ss << static_cast<std::string>(op) << " ";
+                ss << this->string_from_expression(op.right) << " ";
+                return ss.str();
+            }
              
             template<class T>
             std::string process_where(const conditions::is_null_t<T> &c) {
@@ -2363,9 +2377,10 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename column_result_t<self, T>::type,
-            typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr>
+            class R = typename column_result_t<self, T>::type>
             std::vector<R> select(T m, Args ...args) {
+                static_assert(!is_base_of_template<T, compound_operator>::value || std::tuple_size<std::tuple<Args...>>::value == 0,
+                              "Cannot use args with a compound operator");
                 using select_type = select_t<T, Args...>;
                 auto query = this->string_from_expression(select_type{std::move(m), std::make_tuple<Args...>(std::forward<Args>(args)...), true});
                 auto connection = this->get_or_create_connection();
@@ -2392,41 +2407,6 @@ namespace sqlite_orm {
                 }
             }
             
-            template<
-            class T,
-            class ...Args,
-            class Ret = typename column_result_t<self, T>::type,
-            typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
-            std::vector<Ret> select(T op, Args ...args) {
-                std::stringstream ss;
-                ss << this->string_from_expression(op.left) << " ";
-                ss << static_cast<std::string>(op) << " ";
-                ss << this->string_from_expression(op.right) << " ";
-                auto query = ss.str();
-                auto connection = this->get_or_create_connection();
-                sqlite3_stmt *stmt;
-                if (sqlite3_prepare_v2(connection->get_db(), query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
-                    statement_finalizer finalizer{stmt};
-                    std::vector<Ret> res;
-                    int stepRes;
-                    do{
-                        stepRes = sqlite3_step(stmt);
-                        switch(stepRes){
-                            case SQLITE_ROW:{
-                                res.push_back(row_extractor<Ret>().extract(stmt, 0));
-                            }break;
-                            case SQLITE_DONE: break;
-                            default:{
-                                throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
-                            }
-                        }
-                    }while(stepRes != SQLITE_DONE);
-                    return res;
-                }else{
-                    throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
-                }
-            }
-            
             /**
              *  Returns a string representation of object of a class mapped to the storage.
              *  Type of string has json-like style.
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 43c46d69d..9a464de17 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -6895,7 +6895,7 @@ namespace sqlite_orm {
             }
             
             template<class T>
-            std::string string_from_expression(T t, bool /*noTableName*/ = false, bool escape = false) {
+            typename std::enable_if<!is_base_of_template<T, compound_operator>::value, std::string>::type string_from_expression(T t, bool /*noTableName*/ = false, bool escape = false) {
                 auto isNullable = type_is_nullable<T>::value;
                 if(isNullable && !type_is_nullable<T>()(t)){
                     return "NULL";
@@ -7363,10 +7363,12 @@ namespace sqlite_orm {
             template<class T, class ...Args>
             std::string string_from_expression(const internal::select_t<T, Args...> &sel, bool /*noTableName*/ = false, bool /*escape*/ = false) {
                 std::stringstream ss;
-                if(!sel.highest_level){
-                    ss << "( ";
+                if(!is_base_of_template<T, compound_operator>::value){
+                    if(!sel.highest_level){
+                        ss << "( ";
+                    }
+                    ss << "SELECT ";
                 }
-                ss << "SELECT ";
                 if(get_distinct(sel.col)) {
                     ss << static_cast<std::string>(distinct(0)) << " ";
                 }
@@ -7406,8 +7408,10 @@ namespace sqlite_orm {
                 tuple_helper::iterator<std::tuple_size<tuple_t>::value - 1, Args...>()(sel.conditions, [&ss, this](auto &v){
                     this->process_single_condition(ss, v);
                 }, false);
-                if(!sel.highest_level){
-                    ss << ") ";
+                if(!is_base_of_template<T, compound_operator>::value){
+                    if(!sel.highest_level){
+                        ss << ") ";
+                    }
                 }
                 return ss.str();
             }
@@ -7418,6 +7422,16 @@ namespace sqlite_orm {
                 ss << static_cast<std::string>(c) << " ( " << this->string_from_expression(c.expression) << " AS " << type_printer<T>().print() << ") ";
                 return ss.str();
             }
+            
+            template<class T>
+            typename std::enable_if<is_base_of_template<T, compound_operator>::value, std::string>::type string_from_expression(const T &op, bool /*noTableName*/ = false, bool /*escape*/ = false)
+            {
+                std::stringstream ss;
+                ss << this->string_from_expression(op.left) << " ";
+                ss << static_cast<std::string>(op) << " ";
+                ss << this->string_from_expression(op.right) << " ";
+                return ss.str();
+            }
              
             template<class T>
             std::string process_where(const conditions::is_null_t<T> &c) {
@@ -8820,9 +8834,11 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename column_result_t<self, T>::type,
-            typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr>
+            class R = typename column_result_t<self, T>::type/*,
+            typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr*/>
             std::vector<R> select(T m, Args ...args) {
+                static_assert(!is_base_of_template<T, compound_operator>::value || std::tuple_size<std::tuple<Args...>>::value == 0,
+                              "Cannot use args with a compound operator");
                 using select_type = select_t<T, Args...>;
                 auto query = this->string_from_expression(select_type{std::move(m), std::make_tuple<Args...>(std::forward<Args>(args)...), true});
                 auto connection = this->get_or_create_connection();
@@ -8849,28 +8865,24 @@ namespace sqlite_orm {
                 }
             }
             
-            template<
+            /*template<
             class T,
-            class ...Args,
-            class Ret = typename column_result_t<self, T>::type,
+            class R = typename column_result_t<self, T>::type,
             typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
-            std::vector<Ret> select(T op, Args ...args) {
-                std::stringstream ss;
-                ss << this->string_from_expression(op.left) << " ";
-                ss << static_cast<std::string>(op) << " ";
-                ss << this->string_from_expression(op.right) << " ";
-                auto query = ss.str();
+            std::vector<R> select(T op) {
+                using select_type = select_t<T>;
+                auto query = this->string_from_expression(select_type{std::move(op)});
                 auto connection = this->get_or_create_connection();
                 sqlite3_stmt *stmt;
                 if (sqlite3_prepare_v2(connection->get_db(), query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
                     statement_finalizer finalizer{stmt};
-                    std::vector<Ret> res;
+                    std::vector<R> res;
                     int stepRes;
                     do{
                         stepRes = sqlite3_step(stmt);
                         switch(stepRes){
                             case SQLITE_ROW:{
-                                res.push_back(row_extractor<Ret>().extract(stmt, 0));
+                                res.push_back(row_extractor<R>().extract(stmt, 0));
                             }break;
                             case SQLITE_DONE: break;
                             default:{
@@ -8882,7 +8894,7 @@ namespace sqlite_orm {
                 }else{
                     throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
                 }
-            }
+            }*/
             
             /**
              *  Returns a string representation of object of a class mapped to the storage.

From 4a9084447de5a69a8831419feb0573db8994f204 Mon Sep 17 00:00:00 2001
From: Slobodan Kletnikov <slobodan_kletnikov@hotmail.com>
Date: Thu, 10 Jan 2019 20:55:19 +0100
Subject: [PATCH 38/63] Fix build error on windows

DELETE is already defined macro in winnt.h
---
 dev/journal_mode.h              | 3 +++
 include/sqlite_orm/sqlite_orm.h | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/dev/journal_mode.h b/dev/journal_mode.h
index 619d58ad0..a1f1a25c1 100644
--- a/dev/journal_mode.h
+++ b/dev/journal_mode.h
@@ -11,6 +11,9 @@ namespace sqlite_orm {
     /**
      *  Caps case cause of 1) delete keyword; 2) https://www.sqlite.org/pragma.html#pragma_journal_mode original spelling
      */
+    #ifdef DELETE
+        #undef DELETE
+    #endif
     enum class journal_mode : char {
         DELETE = 0,
         TRUNCATE = 1,
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 9a464de17..f53df2991 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -4095,6 +4095,9 @@ namespace sqlite_orm {
     /**
      *  Caps case cause of 1) delete keyword; 2) https://www.sqlite.org/pragma.html#pragma_journal_mode original spelling
      */
+    #ifdef DELETE
+        #undef DELETE
+    #endif
     enum class journal_mode : char {
         DELETE = 0,
         TRUNCATE = 1,

From a8f4dd91f130ea9b223d1802b5dc5172dce33f1f Mon Sep 17 00:00:00 2001
From: Yevgeniy Zakharov <fnc12@me.com>
Date: Wed, 23 Jan 2019 15:15:09 +0300
Subject: [PATCH 39/63] Update TODO.md

---
 TODO.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/TODO.md b/TODO.md
index c64f14363..c2b81c7d7 100644
--- a/TODO.md
+++ b/TODO.md
@@ -19,5 +19,6 @@
 * column alias
 * `FULL OUTER JOIN`
 * `WINDOW`
+* `UPSERT` https://www.sqlite.org/lang_UPSERT.html
 
 Please feel free to add any feature that isn't listed here and not implemented yet.

From 2295627b4df60316b17192c2d58ef931d8aa5c3c Mon Sep 17 00:00:00 2001
From: NIPE-SYSTEMS <dev.nipe.systems@gmail.com>
Date: Fri, 15 Feb 2019 17:04:22 +0100
Subject: [PATCH 40/63] Fix MSVC14 warning C4800 bool conversion

This changes a boolean expression to not forcing an integer value into a
boolean value. The expression compares if two lengths are both zero or
both not zero. This had been done by casting the length into a boolean and
is changed by this commit to an explicit boolean check whether 'length > 0'.
---
 dev/storage_impl.h              | 2 +-
 include/sqlite_orm/sqlite_orm.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/storage_impl.h b/dev/storage_impl.h
index 8a702da57..f9624d287 100644
--- a/dev/storage_impl.h
+++ b/dev/storage_impl.h
@@ -395,7 +395,7 @@ namespace sqlite_orm {
                             auto columnsAreEqual = dbColumnInfo.name == storageColumnInfo.name &&
                             *dbColumnInfoType == *storageColumnInfoType &&
                             dbColumnInfo.notnull == storageColumnInfo.notnull &&
-                            bool(dbColumnInfo.dflt_value.length()) == bool(storageColumnInfo.dflt_value.length()) &&
+                            (dbColumnInfo.dflt_value.length() > 0) == (storageColumnInfo.dflt_value.length() > 0) &&
                             dbColumnInfo.pk == storageColumnInfo.pk;
                             if(!columnsAreEqual){
                                 notEqual = true;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index f53df2991..d56f6f372 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -5950,7 +5950,7 @@ namespace sqlite_orm {
                             auto columnsAreEqual = dbColumnInfo.name == storageColumnInfo.name &&
                             *dbColumnInfoType == *storageColumnInfoType &&
                             dbColumnInfo.notnull == storageColumnInfo.notnull &&
-                            bool(dbColumnInfo.dflt_value.length()) == bool(storageColumnInfo.dflt_value.length()) &&
+                            (dbColumnInfo.dflt_value.length() > 0) == (storageColumnInfo.dflt_value.length() > 0) &&
                             dbColumnInfo.pk == storageColumnInfo.pk;
                             if(!columnsAreEqual){
                                 notEqual = true;

From 74c936802026102df8095de5e0410c60970314b7 Mon Sep 17 00:00:00 2001
From: Oscar Ostlund <oscar.ostlund@gmail.com>
Date: Tue, 19 Mar 2019 22:03:05 -0400
Subject: [PATCH 41/63] Use getter to access db from storage

---
 dev/storage.h                   | 2 +-
 include/sqlite_orm/sqlite_orm.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index f7af6aafa..f2171b1ed 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -3147,7 +3147,7 @@ namespace sqlite_orm {
                                        }, &tableNames,nullptr);
                 
                 if(res != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(connection->db()), get_sqlite_error_category()));
+                    throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
                 }
                 return tableNames;
             }
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d56f6f372..6d0e68f9a 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -9639,7 +9639,7 @@ namespace sqlite_orm {
                                        }, &tableNames,nullptr);
                 
                 if(res != SQLITE_OK) {
-                    throw std::system_error(std::error_code(sqlite3_errcode(connection->db()), get_sqlite_error_category()));
+                    throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
                 }
                 return tableNames;
             }

From 730417884dbac13a4efd14f0bdab02d262c6ca7b Mon Sep 17 00:00:00 2001
From: Matt Kline <matthew.kline@flukenetworks.com>
Date: Tue, 26 Feb 2019 17:32:42 -0800
Subject: [PATCH 42/63] Prefer unique_ptr over shared_ptr

Most scenarios don't need shared ownership of data, so we should prefer
unique_ptr when possible. It's more efficient, doesn't require atomic
ops for a reference count (which can cause major slowdowns on
weakly-ordered platforms like ARM), and can be promoted by the user to a
shared_ptr as-needed.
(Conversely, you _can't_ go from shared back to unique.)

This replaces all instances of shared_ptr with unique_ptr except for two
cases:

1. iterator_t's current item is shared among copies,
   as move-only iterators aren't currently allowed.
   (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0902r0.html)

2. The internal::connection returned by get_or_create_connection() is
   shared among those who call that function.

Another interesting step would be to use optional<T>, either from Boost
or from C++17, to avoid heap allocations where they aren't necessary.

See also:
https://herbsutter.com/2013/05/29/gotw-89-solution-smart-pointers/
---
 README.md                          |  16 +--
 dev/column.h                       |   8 +-
 dev/column_result.h                |   8 +-
 dev/default_value_extractor.h      |   8 +-
 dev/sqlite_type.h                  |   6 +-
 dev/storage.h                      | 104 +++++++++---------
 dev/table.h                        |   2 +-
 examples/core_functions.cpp        |   2 +-
 examples/custom_aliases.cpp        |   2 +
 examples/enum_binding.cpp          |   6 +-
 examples/left_and_inner_join.cpp   |  18 +--
 examples/nullable_enum_binding.cpp |  12 +-
 examples/select.cpp                |  20 ++--
 examples/unique.cpp                |   6 +-
 examples/update.cpp                |   4 +-
 include/sqlite_orm/sqlite_orm.h    | 170 ++++++++++++-----------------
 tests/tests.cpp                    |  29 +++--
 17 files changed, 199 insertions(+), 222 deletions(-)

diff --git a/README.md b/README.md
index 52558ba47..c48969e1c 100644
--- a/README.md
+++ b/README.md
@@ -50,7 +50,7 @@ struct User{
     std::string firstName;
     std::string lastName;
     int birthDate;
-    std::shared_ptr<std::string> imageUrl;      
+    std::unique_ptr<std::string> imageUrl;
     int typeId;
 };
 
@@ -96,7 +96,7 @@ More details about making storage can be found in [tutorial](https://github.com/
 Let's create and insert new `User` into database. First we need to create a `User` object with any id and call `insert` function. It will return id of just created user or throw exception if something goes wrong.
 
 ```c++
-User user{-1, "Jonh", "Doe", 664416000, std::make_shared<std::string>("url_to_heaven"), 3 };
+User user{-1, "Jonh", "Doe", 664416000, std::make_unique<std::string>("url_to_heaven"), 3 };
     
 auto insertedId = storage.insert(user);
 cout << "insertedId = " << insertedId << endl;      //  insertedId = 8
@@ -121,7 +121,7 @@ try{
 }
 ```
 
-Probably you may not like throwing exceptions. Me too. Exception `std::system_error` is thrown because return type in `get` function is not nullable. You can use alternative version `get_no_throw` which returns `std::shared_ptr` and doesn't throw `not_found_exception` if nothing found - just returns `nullptr`.
+Probably you may not like throwing exceptions. Me too. Exception `std::system_error` is thrown because return type in `get` function is not nullable. You can use alternative version `get_no_throw` which returns `std::unique_ptr` and doesn't throw `not_found_exception` if nothing found - just returns `nullptr`.
 
 ```c++
 if(auto user = storage.get_no_throw<User>(insertedId)){
@@ -131,7 +131,7 @@ if(auto user = storage.get_no_throw<User>(insertedId)){
 }
 ```
 
-`std::shared_ptr` is used as optional in `sqlite_orm`. Of course there is class optional in C++14 located at `std::experimental::optional`. But we don't want to use it until it is `experimental`.
+`std::unique_ptr` is used as optional in `sqlite_orm`. Of course there is class optional in C++14 located at `std::experimental::optional`. But we don't want to use it until it is `experimental`.
 
 We can also update our user. It updates row by id provided in `user` object and sets all other non `primary_key` fields to values stored in the passed `user` object. So you can just assign members to `user` object you want and call `update`
 
@@ -218,21 +218,21 @@ cout << "concatedUserIdWithDashes = " << concatedUserIdWithDashes << endl;
 
 //  SELECT MAX(id) FROM users
 if(auto maxId = storage.max(&User::id)){    
-    cout << "maxId = " << *maxId <<endl;    //  maxId = 12  (maxId is std::shared_ptr<int>)
+    cout << "maxId = " << *maxId <<endl;    //  maxId = 12  (maxId is std::unique_ptr<int>)
 }else{
     cout << "maxId is null" << endl;
 }
     
 //  SELECT MAX(first_name) FROM users
 if(auto maxFirstName = storage.max(&User::firstName)){ 
-    cout << "maxFirstName = " << *maxFirstName << endl; //  maxFirstName = Jonh (maxFirstName is std::shared_ptr<std::string>)
+    cout << "maxFirstName = " << *maxFirstName << endl; //  maxFirstName = Jonh (maxFirstName is std::unique_ptr<std::string>)
 }else{
     cout << "maxFirstName is null" << endl;
 }
 
 //  SELECT MIN(id) FROM users
 if(auto minId = storage.min(&User::id)){    
-    cout << "minId = " << *minId << endl;   //  minId = 1 (minId is std::shared_ptr<int>)
+    cout << "minId = " << *minId << endl;   //  minId = 1 (minId is std::unique_ptr<int>)
 }else{
     cout << "minId is null" << endl;
 }
@@ -245,7 +245,7 @@ if(auto minLastName = storage.min(&User::lastName)){
 }
 
 //  SELECT SUM(id) FROM users
-if(auto sumId = storage.sum(&User::id)){    //  sumId is std::shared_ptr<int>
+if(auto sumId = storage.sum(&User::id)){    //  sumId is std::unique_ptr<int>
     cout << "sumId = " << *sumId << endl;
 }else{
     cout << "sumId is null" << endl;
diff --git a/dev/column.h b/dev/column.h
index c277d1d96..6e1fcf1b4 100644
--- a/dev/column.h
+++ b/dev/column.h
@@ -2,7 +2,7 @@
 
 #include <tuple>    //  std::tuple
 #include <string>   //  std::string
-#include <memory>   //  std::shared_ptr
+#include <memory>   //  std::unique_ptr
 #include <type_traits>  //  std::true_type, std::false_type, std::is_same, std::enable_if
 
 #include "type_is_nullable.h"
@@ -85,12 +85,12 @@ namespace sqlite_orm {
              *  Simplified interface for `DEFAULT` constraint
              *  @return string representation of default value if it exists otherwise nullptr
              */
-            std::shared_ptr<std::string> default_value() {
-                std::shared_ptr<std::string> res;
+            std::unique_ptr<std::string> default_value() {
+                std::unique_ptr<std::string> res;
                 tuple_helper::iterator<std::tuple_size<constraints_type>::value - 1, Op...>()(constraints, [&res](auto &v){
                     auto dft = internal::default_value_extractor()(v);
                     if(dft){
-                        res = dft;
+                        res = std::move(dft);
                     }
                 });
                 return res;
diff --git a/dev/column_result.h b/dev/column_result.h
index 6a3195ce1..047d46844 100644
--- a/dev/column_result.h
+++ b/dev/column_result.h
@@ -74,7 +74,7 @@ namespace sqlite_orm {
         
         template<class St, class T>
         struct column_result_t<St, core_functions::abs_t<T>, void> {
-            using type = std::shared_ptr<double>;
+            using type = std::unique_ptr<double>;
         };
         
         template<class St, class T>
@@ -149,7 +149,7 @@ namespace sqlite_orm {
         
         template<class St, class T>
         struct column_result_t<St, aggregate_functions::sum_t<T>, void> {
-            using type = std::shared_ptr<double>;
+            using type = std::unique_ptr<double>;
         };
         
         template<class St, class T>
@@ -169,12 +169,12 @@ namespace sqlite_orm {
         
         template<class St, class T>
         struct column_result_t<St, aggregate_functions::max_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
+            using type = std::unique_ptr<typename column_result_t<St, T>::type>;
         };
         
         template<class St, class T>
         struct column_result_t<St, aggregate_functions::min_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
+            using type = std::unique_ptr<typename column_result_t<St, T>::type>;
         };
         
         template<class St>
diff --git a/dev/default_value_extractor.h b/dev/default_value_extractor.h
index 0f0c35913..add630f15 100644
--- a/dev/default_value_extractor.h
+++ b/dev/default_value_extractor.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <memory>   //  std::shared_ptr
+#include <memory>   //  std::unique_ptr
 #include <string>   //  std::string
 #include <sstream>  //  std::stringstream
 
@@ -17,15 +17,15 @@ namespace sqlite_orm {
         struct default_value_extractor {
             
             template<class A>
-            std::shared_ptr<std::string> operator() (const A &) {
+            std::unique_ptr<std::string> operator() (const A &) {
                 return {};
             }
             
             template<class T>
-            std::shared_ptr<std::string> operator() (const constraints::default_t<T> &t) {
+            std::unique_ptr<std::string> operator() (const constraints::default_t<T> &t) {
                 std::stringstream ss;
                 ss << t.value;
-                return std::make_shared<std::string>(ss.str());
+                return std::make_unique<std::string>(ss.str());
             }
         };
         
diff --git a/dev/sqlite_type.h b/dev/sqlite_type.h
index e1477d48c..55fe46be4 100644
--- a/dev/sqlite_type.h
+++ b/dev/sqlite_type.h
@@ -3,7 +3,7 @@
 #include <map>  //  std::map
 #include <string>   //  std::string
 #include <regex>    //  std::regex, std::regex_match
-#include <memory>   //  std::make_shared, std::shared_ptr
+#include <memory>   //  std::make_unique, std::unique_ptr
 #include <vector>   //  std::vector
 #include <cctype>   //  std::toupper
 
@@ -22,7 +22,7 @@ namespace sqlite_orm {
     /**
      *  @param str case doesn't matter - it is uppercased before comparing.
      */
-    inline std::shared_ptr<sqlite_type> to_sqlite_type(const std::string &str) {
+    inline std::unique_ptr<sqlite_type> to_sqlite_type(const std::string &str) {
         auto asciiStringToUpper = [](std::string &s){
             std::transform(s.begin(),
                            s.end(),
@@ -71,7 +71,7 @@ namespace sqlite_orm {
         for(auto &p : typeMap) {
             for(auto &r : p.second) {
                 if(std::regex_match(upperStr, r)){
-                    return std::make_shared<sqlite_type>(p.first);
+                    return std::make_unique<sqlite_type>(p.first);
                 }
             }
         }
diff --git a/dev/storage.h b/dev/storage.h
index f7af6aafa..0a411fcb0 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <memory>   //  std::shared_ptr, std::make_shared
+#include <memory>   //  std::unique/shared_ptr, std::make_unique/shared
 #include <string>   //  std::string
 #include <sqlite3.h>
 #include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay, std::false_type, std::true_type
@@ -68,7 +68,7 @@ namespace sqlite_orm {
                 
                 view_t(storage_t &stor, decltype(connection) conn, Args&& ...args):
                 storage(stor),
-                connection(conn),
+                connection(std::move(conn)),
                 query([&args..., &stor]{
                     std::string q;
                     stor.template generate_select_asterisk<T>(&q, args...);
@@ -77,21 +77,23 @@ namespace sqlite_orm {
                 
                 struct iterator_t {
                 protected:
-                    std::shared_ptr<sqlite3_stmt *> stmt;
+                    sqlite3_stmt *stmt;
                     view_t<T, Args...> &view;
-                    std::shared_ptr<T> temp;
+                    // shared_ptr is used over unique_ptr here
+                    // so that the iterator can be copyable.
+                    std::shared_ptr<T> current;
                     
-                    void extract_value(decltype(temp) &temp) {
-                        temp = std::make_shared<T>();
+                    void extract_value(std::unique_ptr<T> &temp) {
+                        temp = std::make_unique<T>();
                         auto &storage = this->view.storage;
                         auto &impl = storage.template get_impl<T>();
                         auto index = 0;
                         impl.table.for_each_column([&index, &temp, this] (auto &c) {
                             using field_type = typename std::decay<decltype(c)>::type::field_type;
-                            auto value = row_extractor<field_type>().extract(*this->stmt, index++);
+                            auto value = row_extractor<field_type>().extract(this->stmt, index++);
                             if(c.member_pointer){
                                 auto member_pointer = c.member_pointer;
-                                (*temp).*member_pointer = value;
+                                (*temp).*member_pointer = std::move(value);
                             }else{
                                 ((*temp).*(c.setter))(std::move(value));
                             }
@@ -105,7 +107,7 @@ namespace sqlite_orm {
                     using reference = value_type &;
                     using iterator_category = std::input_iterator_tag;
                     
-                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(std::make_shared<sqlite3_stmt *>(stmt_)), view(view_) {
+                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(stmt_), view(view_) {
                         this->operator++();
                     }
                     
@@ -118,41 +120,43 @@ namespace sqlite_orm {
                     iterator_t& operator=(const iterator_t&) = default;
                     
                     ~iterator_t() {
-                        if(this->stmt){
-                            statement_finalizer f{*this->stmt};
-                        }
+                        statement_finalizer f{this->stmt};
                     }
                     
                     T& operator*() {
                         if(!this->stmt) {
                             throw std::system_error(std::make_error_code(orm_error_code::trying_to_dereference_null_iterator));
                         }
-                        if(!this->temp){
-                            this->extract_value(this->temp);
+                        if(!this->current){
+                            std::unique_ptr<T> value;
+                            this->extract_value(value);
+                            this->current = std::move(value);
                         }
-                        return *this->temp;
+                        return *this->current;
                     }
                     
                     T* operator->() {
                         if(!this->stmt) {
                             throw std::system_error(std::make_error_code(orm_error_code::trying_to_dereference_null_iterator));
                         }
-                        if(!this->temp){
-                            this->extract_value(this->temp);
+                        if(!this->current){
+                            std::unique_ptr<T> value;
+                            this->extract_value(value);
+                            this->current = std::move(value);
                         }
-                        return &*this->temp;
+                        return &*this->current;
                     }
                     
                     void operator++() {
-                        if(this->stmt && *this->stmt){
-                            auto ret = sqlite3_step(*this->stmt);
+                        if(this->stmt){
+                            auto ret = sqlite3_step(this->stmt);
                             switch(ret){
                                 case SQLITE_ROW:
-                                    this->temp = nullptr;
+                                    this->current = nullptr;
                                     break;
                                 case SQLITE_DONE:{
-                                    statement_finalizer f{*this->stmt};
-                                    *this->stmt = nullptr;
+                                    statement_finalizer f{this->stmt};
+                                    this->stmt = nullptr;
                                 }break;
                                 default:{
                                     throw std::system_error(std::error_code(sqlite3_errcode(this->view.connection->get_db()), get_sqlite_error_category()));
@@ -167,7 +171,7 @@ namespace sqlite_orm {
                     
                     bool operator==(const iterator_t &other) const {
                         if(this->stmt && other.stmt){
-                            return *this->stmt == *other.stmt;
+                            return this->stmt == other.stmt;
                         }else{
                             if(!this->stmt && !other.stmt){
                                 return true;
@@ -1831,7 +1835,7 @@ namespace sqlite_orm {
             }
             
             template<class F, class O, class ...Args>
-            std::string group_concat_internal(F O::*m, std::shared_ptr<const std::string> y, Args&& ...args) {
+            std::string group_concat_internal(F O::*m, std::unique_ptr<const std::string> y, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
@@ -1895,7 +1899,7 @@ namespace sqlite_orm {
                                     using field_type = typename decltype(c)::field_type;
                                     auto value = row_extractor<field_type>().extract(stmt, index++);
                                     if(c.member_pointer){
-                                        obj.*c.member_pointer = value;
+                                        obj.*c.member_pointer = std::move(value);
                                     }else{
                                         ((obj).*(c.setter))(std::move(value));
                                     }
@@ -1928,7 +1932,7 @@ namespace sqlite_orm {
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<O> res;
+                std::unique_ptr<O> res;
                 std::stringstream ss;
                 ss << "SELECT ";
                 auto columnNames = impl.table.column_names();
@@ -1970,7 +1974,7 @@ namespace sqlite_orm {
                                     using field_type = typename decltype(c)::field_type;
                                     auto value = row_extractor<field_type>().extract(stmt, index++);
                                     if(c.member_pointer){
-                                        res.*c.member_pointer = value;
+                                        res.*c.member_pointer = std::move(value);
                                     }else{
                                         ((res).*(c.setter))(std::move(value));
                                     }
@@ -1993,16 +1997,16 @@ namespace sqlite_orm {
             }
             
             /**
-             *  The same as `get` function but doesn't throw an exception if noting found but returns std::shared_ptr with null value.
+             *  The same as `get` function but doesn't throw an exception if noting found but returns std::unique_ptr with null value.
              *  throws std::system_error in case of db error.
              */
             template<class O, class ...Ids>
-            std::shared_ptr<O> get_no_throw(Ids ...ids) {
+            std::unique_ptr<O> get_no_throw(Ids ...ids) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<O> res;
+                std::unique_ptr<O> res;
                 std::stringstream ss;
                 ss << "SELECT ";
                 auto columnNames = impl.table.column_names();
@@ -2044,12 +2048,12 @@ namespace sqlite_orm {
                                     using field_type = typename decltype(c)::field_type;
                                     auto value = row_extractor<field_type>().extract(stmt, index++);
                                     if(c.member_pointer){
-                                        res.*c.member_pointer = value;
+                                        res.*c.member_pointer = std::move(value);
                                     }else{
                                         ((res).*(c.setter))(std::move(value));
                                     }
                                 });
-                                return std::make_shared<O>(std::move(res));
+                                return std::make_unique<O>(std::move(res));
                             }break;
                             case SQLITE_DONE:{
                                 return {};
@@ -2198,26 +2202,26 @@ namespace sqlite_orm {
              */
             template<class F, class O, class ...Args>
             std::string group_concat(F O::*m, const std::string &y, Args&& ...args) {
-                return this->group_concat_internal(m, std::make_shared<std::string>(y), std::forward<Args>(args)...);
+                return this->group_concat_internal(m, std::make_unique<std::string>(y), std::forward<Args>(args)...);
             }
             
             template<class F, class O, class ...Args>
             std::string group_concat(F O::*m, const char *y, Args&& ...args) {
-                return this->group_concat_internal(m, std::make_shared<std::string>(y), std::forward<Args>(args)...);
+                return this->group_concat_internal(m, std::make_unique<std::string>(y), std::forward<Args>(args)...);
             }
             
             /**
              *  MAX(x) query.
              *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::shared_ptr with max value or null if sqlite engine returned null.
+             *  @return std::unique_ptr with max value or null if sqlite engine returned null.
              */
             template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::shared_ptr<Ret> max(F O::*m, Args&& ...args) {
+            std::unique_ptr<Ret> max(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<Ret> res;
+                std::unique_ptr<Ret> res;
                 std::stringstream ss;
                 ss << "SELECT " << static_cast<std::string>(sqlite_orm::max(0)) << "(";
                 auto columnName = this->string_from_expression(m);
@@ -2228,10 +2232,10 @@ namespace sqlite_orm {
                     auto rc = sqlite3_exec(connection->get_db(),
                                            query.c_str(),
                                            [](void *data, int argc, char **argv,char **)->int{
-                                               auto &res = *(std::shared_ptr<Ret>*)data;
+                                               auto &res = *(std::unique_ptr<Ret>*)data;
                                                if(argc){
                                                    if(argv[0]){
-                                                       res = std::make_shared<Ret>(row_extractor<Ret>().extract(argv[0]));
+                                                       res = std::make_unique<Ret>(row_extractor<Ret>().extract(argv[0]));
                                                    }
                                                }
                                                return 0;
@@ -2248,15 +2252,15 @@ namespace sqlite_orm {
             /**
              *  MIN(x) query.
              *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::shared_ptr with min value or null if sqlite engine returned null.
+             *  @return std::unique_ptr with min value or null if sqlite engine returned null.
              */
             template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::shared_ptr<Ret> min(F O::*m, Args&& ...args) {
+            std::unique_ptr<Ret> min(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<Ret> res;
+                std::unique_ptr<Ret> res;
                 std::stringstream ss;
                 ss << "SELECT " << static_cast<std::string>(sqlite_orm::min(0)) << "(";
                 auto columnName = this->string_from_expression(m);
@@ -2267,10 +2271,10 @@ namespace sqlite_orm {
                     auto rc = sqlite3_exec(connection->get_db(),
                                            query.c_str(),
                                            [](void *data, int argc, char **argv,char **)->int{
-                                               auto &res = *(std::shared_ptr<Ret>*)data;
+                                               auto &res = *(std::unique_ptr<Ret>*)data;
                                                if(argc){
                                                    if(argv[0]){
-                                                       res = std::make_shared<Ret>(row_extractor<Ret>().extract(argv[0]));
+                                                       res = std::make_unique<Ret>(row_extractor<Ret>().extract(argv[0]));
                                                    }
                                                }
                                                return 0;
@@ -2287,15 +2291,15 @@ namespace sqlite_orm {
             /**
              *  SUM(x) query.
              *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::shared_ptr with sum value or null if sqlite engine returned null.
+             *  @return std::unique_ptr with sum value or null if sqlite engine returned null.
              */
             template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::shared_ptr<Ret> sum(F O::*m, Args&& ...args) {
+            std::unique_ptr<Ret> sum(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<Ret> res;
+                std::unique_ptr<Ret> res;
                 std::stringstream ss;
                 ss << "SELECT " << static_cast<std::string>(sqlite_orm::sum(0)) << "(";
                 auto columnName = this->string_from_expression(m);
@@ -2306,9 +2310,9 @@ namespace sqlite_orm {
                     auto rc = sqlite3_exec(connection->get_db(),
                                            query.c_str(),
                                            [](void *data, int argc, char **argv, char **)->int{
-                                               auto &res = *(std::shared_ptr<Ret>*)data;
+                                               auto &res = *(std::unique_ptr<Ret>*)data;
                                                if(argc){
-                                                   res = std::make_shared<Ret>(row_extractor<Ret>().extract(argv[0]));
+                                                   res = std::make_unique<Ret>(row_extractor<Ret>().extract(argv[0]));
                                                }
                                                return 0;
                                            }, &res, nullptr);
diff --git a/dev/table.h b/dev/table.h
index b55b67c61..2b481d04e 100644
--- a/dev/table.h
+++ b/dev/table.h
@@ -280,7 +280,7 @@ namespace sqlite_orm {
     
     /**
      *  Function used for table creation. Do not use table constructor - use this function
-     *  cause table class is templated and its constructing too (just like std::make_shared or std::make_pair).
+     *  cause table class is templated and its constructing too (just like std::make_unique or std::make_pair).
      */
     template<class ...Cs, class T = typename std::tuple_element<0, std::tuple<Cs...>>::type::object_type>
     internal::table_t<T, Cs...> make_table(const std::string &name, Cs&& ...args) {
diff --git a/examples/core_functions.cpp b/examples/core_functions.cpp
index 9426ae15b..d47d0b964 100644
--- a/examples/core_functions.cpp
+++ b/examples/core_functions.cpp
@@ -70,7 +70,7 @@ int main(int argc, char **argv) {
     cout << "customTwo = {" << std::get<0>(customTwo.front()) << ", " << std::get<1>(customTwo.front()) << "}" << endl;
     
     //  SELECT ABS(points) FROM marvel
-    auto absPoints = storage.select(abs(&MarvelHero::points));  //  std::vector<std::shared_ptr<int>>
+    auto absPoints = storage.select(abs(&MarvelHero::points));  //  std::vector<std::unique_ptr<int>>
     cout << "absPoints: ";
     for(auto &value : absPoints) {
         if(value) {
diff --git a/examples/custom_aliases.cpp b/examples/custom_aliases.cpp
index 6003769cf..beaa6888c 100644
--- a/examples/custom_aliases.cpp
+++ b/examples/custom_aliases.cpp
@@ -3,6 +3,8 @@
  */
 
 #include <sqlite_orm/sqlite_orm.h>
+
+#include <cassert>
 #include <string>
 #include <iostream>
 
diff --git a/examples/enum_binding.cpp b/examples/enum_binding.cpp
index e1f0aafad..72e84a3a5 100644
--- a/examples/enum_binding.cpp
+++ b/examples/enum_binding.cpp
@@ -41,11 +41,11 @@ std::string GenderToString(Gender gender) {
  *  that's why I placed it separatedly. You can use any transformation type/form
  *  (for example BETTER_ENUM https://github.com/aantron/better-enums)
  */
-std::shared_ptr<Gender> GenderFromString(const std::string &s) {
+std::unique_ptr<Gender> GenderFromString(const std::string &s) {
     if(s == "female") {
-        return std::make_shared<Gender>(Gender::Female);
+        return std::make_unique<Gender>(Gender::Female);
     }else if(s == "male") {
-        return std::make_shared<Gender>(Gender::Male);
+        return std::make_unique<Gender>(Gender::Male);
     }
     return nullptr;
 }
diff --git a/examples/left_and_inner_join.cpp b/examples/left_and_inner_join.cpp
index 286ccc4d4..7cf3a272b 100644
--- a/examples/left_and_inner_join.cpp
+++ b/examples/left_and_inner_join.cpp
@@ -13,25 +13,25 @@ using std::cout;
 using std::endl;
 
 struct Artist {
-    std::shared_ptr<int> artistId;
-    std::shared_ptr<std::string> name;
+    std::unique_ptr<int> artistId;
+    std::unique_ptr<std::string> name;
 };
 
 struct Album {
-    std::shared_ptr<int> albumId;
-    std::shared_ptr<std::string> title;
-    std::shared_ptr<int> artistId;
+    std::unique_ptr<int> albumId;
+    std::unique_ptr<std::string> title;
+    std::unique_ptr<int> artistId;
 };
 
 struct Track {
     int trackId;
     std::string name;
-    std::shared_ptr<int> albumId;
+    std::unique_ptr<int> albumId;
     int mediaTypeId;
-    std::shared_ptr<int> genreId;
-    std::shared_ptr<std::string> composer;
+    std::unique_ptr<int> genreId;
+    std::unique_ptr<std::string> composer;
     long milliseconds;
-    std::shared_ptr<long> bytes;
+    std::unique_ptr<long> bytes;
     double unitPrice;
 };
 
diff --git a/examples/nullable_enum_binding.cpp b/examples/nullable_enum_binding.cpp
index 36dcd1515..490f72dc2 100644
--- a/examples/nullable_enum_binding.cpp
+++ b/examples/nullable_enum_binding.cpp
@@ -19,19 +19,19 @@ enum class Gender {
     Female,
 };
 
-std::shared_ptr<std::string> GenderToString(Gender gender) {
+std::unique_ptr<std::string> GenderToString(Gender gender) {
     switch(gender){
-        case Gender::Female:return std::make_shared<std::string>("female");
-        case Gender::Male:return std::make_shared<std::string>("male");
+        case Gender::Female:return std::make_unique<std::string>("female");
+        case Gender::Male:return std::make_unique<std::string>("male");
         case Gender::None:return {};
     }
 }
 
-std::shared_ptr<Gender> GenderFromString(const std::string &s) {
+std::unique_ptr<Gender> GenderFromString(const std::string &s) {
     if(s == "female") {
-        return std::make_shared<Gender>(Gender::Female);
+        return std::make_unique<Gender>(Gender::Female);
     }else if(s == "male") {
-        return std::make_shared<Gender>(Gender::Male);
+        return std::make_unique<Gender>(Gender::Male);
     }
     return nullptr;
 }
diff --git a/examples/select.cpp b/examples/select.cpp
index 2bf13fe28..20bb342eb 100644
--- a/examples/select.cpp
+++ b/examples/select.cpp
@@ -10,8 +10,8 @@ struct Employee {
     int id;
     std::string name;
     int age;
-    std::shared_ptr<std::string> address;   //  optional
-    std::shared_ptr<double> salary; //  optional
+    std::unique_ptr<std::string> address;   //  optional
+    std::unique_ptr<double> salary; //  optional
 };
 
 using namespace sqlite_orm;
@@ -31,13 +31,13 @@ int main(int argc, char **argv) {
     storage.remove_all<Employee>(); //  remove all old employees in case they exist in db..
     
     //  create employees..
-    Employee paul{-1, "Paul", 32, std::make_shared<std::string>("California"), std::make_shared<double>(20000.0) };
-    Employee allen{-1, "Allen", 25, std::make_shared<std::string>("Texas"), std::make_shared<double>(15000.0) };
-    Employee teddy{-1, "Teddy", 23, std::make_shared<std::string>("Norway"), std::make_shared<double>(20000.0) };
-    Employee mark{-1, "Mark", 25, std::make_shared<std::string>("Rich-Mond"), std::make_shared<double>(65000.0) };
-    Employee david{-1, "David", 27, std::make_shared<std::string>("Texas"), std::make_shared<double>(85000.0) };
-    Employee kim{-1, "Kim", 22, std::make_shared<std::string>("South-Hall"), std::make_shared<double>(45000.0) };
-    Employee james{-1, "James", 24, std::make_shared<std::string>("Houston"), std::make_shared<double>(10000.0) };
+    Employee paul{-1, "Paul", 32, std::make_unique<std::string>("California"), std::make_unique<double>(20000.0) };
+    Employee allen{-1, "Allen", 25, std::make_unique<std::string>("Texas"), std::make_unique<double>(15000.0) };
+    Employee teddy{-1, "Teddy", 23, std::make_unique<std::string>("Norway"), std::make_unique<double>(20000.0) };
+    Employee mark{-1, "Mark", 25, std::make_unique<std::string>("Rich-Mond"), std::make_unique<double>(65000.0) };
+    Employee david{-1, "David", 27, std::make_unique<std::string>("Texas"), std::make_unique<double>(85000.0) };
+    Employee kim{-1, "Kim", 22, std::make_unique<std::string>("South-Hall"), std::make_unique<double>(45000.0) };
+    Employee james{-1, "James", 24, std::make_unique<std::string>("Houston"), std::make_unique<double>(10000.0) };
     
     //  insert employees. `insert` function returns id of inserted object..
     paul.id = storage.insert(paul);
@@ -67,7 +67,7 @@ int main(int argc, char **argv) {
     auto idsNamesSalarys = storage.select(columns(&Employee::id,
                                                   &Employee::name,
                                                   &Employee::salary));
-    //  decltype(idsNamesSalarys) = std::vector<std::tuple<int, std::string, std::shared_ptr<double>>>
+    //  decltype(idsNamesSalarys) = std::vector<std::tuple<int, std::string, std::unique_ptr<double>>>
     for(auto &tpl : idsNamesSalarys) {
         cout << "id = " << std::get<0>(tpl) << ", name = " << std::get<1>(tpl) << ", salary = ";
         if(std::get<2>(tpl)){
diff --git a/examples/unique.cpp b/examples/unique.cpp
index 2fbee915c..82ce29f41 100644
--- a/examples/unique.cpp
+++ b/examples/unique.cpp
@@ -11,7 +11,7 @@ using std::cerr;
 struct Entry {
     int id;
     std::string uniqueColumn;
-    std::shared_ptr<std::string> nullableColumn;
+    std::unique_ptr<std::string> nullableColumn;
 };
 
 int main(int argc, char **argv) {
@@ -27,12 +27,12 @@ int main(int argc, char **argv) {
     try {
         auto sameString = "Bebe Rexha";
         
-        auto id1 = storage.insert(Entry{ 0, sameString, std::make_shared<std::string>("The way I are") });
+        auto id1 = storage.insert(Entry{ 0, sameString, std::make_unique<std::string>("The way I are") });
         cout << "inserted " << storage.dump(storage.get<Entry>(id1)) << endl;
         
         //  it's ok but the next line will throw std::system_error
         
-        auto id2 = storage.insert(Entry{ 0, sameString, std::make_shared<std::string>("I got you") });
+        auto id2 = storage.insert(Entry{ 0, sameString, std::make_unique<std::string>("I got you") });
         cout << "inserted " << storage.dump(storage.get<Entry>(id2)) << endl;
     } catch (std::system_error e) {
         cerr << e.what() << endl;
diff --git a/examples/update.cpp b/examples/update.cpp
index 3e44f065e..3f26ea049 100644
--- a/examples/update.cpp
+++ b/examples/update.cpp
@@ -30,10 +30,10 @@ inline auto initStorage(const std::string &path) {
 
 using Storage = decltype(initStorage(""));
 
-static std::shared_ptr<Storage> stor;
+static std::unique_ptr<Storage> stor;
 
 int main(int argc, char **argv) {
-    stor = std::make_shared<Storage>(initStorage("update.sqlite"));
+    stor = std::make_unique<Storage>(initStorage("update.sqlite"));
     stor->sync_schema();
     stor->remove_all<Employee>();
 
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index d56f6f372..ab7fd7ddb 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -111,7 +111,7 @@ namespace std
 #include <map>  //  std::map
 #include <string>   //  std::string
 #include <regex>    //  std::regex, std::regex_match
-#include <memory>   //  std::make_shared, std::shared_ptr
+#include <memory>   //  std::make_unique, std::unique_ptr
 #include <vector>   //  std::vector
 #include <cctype>   //  std::toupper
 
@@ -130,7 +130,7 @@ namespace sqlite_orm {
     /**
      *  @param str case doesn't matter - it is uppercased before comparing.
      */
-    inline std::shared_ptr<sqlite_type> to_sqlite_type(const std::string &str) {
+    inline std::unique_ptr<sqlite_type> to_sqlite_type(const std::string &str) {
         auto asciiStringToUpper = [](std::string &s){
             std::transform(s.begin(),
                            s.end(),
@@ -179,7 +179,7 @@ namespace sqlite_orm {
         for(auto &p : typeMap) {
             for(auto &r : p.second) {
                 if(std::regex_match(upperStr, r)){
-                    return std::make_shared<sqlite_type>(p.first);
+                    return std::make_unique<sqlite_type>(p.first);
                 }
             }
         }
@@ -864,7 +864,7 @@ namespace sqlite_orm {
 }
 #pragma once
 
-#include <memory>   //  std::shared_ptr
+#include <memory>   //  std::unique_ptr
 #include <string>   //  std::string
 #include <sstream>  //  std::stringstream
 
@@ -882,15 +882,15 @@ namespace sqlite_orm {
         struct default_value_extractor {
             
             template<class A>
-            std::shared_ptr<std::string> operator() (const A &) {
+            std::unique_ptr<std::string> operator() (const A &) {
                 return {};
             }
             
             template<class T>
-            std::shared_ptr<std::string> operator() (const constraints::default_t<T> &t) {
+            std::unique_ptr<std::string> operator() (const constraints::default_t<T> &t) {
                 std::stringstream ss;
                 ss << t.value;
-                return std::make_shared<std::string>(ss.str());
+                return std::make_unique<std::string>(ss.str());
             }
         };
         
@@ -1099,7 +1099,7 @@ namespace sqlite_orm {
 
 #include <tuple>    //  std::tuple
 #include <string>   //  std::string
-#include <memory>   //  std::shared_ptr
+#include <memory>   //  std::unique_ptr
 #include <type_traits>  //  std::true_type, std::false_type, std::is_same, std::enable_if
 
 // #include "type_is_nullable.h"
@@ -1186,12 +1186,12 @@ namespace sqlite_orm {
              *  Simplified interface for `DEFAULT` constraint
              *  @return string representation of default value if it exists otherwise nullptr
              */
-            std::shared_ptr<std::string> default_value() {
-                std::shared_ptr<std::string> res;
+            std::unique_ptr<std::string> default_value() {
+                std::unique_ptr<std::string> res;
                 tuple_helper::iterator<std::tuple_size<constraints_type>::value - 1, Op...>()(constraints, [&res](auto &v){
                     auto dft = internal::default_value_extractor()(v);
                     if(dft){
-                        res = dft;
+                        res = std::move(dft);
                     }
                 });
                 return res;
@@ -4819,7 +4819,7 @@ namespace sqlite_orm {
         
         template<class St, class T>
         struct column_result_t<St, core_functions::abs_t<T>, void> {
-            using type = std::shared_ptr<double>;
+            using type = std::unique_ptr<double>;
         };
         
         template<class St, class T>
@@ -4894,7 +4894,7 @@ namespace sqlite_orm {
         
         template<class St, class T>
         struct column_result_t<St, aggregate_functions::sum_t<T>, void> {
-            using type = std::shared_ptr<double>;
+            using type = std::unique_ptr<double>;
         };
         
         template<class St, class T>
@@ -4914,12 +4914,12 @@ namespace sqlite_orm {
         
         template<class St, class T>
         struct column_result_t<St, aggregate_functions::max_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
+            using type = std::unique_ptr<typename column_result_t<St, T>::type>;
         };
         
         template<class St, class T>
         struct column_result_t<St, aggregate_functions::min_t<T>, void> {
-            using type = std::shared_ptr<typename column_result_t<St, T>::type>;
+            using type = std::unique_ptr<typename column_result_t<St, T>::type>;
         };
         
         template<class St>
@@ -5503,7 +5503,7 @@ namespace sqlite_orm {
     
     /**
      *  Function used for table creation. Do not use table constructor - use this function
-     *  cause table class is templated and its constructing too (just like std::make_shared or std::make_pair).
+     *  cause table class is templated and its constructing too (just like std::make_unique or std::make_pair).
      */
     template<class ...Cs, class T = typename std::tuple_element<0, std::tuple<Cs...>>::type::object_type>
     internal::table_t<T, Cs...> make_table(const std::string &name, Cs&& ...args) {
@@ -6117,7 +6117,7 @@ namespace sqlite_orm {
 }
 #pragma once
 
-#include <memory>   //  std::shared_ptr, std::make_shared
+#include <memory>   //  std::unique/shared_ptr, std::make_unique/shared
 #include <string>   //  std::string
 #include <sqlite3.h>
 #include <type_traits>  //  std::remove_reference, std::is_base_of, std::decay, std::false_type, std::true_type
@@ -6528,7 +6528,7 @@ namespace sqlite_orm {
                 
                 view_t(storage_t &stor, decltype(connection) conn, Args&& ...args):
                 storage(stor),
-                connection(conn),
+                connection(std::move(conn)),
                 query([&args..., &stor]{
                     std::string q;
                     stor.template generate_select_asterisk<T>(&q, args...);
@@ -6537,21 +6537,23 @@ namespace sqlite_orm {
                 
                 struct iterator_t {
                 protected:
-                    std::shared_ptr<sqlite3_stmt *> stmt;
+                    sqlite3_stmt *stmt;
                     view_t<T, Args...> &view;
-                    std::shared_ptr<T> temp;
+                    // shared_ptr is used over unique_ptr here
+                    // so that the iterator can be copyable.
+                    std::shared_ptr<T> current;
                     
-                    void extract_value(decltype(temp) &temp) {
-                        temp = std::make_shared<T>();
+                    void extract_value(std::unique_ptr<T> &temp) {
+                        temp = std::make_unique<T>();
                         auto &storage = this->view.storage;
                         auto &impl = storage.template get_impl<T>();
                         auto index = 0;
                         impl.table.for_each_column([&index, &temp, this] (auto &c) {
                             using field_type = typename std::decay<decltype(c)>::type::field_type;
-                            auto value = row_extractor<field_type>().extract(*this->stmt, index++);
+                            auto value = row_extractor<field_type>().extract(this->stmt, index++);
                             if(c.member_pointer){
                                 auto member_pointer = c.member_pointer;
-                                (*temp).*member_pointer = value;
+                                (*temp).*member_pointer = std::move(value);
                             }else{
                                 ((*temp).*(c.setter))(std::move(value));
                             }
@@ -6565,7 +6567,7 @@ namespace sqlite_orm {
                     using reference = value_type &;
                     using iterator_category = std::input_iterator_tag;
                     
-                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(std::make_shared<sqlite3_stmt *>(stmt_)), view(view_) {
+                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(stmt_), view(view_) {
                         this->operator++();
                     }
                     
@@ -6578,41 +6580,43 @@ namespace sqlite_orm {
                     iterator_t& operator=(const iterator_t&) = default;
                     
                     ~iterator_t() {
-                        if(this->stmt){
-                            statement_finalizer f{*this->stmt};
-                        }
+                        statement_finalizer f{this->stmt};
                     }
                     
                     T& operator*() {
                         if(!this->stmt) {
                             throw std::system_error(std::make_error_code(orm_error_code::trying_to_dereference_null_iterator));
                         }
-                        if(!this->temp){
-                            this->extract_value(this->temp);
+                        if(!this->current){
+                            std::unique_ptr<T> value;
+                            this->extract_value(value);
+                            this->current = std::move(value);
                         }
-                        return *this->temp;
+                        return *this->current;
                     }
                     
                     T* operator->() {
                         if(!this->stmt) {
                             throw std::system_error(std::make_error_code(orm_error_code::trying_to_dereference_null_iterator));
                         }
-                        if(!this->temp){
-                            this->extract_value(this->temp);
+                        if(!this->current){
+                            std::unique_ptr<T> value;
+                            this->extract_value(value);
+                            this->current = std::move(value);
                         }
-                        return &*this->temp;
+                        return &*this->current;
                     }
                     
                     void operator++() {
-                        if(this->stmt && *this->stmt){
-                            auto ret = sqlite3_step(*this->stmt);
+                        if(this->stmt){
+                            auto ret = sqlite3_step(this->stmt);
                             switch(ret){
                                 case SQLITE_ROW:
-                                    this->temp = nullptr;
+                                    this->current = nullptr;
                                     break;
                                 case SQLITE_DONE:{
-                                    statement_finalizer f{*this->stmt};
-                                    *this->stmt = nullptr;
+                                    statement_finalizer f{this->stmt};
+                                    this->stmt = nullptr;
                                 }break;
                                 default:{
                                     throw std::system_error(std::error_code(sqlite3_errcode(this->view.connection->get_db()), get_sqlite_error_category()));
@@ -6627,7 +6631,7 @@ namespace sqlite_orm {
                     
                     bool operator==(const iterator_t &other) const {
                         if(this->stmt && other.stmt){
-                            return *this->stmt == *other.stmt;
+                            return this->stmt == other.stmt;
                         }else{
                             if(!this->stmt && !other.stmt){
                                 return true;
@@ -8291,7 +8295,7 @@ namespace sqlite_orm {
             }
             
             template<class F, class O, class ...Args>
-            std::string group_concat_internal(F O::*m, std::shared_ptr<const std::string> y, Args&& ...args) {
+            std::string group_concat_internal(F O::*m, std::unique_ptr<const std::string> y, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
@@ -8355,7 +8359,7 @@ namespace sqlite_orm {
                                     using field_type = typename decltype(c)::field_type;
                                     auto value = row_extractor<field_type>().extract(stmt, index++);
                                     if(c.member_pointer){
-                                        obj.*c.member_pointer = value;
+                                        obj.*c.member_pointer = std::move(value);
                                     }else{
                                         ((obj).*(c.setter))(std::move(value));
                                     }
@@ -8388,7 +8392,7 @@ namespace sqlite_orm {
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<O> res;
+                std::unique_ptr<O> res;
                 std::stringstream ss;
                 ss << "SELECT ";
                 auto columnNames = impl.table.column_names();
@@ -8430,7 +8434,7 @@ namespace sqlite_orm {
                                     using field_type = typename decltype(c)::field_type;
                                     auto value = row_extractor<field_type>().extract(stmt, index++);
                                     if(c.member_pointer){
-                                        res.*c.member_pointer = value;
+                                        res.*c.member_pointer = std::move(value);
                                     }else{
                                         ((res).*(c.setter))(std::move(value));
                                     }
@@ -8453,16 +8457,16 @@ namespace sqlite_orm {
             }
             
             /**
-             *  The same as `get` function but doesn't throw an exception if noting found but returns std::shared_ptr with null value.
+             *  The same as `get` function but doesn't throw an exception if noting found but returns std::unique_ptr with null value.
              *  throws std::system_error in case of db error.
              */
             template<class O, class ...Ids>
-            std::shared_ptr<O> get_no_throw(Ids ...ids) {
+            std::unique_ptr<O> get_no_throw(Ids ...ids) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<O> res;
+                std::unique_ptr<O> res;
                 std::stringstream ss;
                 ss << "SELECT ";
                 auto columnNames = impl.table.column_names();
@@ -8504,12 +8508,12 @@ namespace sqlite_orm {
                                     using field_type = typename decltype(c)::field_type;
                                     auto value = row_extractor<field_type>().extract(stmt, index++);
                                     if(c.member_pointer){
-                                        res.*c.member_pointer = value;
+                                        res.*c.member_pointer = std::move(value);
                                     }else{
                                         ((res).*(c.setter))(std::move(value));
                                     }
                                 });
-                                return std::make_shared<O>(std::move(res));
+                                return std::make_unique<O>(std::move(res));
                             }break;
                             case SQLITE_DONE:{
                                 return {};
@@ -8658,26 +8662,26 @@ namespace sqlite_orm {
              */
             template<class F, class O, class ...Args>
             std::string group_concat(F O::*m, const std::string &y, Args&& ...args) {
-                return this->group_concat_internal(m, std::make_shared<std::string>(y), std::forward<Args>(args)...);
+                return this->group_concat_internal(m, std::make_unique<std::string>(y), std::forward<Args>(args)...);
             }
             
             template<class F, class O, class ...Args>
             std::string group_concat(F O::*m, const char *y, Args&& ...args) {
-                return this->group_concat_internal(m, std::make_shared<std::string>(y), std::forward<Args>(args)...);
+                return this->group_concat_internal(m, std::make_unique<std::string>(y), std::forward<Args>(args)...);
             }
             
             /**
              *  MAX(x) query.
              *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::shared_ptr with max value or null if sqlite engine returned null.
+             *  @return std::unique_ptr with max value or null if sqlite engine returned null.
              */
             template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::shared_ptr<Ret> max(F O::*m, Args&& ...args) {
+            std::unique_ptr<Ret> max(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<Ret> res;
+                std::unique_ptr<Ret> res;
                 std::stringstream ss;
                 ss << "SELECT " << static_cast<std::string>(sqlite_orm::max(0)) << "(";
                 auto columnName = this->string_from_expression(m);
@@ -8688,10 +8692,10 @@ namespace sqlite_orm {
                     auto rc = sqlite3_exec(connection->get_db(),
                                            query.c_str(),
                                            [](void *data, int argc, char **argv,char **)->int{
-                                               auto &res = *(std::shared_ptr<Ret>*)data;
+                                               auto &res = *(std::unique_ptr<Ret>*)data;
                                                if(argc){
                                                    if(argv[0]){
-                                                       res = std::make_shared<Ret>(row_extractor<Ret>().extract(argv[0]));
+                                                       res = std::make_unique<Ret>(row_extractor<Ret>().extract(argv[0]));
                                                    }
                                                }
                                                return 0;
@@ -8708,15 +8712,15 @@ namespace sqlite_orm {
             /**
              *  MIN(x) query.
              *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::shared_ptr with min value or null if sqlite engine returned null.
+             *  @return std::unique_ptr with min value or null if sqlite engine returned null.
              */
             template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::shared_ptr<Ret> min(F O::*m, Args&& ...args) {
+            std::unique_ptr<Ret> min(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<Ret> res;
+                std::unique_ptr<Ret> res;
                 std::stringstream ss;
                 ss << "SELECT " << static_cast<std::string>(sqlite_orm::min(0)) << "(";
                 auto columnName = this->string_from_expression(m);
@@ -8727,10 +8731,10 @@ namespace sqlite_orm {
                     auto rc = sqlite3_exec(connection->get_db(),
                                            query.c_str(),
                                            [](void *data, int argc, char **argv,char **)->int{
-                                               auto &res = *(std::shared_ptr<Ret>*)data;
+                                               auto &res = *(std::unique_ptr<Ret>*)data;
                                                if(argc){
                                                    if(argv[0]){
-                                                       res = std::make_shared<Ret>(row_extractor<Ret>().extract(argv[0]));
+                                                       res = std::make_unique<Ret>(row_extractor<Ret>().extract(argv[0]));
                                                    }
                                                }
                                                return 0;
@@ -8747,15 +8751,15 @@ namespace sqlite_orm {
             /**
              *  SUM(x) query.
              *  @param m is a class member pointer (the same you passed into make_column).
-             *  @return std::shared_ptr with sum value or null if sqlite engine returned null.
+             *  @return std::unique_ptr with sum value or null if sqlite engine returned null.
              */
             template<class F, class O, class ...Args, class Ret = typename column_result_t<self, F O::*>::type>
-            std::shared_ptr<Ret> sum(F O::*m, Args&& ...args) {
+            std::unique_ptr<Ret> sum(F O::*m, Args&& ...args) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
                 auto &impl = this->get_impl<O>();
-                std::shared_ptr<Ret> res;
+                std::unique_ptr<Ret> res;
                 std::stringstream ss;
                 ss << "SELECT " << static_cast<std::string>(sqlite_orm::sum(0)) << "(";
                 auto columnName = this->string_from_expression(m);
@@ -8766,9 +8770,9 @@ namespace sqlite_orm {
                     auto rc = sqlite3_exec(connection->get_db(),
                                            query.c_str(),
                                            [](void *data, int argc, char **argv, char **)->int{
-                                               auto &res = *(std::shared_ptr<Ret>*)data;
+                                               auto &res = *(std::unique_ptr<Ret>*)data;
                                                if(argc){
-                                                   res = std::make_shared<Ret>(row_extractor<Ret>().extract(argv[0]));
+                                                   res = std::make_unique<Ret>(row_extractor<Ret>().extract(argv[0]));
                                                }
                                                return 0;
                                            }, &res, nullptr);
@@ -8837,8 +8841,7 @@ namespace sqlite_orm {
             template<
             class T,
             class ...Args,
-            class R = typename column_result_t<self, T>::type/*,
-            typename std::enable_if<!is_base_of_template<T, compound_operator>::value>::type * = nullptr*/>
+            class R = typename column_result_t<self, T>::type>
             std::vector<R> select(T m, Args ...args) {
                 static_assert(!is_base_of_template<T, compound_operator>::value || std::tuple_size<std::tuple<Args...>>::value == 0,
                               "Cannot use args with a compound operator");
@@ -8868,37 +8871,6 @@ namespace sqlite_orm {
                 }
             }
             
-            /*template<
-            class T,
-            class R = typename column_result_t<self, T>::type,
-            typename std::enable_if<is_base_of_template<T, compound_operator>::value>::type * = nullptr>
-            std::vector<R> select(T op) {
-                using select_type = select_t<T>;
-                auto query = this->string_from_expression(select_type{std::move(op)});
-                auto connection = this->get_or_create_connection();
-                sqlite3_stmt *stmt;
-                if (sqlite3_prepare_v2(connection->get_db(), query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
-                    statement_finalizer finalizer{stmt};
-                    std::vector<R> res;
-                    int stepRes;
-                    do{
-                        stepRes = sqlite3_step(stmt);
-                        switch(stepRes){
-                            case SQLITE_ROW:{
-                                res.push_back(row_extractor<R>().extract(stmt, 0));
-                            }break;
-                            case SQLITE_DONE: break;
-                            default:{
-                                throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
-                            }
-                        }
-                    }while(stepRes != SQLITE_DONE);
-                    return res;
-                }else{
-                    throw std::system_error(std::error_code(sqlite3_errcode(connection->get_db()), get_sqlite_error_category()));
-                }
-            }*/
-            
             /**
              *  Returns a string representation of object of a class mapped to the storage.
              *  Type of string has json-like style.
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 3a05fa22b..bffa07f42 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1062,8 +1062,8 @@ void testForeignKey() {
 
     struct Visit {
         int id;
-        std::shared_ptr<int> location;
-        std::shared_ptr<int> user;
+        std::unique_ptr<int> location;
+        std::unique_ptr<int> user;
         int visited_at;
         uint8_t mark;
     };
@@ -1241,8 +1241,8 @@ void testTypeParsing() {
     assert(type_is_nullable<long double>::value == false);
     assert(type_is_nullable<long double>::value == false);
     assert(type_is_nullable<std::string>::value == false);
-    assert(type_is_nullable<std::shared_ptr<int>>::value == true);
-    assert(type_is_nullable<std::shared_ptr<std::string>>::value == true);
+    assert(type_is_nullable<std::unique_ptr<int>>::value == true);
+    assert(type_is_nullable<std::unique_ptr<std::string>>::value == true);
     assert(type_is_nullable<std::unique_ptr<int>>::value == true);
     assert(type_is_nullable<std::unique_ptr<std::string>>::value == true);
 
@@ -1262,8 +1262,8 @@ void testSyncSchema() {
     struct UserBefore {
         int id;
         std::string name;
-        std::shared_ptr<int> categoryId;
-        std::shared_ptr<std::string> surname;
+        std::unique_ptr<int> categoryId;
+        std::unique_ptr<std::string> surname;
     };
 
     //  this is an new version of user..
@@ -1296,15 +1296,14 @@ void testSyncSchema() {
     storage.remove_all<UserBefore>();
 
     //  create c++ objects to insert into table..
-    std::vector<UserBefore> usersToInsert {
-        { -1, "Michael", nullptr, std::make_shared<std::string>("Scofield") },
-        { -1, "Lincoln", std::make_shared<int>(4), std::make_shared<std::string>("Burrows") },
-        { -1, "Sucre", nullptr, nullptr },
-        { -1, "Sara", std::make_shared<int>(996), std::make_shared<std::string>("Tancredi") },
-        { -1, "John", std::make_shared<int>(100500), std::make_shared<std::string>("Abruzzi") },
-        { -1, "Brad", std::make_shared<int>(65), nullptr },
-        { -1, "Paul", std::make_shared<int>(65), nullptr },
-    };
+    std::vector<UserBefore> usersToInsert;
+    usersToInsert.push_back({-1, "Michael", nullptr, std::make_unique<std::string>("Scofield")});
+    usersToInsert.push_back({-1, "Lincoln", std::make_unique<int>(4), std::make_unique<std::string>("Burrows")});
+    usersToInsert.push_back({-1, "Sucre", nullptr, nullptr});
+    usersToInsert.push_back({-1, "Sara", std::make_unique<int>(996), std::make_unique<std::string>("Tancredi")});
+    usersToInsert.push_back({-1, "John", std::make_unique<int>(100500), std::make_unique<std::string>("Abruzzi")});
+    usersToInsert.push_back({-1, "Brad", std::make_unique<int>(65), nullptr});
+    usersToInsert.push_back({-1, "Paul", std::make_unique<int>(65), nullptr});
 
     for(auto &user : usersToInsert) {
         auto insertedId = storage.insert(user);

From b782f0cb313af4e75bf1596885464e0fdf7816a4 Mon Sep 17 00:00:00 2001
From: Matt Kline <matthew.kline@flukenetworks.com>
Date: Wed, 13 Mar 2019 11:17:26 -0700
Subject: [PATCH 43/63] Fix iterator_t: Restore sqlite3_stmt double ptr

The previous patch didn't catch why the sqlite3_stmt was a pointer
inside a shared_ptr. Restore that (to fix the resulting segfault)
and add an explanation.
---
 dev/storage.h                   | 24 +++++++++++++++---------
 include/sqlite_orm/sqlite_orm.h | 24 +++++++++++++++---------
 2 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/dev/storage.h b/dev/storage.h
index 0a411fcb0..738a51c56 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -77,7 +77,11 @@ namespace sqlite_orm {
                 
                 struct iterator_t {
                 protected:
-                    sqlite3_stmt *stmt;
+                    // The double-indirection is so that copies of the iterator
+                    // share the same sqlite3_stmt from a sqlite3_prepare_v2()
+                    // call. When one finishes iterating it, the pointer
+                    // inside the shared_ptr is nulled out in all copies.
+                    std::shared_ptr<sqlite3_stmt *> stmt;
                     view_t<T, Args...> &view;
                     // shared_ptr is used over unique_ptr here
                     // so that the iterator can be copyable.
@@ -90,7 +94,7 @@ namespace sqlite_orm {
                         auto index = 0;
                         impl.table.for_each_column([&index, &temp, this] (auto &c) {
                             using field_type = typename std::decay<decltype(c)>::type::field_type;
-                            auto value = row_extractor<field_type>().extract(this->stmt, index++);
+                            auto value = row_extractor<field_type>().extract(*this->stmt, index++);
                             if(c.member_pointer){
                                 auto member_pointer = c.member_pointer;
                                 (*temp).*member_pointer = std::move(value);
@@ -107,7 +111,7 @@ namespace sqlite_orm {
                     using reference = value_type &;
                     using iterator_category = std::input_iterator_tag;
                     
-                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(stmt_), view(view_) {
+                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(std::make_shared<sqlite3_stmt *>(stmt_)), view(view_) {
                         this->operator++();
                     }
                     
@@ -120,7 +124,9 @@ namespace sqlite_orm {
                     iterator_t& operator=(const iterator_t&) = default;
                     
                     ~iterator_t() {
-                        statement_finalizer f{this->stmt};
+                        if(this->stmt){
+                            statement_finalizer f{*this->stmt};
+                        }
                     }
                     
                     T& operator*() {
@@ -148,15 +154,15 @@ namespace sqlite_orm {
                     }
                     
                     void operator++() {
-                        if(this->stmt){
-                            auto ret = sqlite3_step(this->stmt);
+                        if(this->stmt && *this->stmt){
+                            auto ret = sqlite3_step(*this->stmt);
                             switch(ret){
                                 case SQLITE_ROW:
                                     this->current = nullptr;
                                     break;
                                 case SQLITE_DONE:{
-                                    statement_finalizer f{this->stmt};
-                                    this->stmt = nullptr;
+                                    statement_finalizer f{*this->stmt};
+                                    *this->stmt = nullptr;
                                 }break;
                                 default:{
                                     throw std::system_error(std::error_code(sqlite3_errcode(this->view.connection->get_db()), get_sqlite_error_category()));
@@ -171,7 +177,7 @@ namespace sqlite_orm {
                     
                     bool operator==(const iterator_t &other) const {
                         if(this->stmt && other.stmt){
-                            return this->stmt == other.stmt;
+                            return *this->stmt == *other.stmt;
                         }else{
                             if(!this->stmt && !other.stmt){
                                 return true;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index ab7fd7ddb..862fad8ba 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -6537,7 +6537,11 @@ namespace sqlite_orm {
                 
                 struct iterator_t {
                 protected:
-                    sqlite3_stmt *stmt;
+                    // The double-indirection is so that copies of the iterator
+                    // share the same sqlite3_stmt from a sqlite3_prepare_v2()
+                    // call. When one finishes iterating it, the pointer
+                    // inside the shared_ptr is nulled out in all copies.
+                    std::shared_ptr<sqlite3_stmt *> stmt;
                     view_t<T, Args...> &view;
                     // shared_ptr is used over unique_ptr here
                     // so that the iterator can be copyable.
@@ -6550,7 +6554,7 @@ namespace sqlite_orm {
                         auto index = 0;
                         impl.table.for_each_column([&index, &temp, this] (auto &c) {
                             using field_type = typename std::decay<decltype(c)>::type::field_type;
-                            auto value = row_extractor<field_type>().extract(this->stmt, index++);
+                            auto value = row_extractor<field_type>().extract(*this->stmt, index++);
                             if(c.member_pointer){
                                 auto member_pointer = c.member_pointer;
                                 (*temp).*member_pointer = std::move(value);
@@ -6567,7 +6571,7 @@ namespace sqlite_orm {
                     using reference = value_type &;
                     using iterator_category = std::input_iterator_tag;
                     
-                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(stmt_), view(view_) {
+                    iterator_t(sqlite3_stmt * stmt_, view_t<T, Args...> &view_): stmt(std::make_shared<sqlite3_stmt *>(stmt_)), view(view_) {
                         this->operator++();
                     }
                     
@@ -6580,7 +6584,9 @@ namespace sqlite_orm {
                     iterator_t& operator=(const iterator_t&) = default;
                     
                     ~iterator_t() {
-                        statement_finalizer f{this->stmt};
+                        if(this->stmt){
+                            statement_finalizer f{*this->stmt};
+                        }
                     }
                     
                     T& operator*() {
@@ -6608,15 +6614,15 @@ namespace sqlite_orm {
                     }
                     
                     void operator++() {
-                        if(this->stmt){
-                            auto ret = sqlite3_step(this->stmt);
+                        if(this->stmt && *this->stmt){
+                            auto ret = sqlite3_step(*this->stmt);
                             switch(ret){
                                 case SQLITE_ROW:
                                     this->current = nullptr;
                                     break;
                                 case SQLITE_DONE:{
-                                    statement_finalizer f{this->stmt};
-                                    this->stmt = nullptr;
+                                    statement_finalizer f{*this->stmt};
+                                    *this->stmt = nullptr;
                                 }break;
                                 default:{
                                     throw std::system_error(std::error_code(sqlite3_errcode(this->view.connection->get_db()), get_sqlite_error_category()));
@@ -6631,7 +6637,7 @@ namespace sqlite_orm {
                     
                     bool operator==(const iterator_t &other) const {
                         if(this->stmt && other.stmt){
-                            return this->stmt == other.stmt;
+                            return *this->stmt == *other.stmt;
                         }else{
                             if(!this->stmt && !other.stmt){
                                 return true;

From 88fbab0729ef02ee3b1a582c4e052f8911a3630f Mon Sep 17 00:00:00 2001
From: Matt Kline <matthew.kline@flukenetworks.com>
Date: Wed, 27 Mar 2019 15:40:23 -0700
Subject: [PATCH 44/63] Make get_no_throw return shared_ptr again, add new
 get_pointer

This leaves a few user-facing functions such as `min()` and `max()`
returning `unique_ptr` instead of `shared_ptr`,
but because of how interoperable the two pointer types are,
I don't think this is a large problem.
Note that the relevant tests (like `testDifferentGettersAndSetters()`)
haven't had to change at all! Use seems to fall into one of two camps:

1. The result is used immediately, e.g.,
   `if (*storage0.sum(&User::id) > 42)` or stored in an `auto` variable,
   e.g., `auto sum = storage0.sum(&User::id);`.
   In both of these cases, type deduction will take care of everything.

2. The result is stored in a `shared_ptr`, e.g.,
   `shared_ptr<int> sum = storage0.sum(&User::id)`,
   but since you can construct a `shared_ptr` from a `unique_ptr&&`,
   the code continues to compile.

Users' code would only stop working if they stored the result in
an `auto` variable, then tried to assign it to a `shared_ptr`:

    auto sum  = storage0.sum(&User::id);
    shared_ptr<int> sum2 = sum; // compile-error

I can't imagine many people mixing paradigms like that.
---
 README.md                       |  6 +++---
 dev/storage.h                   | 22 ++++++++++++++++++++--
 examples/composite_key.cpp      |  2 +-
 examples/key_value.cpp          |  4 ++--
 include/sqlite_orm/sqlite_orm.h | 22 ++++++++++++++++++++--
 tests/tests.cpp                 |  2 +-
 6 files changed, 47 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index c48969e1c..ee64ccb86 100644
--- a/README.md
+++ b/README.md
@@ -121,10 +121,10 @@ try{
 }
 ```
 
-Probably you may not like throwing exceptions. Me too. Exception `std::system_error` is thrown because return type in `get` function is not nullable. You can use alternative version `get_no_throw` which returns `std::unique_ptr` and doesn't throw `not_found_exception` if nothing found - just returns `nullptr`.
+Probably you may not like throwing exceptions. Me too. Exception `std::system_error` is thrown because return type in `get` function is not nullable. You can use alternative version `get_pointer` which returns `std::unique_ptr` and doesn't throw `not_found_exception` if nothing found - just returns `nullptr`.
 
 ```c++
-if(auto user = storage.get_no_throw<User>(insertedId)){
+if(auto user = storage.get_pointer<User>(insertedId)){
     cout << "user = " << user->firstName << " " << user->lastName << endl;
 }else{
     cout << "no user with id " << insertedId << endl;
@@ -183,7 +183,7 @@ for(auto &user : storage.iterate<User>()) {
 
 `iterate` member function returns adapter object that has `begin` and `end` member functions returning iterators that fetch object on dereference operator call.
 
-CRUD functions `get`, `get_no_throw`, `remove`, `update` (not `insert`) work only if your type has a primary key column. If you try to `get` an object that is mapped to your storage but has no primary key column a `std::system_error` will be thrown cause `sqlite_orm` cannot detect an id. If you want to know how to perform a storage without primary key take a look at `date_time.cpp` example in `examples` folder.
+CRUD functions `get`, `get_pointer`, `remove`, `update` (not `insert`) work only if your type has a primary key column. If you try to `get` an object that is mapped to your storage but has no primary key column a `std::system_error` will be thrown cause `sqlite_orm` cannot detect an id. If you want to know how to perform a storage without primary key take a look at `date_time.cpp` example in `examples` folder.
 
 # Aggregate Functions
 
diff --git a/dev/storage.h b/dev/storage.h
index 738a51c56..a447ca6c3 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -2007,7 +2007,7 @@ namespace sqlite_orm {
              *  throws std::system_error in case of db error.
              */
             template<class O, class ...Ids>
-            std::unique_ptr<O> get_no_throw(Ids ...ids) {
+            std::unique_ptr<O> get_pointer(Ids ...ids) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
@@ -2075,7 +2075,25 @@ namespace sqlite_orm {
                     throw std::system_error(std::make_error_code(orm_error_code::table_has_no_primary_key_column));
                 }
             }
-            
+
+            /**
+             * A previous version of get_pointer() that returns a shared_ptr
+             * instead of a unique_ptr. New code should prefer get_pointer()
+             * unless the data needs to be shared.
+             *
+             * @note
+             * Most scenarios don't need shared ownership of data, so we should prefer
+             * unique_ptr when possible. It's more efficient, doesn't require atomic
+             * ops for a reference count (which can cause major slowdowns on
+             * weakly-ordered platforms like ARM), and can be easily promoted to a
+             * shared_ptr, exactly like we're doing here.
+             * (Conversely, you _can't_ go from shared back to unique.)
+             */
+            template<class O, class ...Ids>
+            std::shared_ptr<O> get_no_throw(Ids ...ids) {
+                return std::shared_ptr<O>(get_pointer<O>(std::forward<Ids>(ids)...));
+            }
+
             /**
              *  SELECT COUNT(*) with no conditions routine. https://www.sqlite.org/lang_aggfunc.html#count
              *  @return Number of O object in table.
diff --git a/examples/composite_key.cpp b/examples/composite_key.cpp
index 8b858149b..71b815435 100644
--- a/examples/composite_key.cpp
+++ b/examples/composite_key.cpp
@@ -46,7 +46,7 @@ int main() {
     });
     auto bebeRexha = storage.get<User>(1, "Bebe");
     cout << "bebeRexha = " << storage.dump(bebeRexha) << endl;
-    auto bebeRexhaMaybe = storage.get_no_throw<User>(1, "Bebe");
+    auto bebeRexhaMaybe = storage.get_pointer<User>(1, "Bebe");
     try{
         //  2 and 'Drake' values will be ignored cause they are primary keys
         storage.insert(User{ 2, "Drake", "Singer" });
diff --git a/examples/key_value.cpp b/examples/key_value.cpp
index a9643fb8b..821701d24 100644
--- a/examples/key_value.cpp
+++ b/examples/key_value.cpp
@@ -9,7 +9,7 @@
  object (KeyValue is a class mapped to the storage) with arguments and calls REPLACE. REPLACE (shorter version of INSERT OR REPLACE)
  removes row with a given primary key if it exists and inserts a given value in the table.
  After this there is a row in the `key_value` table with key and value passed into `setValue` function.
- `getValue` performs `get_no_throw` by id and returns its value or returns empty string if nothing obtained from db.
+ `getValue` performs `get_pointer` by id and returns its value or returns empty string if nothing obtained from db.
  ******/
 
 #include <sqlite_orm/sqlite_orm.h>
@@ -45,7 +45,7 @@ void setValue(const std::string &key, const std::string &value) {
 
 std::string getValue(const std::string &key) {
     using namespace sqlite_orm;
-    if(auto kv = getStorage().get_no_throw<KeyValue>(key)){
+    if(auto kv = getStorage().get_pointer<KeyValue>(key)){
         return kv->value;
     }else{
         return {};
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 862fad8ba..eeb6a1296 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -8467,7 +8467,7 @@ namespace sqlite_orm {
              *  throws std::system_error in case of db error.
              */
             template<class O, class ...Ids>
-            std::unique_ptr<O> get_no_throw(Ids ...ids) {
+            std::unique_ptr<O> get_pointer(Ids ...ids) {
                 this->assert_mapped_type<O>();
                 
                 auto connection = this->get_or_create_connection();
@@ -8535,7 +8535,25 @@ namespace sqlite_orm {
                     throw std::system_error(std::make_error_code(orm_error_code::table_has_no_primary_key_column));
                 }
             }
-            
+
+            /**
+             * A previous version of get_pointer() that returns a shared_ptr
+             * instead of a unique_ptr. New code should prefer get_pointer()
+             * unless the data needs to be shared.
+             *
+             * @note
+             * Most scenarios don't need shared ownership of data, so we should prefer
+             * unique_ptr when possible. It's more efficient, doesn't require atomic
+             * ops for a reference count (which can cause major slowdowns on
+             * weakly-ordered platforms like ARM), and can be easily promoted to a
+             * shared_ptr, exactly like we're doing here.
+             * (Conversely, you _can't_ go from shared back to unique.)
+             */
+            template<class O, class ...Ids>
+            std::shared_ptr<O> get_no_throw(Ids ...ids) {
+                return std::shared_ptr<O>(get_pointer<O>(std::forward<Ids>(ids)...));
+            }
+
             /**
              *  SELECT COUNT(*) with no conditions routine. https://www.sqlite.org/lang_aggfunc.html#count
              *  @return Number of O object in table.
diff --git a/tests/tests.cpp b/tests/tests.cpp
index bffa07f42..af9e4263a 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -1474,7 +1474,7 @@ void testSelect() {
     assert(firstRow->afterWord == "hey");
     assert(firstRow->occurances == 5);
 
-    auto secondRow = storage.get_no_throw<Word>(secondId);
+    auto secondRow = storage.get_pointer<Word>(secondId);
     assert(secondRow);
     assert(secondRow->currentWord == "corruption");
     assert(secondRow->beforeWord == "blood");

From 0d176b966eed68f0459437c099c11ff7a2d7e826 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Sat, 30 Mar 2019 17:54:30 +0430
Subject: [PATCH 45/63] Add cmake config module. (fixes #249)

---
 CMakeLists.txt                            | 35 +++++++++++++++++++++--
 build/cmake/DefineInstallationPaths.cmake | 32 +++++++++++++++++++++
 build/cmake/GenerateConfigModule.cmake    | 24 ++++++++++++++++
 build/cmake/SqliteOrmConfig.cmake.in      | 22 ++++++++++++++
 4 files changed, 111 insertions(+), 2 deletions(-)
 create mode 100644 build/cmake/DefineInstallationPaths.cmake
 create mode 100644 build/cmake/GenerateConfigModule.cmake
 create mode 100644 build/cmake/SqliteOrmConfig.cmake.in

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 060c14738..f54ba1f4e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,13 +2,33 @@ cmake_minimum_required (VERSION 3.2)
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-project(sqlite_orm)
+# PACKAGE_VERSION is used by cpack scripts currently
+# Both sqlite_orm_VERSION and PACKAGE_VERSION should be the same for now
+
+set(sqlite_orm_VERSION "1.3.0")
+set(PACKAGE_VERSION ${sqlite_orm_VERSION})
+
+project("sqlite_orm" VERSION ${PACKAGE_VERSION})
+
+message(STATUS "Configuring ${CMAKE_PROJECT_NAME} ${sqlite_orm_VERSION}")
+
+set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake")
+
+# Build time options are defined here
+include(DefineInstallationPaths)
+
+# Generate the SqliteOrmConfig.cmake module
+include(GenerateConfigModule)
+
+set(ProjectName "SqliteOrm")
 
 option(SqliteOrm_BuildTests "Build sqlite_orm unit tests" ON)
 
 set(SqliteOrm_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_library(sqlite_orm INTERFACE)
-target_include_directories(sqlite_orm INTERFACE include)
+target_include_directories(sqlite_orm INTERFACE
+	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+	$<INSTALL_INTERFACE:include>)
 
 # Tests
 include(CTest)
@@ -19,3 +39,14 @@ endif()
 
 add_subdirectory(examples)
 
+install(TARGETS sqlite_orm EXPORT "${ProjectName}Targets"
+	PUBLIC_HEADER DESTINATION "${INCLUDE_INSTALL_DIR}" COMPONENT Development)
+
+export(EXPORT "${ProjectName}Targets"
+	FILE "${CMAKE_CURRENT_BINARY_DIR}/${ProjectName}/${ProjectName}Targets.cmake"
+	NAMESPACE "sqlite_orm::")
+
+install(EXPORT "${ProjectName}Targets"
+	FILE "${ProjectName}Targets.cmake"
+	NAMESPACE "sqlite_orm::"
+	DESTINATION "${CMAKE_INSTALL_DIR}/sqlite_orm")
diff --git a/build/cmake/DefineInstallationPaths.cmake b/build/cmake/DefineInstallationPaths.cmake
new file mode 100644
index 000000000..0c824cc7a
--- /dev/null
+++ b/build/cmake/DefineInstallationPaths.cmake
@@ -0,0 +1,32 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+
+# Define the default install paths
+set(BIN_INSTALL_DIR "bin" CACHE PATH "The binary install dir (default: bin)")
+set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}" CACHE PATH "The library install dir (default: lib${LIB_SUFFIX})")
+set(INCLUDE_INSTALL_DIR "include" CACHE PATH "The library install dir (default: include)")
+set(CMAKE_INSTALL_DIR "lib/cmake" CACHE PATH "The subdirectory to install cmake config files (default: cmake)")
+set(PKGCONFIG_INSTALL_DIR "lib/pkgconfig" CACHE PATH "The subdirectory to install pkgconfig config files (default: lib/pkgconfig)")
+set(DOC_INSTALL_DIR "share/doc" CACHE PATH "The subdirectory to install documentation files (default: share/doc)")
+set(prefix "${CMAKE_INSTALL_PREFIX}")
+set(exec_prefix "${CMAKE_INSTALL_PREFIX}/bin")
+set(libdir "${CMAKE_INSTALL_PREFIX}/lib")
+set(includedir "${CMAKE_INSTALL_PREFIX}/include")
+set(cmakedir "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DIR}")
diff --git a/build/cmake/GenerateConfigModule.cmake b/build/cmake/GenerateConfigModule.cmake
new file mode 100644
index 000000000..3c5143d3e
--- /dev/null
+++ b/build/cmake/GenerateConfigModule.cmake
@@ -0,0 +1,24 @@
+include(CMakePackageConfigHelpers)
+
+set(PACKAGE_INCLUDE_INSTALL_DIR "${includedir}/sqlite_orm")
+set(PACKAGE_CMAKE_INSTALL_DIR "${cmakedir}/sqlite_orm")
+
+# In CYGWIN enviroment below commands does not work properly
+if (NOT CYGWIN)
+		configure_package_config_file("${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/SqliteOrmConfig.cmake.in"
+						"${CMAKE_CURRENT_BINARY_DIR}/SqliteOrmConfig.cmake"
+						INSTALL_DESTINATION "${CMAKE_INSTALL_DIR}/sqlite_orm"
+						PATH_VARS
+						PACKAGE_INCLUDE_INSTALL_DIR
+						PACKAGE_CMAKE_INSTALL_DIR
+						)
+
+		write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/SqliteOrmConfigVersion.cmake"
+						VERSION ${sqlite_orm_VERSION}
+						COMPATIBILITY SameMajorVersion
+						)
+
+		install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SqliteOrmConfig.cmake"
+						"${CMAKE_CURRENT_BINARY_DIR}/SqliteOrmConfigVersion.cmake"
+						DESTINATION "${CMAKE_INSTALL_DIR}/sqlite_orm")
+endif()
\ No newline at end of file
diff --git a/build/cmake/SqliteOrmConfig.cmake.in b/build/cmake/SqliteOrmConfig.cmake.in
new file mode 100644
index 000000000..a6b6f20b9
--- /dev/null
+++ b/build/cmake/SqliteOrmConfig.cmake.in
@@ -0,0 +1,22 @@
+set(SQLITE_ORM_VERSION ${sqlite_orm_VERSION})
+
+@PACKAGE_INIT@
+
+set_and_check(SQLITE_ORM_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
+set_and_check(SQLITE_ORM_CMAKE_DIR "@PACKAGE_CMAKE_INSTALL_DIR@")
+
+if (NOT TARGET sqlite_orm::sqlite_orm)
+  include("${SQLITE_ORM_CMAKE_DIR}/SqliteOrmTargets.cmake")
+endif()
+
+set(SQLITE_ORM_LIBRARIES sqlite_orm::sqlite_orm)
+
+if ("${SQLITE_ORM_LIBRARIES}" STREQUAL "")
+	message(FATAL_ERROR "sqlite_orm libraries were not found")
+endif()
+
+if (NOT SqliteOrm_FIND_QUIETLY)
+  message(STATUS "Found sqlite_orm: ${PACKAGE_PREFIX_DIR}")
+endif()
+
+check_required_components(SqliteOrm)

From 70614c3cffeaf2b57093d82774da5e429b9ff286 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Sat, 30 Mar 2019 19:35:56 +0430
Subject: [PATCH 46/63] Remove unnecessary copyright comment. (see #249)

---
 build/cmake/DefineInstallationPaths.cmake | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/build/cmake/DefineInstallationPaths.cmake b/build/cmake/DefineInstallationPaths.cmake
index 0c824cc7a..3406e68e4 100644
--- a/build/cmake/DefineInstallationPaths.cmake
+++ b/build/cmake/DefineInstallationPaths.cmake
@@ -1,23 +1,3 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements. See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership. The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
-
-
 # Define the default install paths
 set(BIN_INSTALL_DIR "bin" CACHE PATH "The binary install dir (default: bin)")
 set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}" CACHE PATH "The library install dir (default: lib${LIB_SUFFIX})")

From f56ae808986c88005169596083fb5e1f1c75d5f1 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Sun, 31 Mar 2019 02:14:16 +0430
Subject: [PATCH 47/63] Resolved problem in compiling with third_party sqlite.
 (fixes #255)

---
 tests/third_party/sqlite/CMakeLists.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/third_party/sqlite/CMakeLists.txt b/tests/third_party/sqlite/CMakeLists.txt
index cd30217e0..396695a56 100644
--- a/tests/third_party/sqlite/CMakeLists.txt
+++ b/tests/third_party/sqlite/CMakeLists.txt
@@ -10,10 +10,12 @@ add_custom_command(
     ${CMAKE_COMMAND} -DSQLITE3_ARCH_NAME=${SQLITE3_ARCH_NAME} -DSQLITE3_LINK=${SQLITE3_LINK} -DSQLITE3_ARCH_SHA1=${SQLITE3_ARCH_SHA1} -P "${CMAKE_CURRENT_SOURCE_DIR}/DownloadSqlite3.cmake")
 
 add_custom_command(
-    OUTPUT sqlite-amalgamation-3210000 sqlite-amalgamation-3210000/sqlite3.c
+    OUTPUT sqlite-amalgamation-3210000 sqlite-amalgamation-3210000/sqlite3.c sqlite-amalgamation-3210000/sqlite3.h
     DEPENDS ${SQLITE3_ARCH_NAME}
     COMMAND
     ${CMAKE_COMMAND} -E tar xfz ${SQLITE3_ARCH_NAME})
 
 add_library(sqlite3 sqlite-amalgamation-3210000/sqlite3.c)
+
+target_include_directories(sqlite3 INTERFACE "${CMAKE_CURRENT_BINARY_DIR}/sqlite-amalgamation-3210000")
 target_link_libraries(sqlite3 dl pthread)

From 7053ff810ba6abb5a8447b327ff1684ff10ff28f Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Mon, 1 Apr 2019 18:15:31 +0430
Subject: [PATCH 48/63] Add header file to install path. (see #249)

---
 CMakeLists.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f54ba1f4e..556ecf14d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,6 +26,11 @@ option(SqliteOrm_BuildTests "Build sqlite_orm unit tests" ON)
 
 set(SqliteOrm_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 add_library(sqlite_orm INTERFACE)
+
+target_sources(sqlite_orm INTERFACE
+	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include/sqlite_orm/sqlite_orm.h>
+	$<INSTALL_INTERFACE:include/sqlite_orm/sqlite_orm.h>)
+
 target_include_directories(sqlite_orm INTERFACE
 	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 	$<INSTALL_INTERFACE:include>)
@@ -40,8 +45,12 @@ endif()
 add_subdirectory(examples)
 
 install(TARGETS sqlite_orm EXPORT "${ProjectName}Targets"
+	INCLUDES DESTINATION "${INCLUDE_INSTALL_DIR}" COMPONENT Development
 	PUBLIC_HEADER DESTINATION "${INCLUDE_INSTALL_DIR}" COMPONENT Development)
 
+install(FILES "include/sqlite_orm/sqlite_orm.h"
+	DESTINATION "${INCLUDE_INSTALL_DIR}" COMPONENT Development)
+
 export(EXPORT "${ProjectName}Targets"
 	FILE "${CMAKE_CURRENT_BINARY_DIR}/${ProjectName}/${ProjectName}Targets.cmake"
 	NAMESPACE "sqlite_orm::")

From 99b6070542897fdb5fd8cc2a6e76a7c85174d981 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Mon, 1 Apr 2019 19:57:06 +0430
Subject: [PATCH 49/63] Add appveyor.yml configuration. (fixes #258)

---
 appveyor.yml | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100755 appveyor.yml

diff --git a/appveyor.yml b/appveyor.yml
new file mode 100755
index 000000000..e2bdcf4ed
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,44 @@
+# Copyright (c) 2012-2019 Sebastien Rombauts (sebastien.rombauts@gmail.com)
+
+# build format
+version: "{build}"
+
+# scripts that run after cloning repository
+install:
+  - git submodule update --init --recursive
+ 
+image:
+  - Visual Studio 2017
+  - Visual Studio 2015
+  - Visual Studio 2013
+  
+# configurations to add to build matrix
+# TODO: MinGW Makefiles and MSYS Makefiles
+configuration:
+  - Debug
+  - Release
+
+environment:
+  matrix:
+  - arch: Win32
+  - arch: Win64
+
+init:
+  - echo %APPVEYOR_BUILD_WORKER_IMAGE% - %configuration% - %arch%
+  - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2017" (set vs=Visual Studio 15 2017)
+  - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2015" (set vs=Visual Studio 14 2015)
+  - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2013" (set vs=Visual Studio 12 2013)
+  - if "%arch%"=="Win64" (set generator="%vs% Win64")
+  - if "%arch%"=="Win32" (set generator="%vs%")
+  - echo %generator%
+ 
+# scripts to run before build
+before_build:
+  - mkdir compile
+  - cd compile
+  - cmake -DSqliteOrm_BuildTests=ON .. -G %generator%
+
+# build examples, and run tests (ie make & make test)
+build_script:
+  - cmake --build . --config %configuration%
+  - ctest --output-on-failure

From 205393d03af1af118c39a37b4837c395ae94f815 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Mon, 1 Apr 2019 21:42:00 +0430
Subject: [PATCH 50/63] Make windows friendly. (see ##258)

---
 examples/collate.cpp                    | 5 +++--
 examples/composite_key.cpp              | 6 ++++--
 tests/third_party/sqlite/CMakeLists.txt | 5 ++++-
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/examples/collate.cpp b/examples/collate.cpp
index ba5a5cf02..12d1df6ec 100644
--- a/examples/collate.cpp
+++ b/examples/collate.cpp
@@ -1,9 +1,10 @@
+#include <ctime>
 
-#include <sqlite_orm/sqlite_orm.h>
 #include <string>
-#include <sys/time.h>
 #include <iostream>
 
+#include <sqlite_orm/sqlite_orm.h>
+
 using std::cout;
 using std::endl;
 
diff --git a/examples/composite_key.cpp b/examples/composite_key.cpp
index 71b815435..07c7ede9d 100644
--- a/examples/composite_key.cpp
+++ b/examples/composite_key.cpp
@@ -2,11 +2,13 @@
  *  This example shows you how to create a storage with a tablw with a composite primary key
  *  and another table woth foreign key to first table's primary compisite key.
  */
-#include <stdio.h>
+#include <cstdio>
+#include <ctime>
+
 #include <string>
 #include <iostream>
+
 #include <sqlite_orm/sqlite_orm.h>
-#include <sys/time.h>
 
 using std::cout;
 using std::endl;
diff --git a/tests/third_party/sqlite/CMakeLists.txt b/tests/third_party/sqlite/CMakeLists.txt
index 396695a56..d990826b8 100644
--- a/tests/third_party/sqlite/CMakeLists.txt
+++ b/tests/third_party/sqlite/CMakeLists.txt
@@ -17,5 +17,8 @@ add_custom_command(
 
 add_library(sqlite3 sqlite-amalgamation-3210000/sqlite3.c)
 
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
 target_include_directories(sqlite3 INTERFACE "${CMAKE_CURRENT_BINARY_DIR}/sqlite-amalgamation-3210000")
-target_link_libraries(sqlite3 dl pthread)
+target_link_libraries(sqlite3 PRIVATE ${CMAKE_DL_LIBS} Threads::Threads)

From 22f94da186900544d4b447e64a61e64ae5e871c4 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 01:50:23 +0430
Subject: [PATCH 51/63] Resolved is_base_of_template bug for MSVC. (see #258)

---
 dev/select_constraints.h        | 24 ++++++++++++++++++++++--
 include/sqlite_orm/sqlite_orm.h | 24 ++++++++++++++++++++++--
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/dev/select_constraints.h b/dev/select_constraints.h
index cd0397dee..cbf6c5ba5 100644
--- a/dev/select_constraints.h
+++ b/dev/select_constraints.h
@@ -5,7 +5,26 @@
 namespace sqlite_orm {
     
     namespace internal {
-        
+
+/*
+ * This is because of bug in MSVC, for more information, please visit
+ * https://stackoverflow.com/questions/34672441/stdis-base-of-for-template-classes/34672753#34672753
+ */
+#if defined(_MSC_VER)
+       template <template <typename...> class Base, typename Derived>
+       struct is_base_of_template_impl {
+               template<typename... Ts>
+               static constexpr std::true_type test(const Base<Ts...>*);
+
+               static constexpr std::false_type test(...);
+
+               using type = decltype(test(std::declval<Derived*>()));
+       };
+
+       template <typename Derived, template <typename...> class Base>
+       using is_base_of_template = typename is_base_of_template_impl<Base, Derived>::type;
+
+#else
         template <template <typename...> class C, typename...Ts>
         std::true_type is_base_of_template_impl(const C<Ts...>*);
         
@@ -14,7 +33,8 @@ namespace sqlite_orm {
         
         template <typename T, template <typename...> class C>
         using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
-        
+
+#endif
         /**
          *  DISCTINCT generic container.
          */
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 06167e6b6..597b2bb99 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -3446,7 +3446,26 @@ namespace sqlite_orm {
 namespace sqlite_orm {
     
     namespace internal {
-        
+
+/*
+ * This is because of bug in MSVC, for more information, please visit
+ * https://stackoverflow.com/questions/34672441/stdis-base-of-for-template-classes/34672753#34672753
+ */
+#if defined(_MSC_VER)
+       template <template <typename...> class Base, typename Derived>
+       struct is_base_of_template_impl {
+               template<typename... Ts>
+               static constexpr std::true_type test(const Base<Ts...>*);
+
+               static constexpr std::false_type test(...);
+
+               using type = decltype(test(std::declval<Derived*>()));
+       };
+
+       template <typename Derived, template <typename...> class Base>
+       using is_base_of_template = typename is_base_of_template_impl<Base, Derived>::type;
+
+#else
         template <template <typename...> class C, typename...Ts>
         std::true_type is_base_of_template_impl(const C<Ts...>*);
         
@@ -3455,7 +3474,8 @@ namespace sqlite_orm {
         
         template <typename T, template <typename...> class C>
         using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*>()));
-        
+
+#endif
         /**
          *  DISCTINCT generic container.
          */

From d842d278fd7bc86249615cb219eba735edf6f4fc Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 02:22:34 +0430
Subject: [PATCH 52/63] Add ctest configuration. (see #258)

---
 appveyor.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index e2bdcf4ed..e0711163b 100755
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -41,4 +41,4 @@ before_build:
 # build examples, and run tests (ie make & make test)
 build_script:
   - cmake --build . --config %configuration%
-  - ctest --output-on-failure
+  - ctest --output-on-failure --build-config %configuration%

From 046946531e236942fa267c2fee1b09460e3a9e3a Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 02:38:26 +0430
Subject: [PATCH 53/63] Remove unsupported Visual Sutdio versions. (see #258)

---
 appveyor.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/appveyor.yml b/appveyor.yml
index e0711163b..216bf573c 100755
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -8,9 +8,8 @@ install:
   - git submodule update --init --recursive
  
 image:
+  - Visual Studio 2019 Preview
   - Visual Studio 2017
-  - Visual Studio 2015
-  - Visual Studio 2013
   
 # configurations to add to build matrix
 # TODO: MinGW Makefiles and MSYS Makefiles
@@ -25,6 +24,7 @@ environment:
 
 init:
   - echo %APPVEYOR_BUILD_WORKER_IMAGE% - %configuration% - %arch%
+  - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2019 Preview" (set vs=Visual Studio 15 2019 Preview)
   - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2017" (set vs=Visual Studio 15 2017)
   - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2015" (set vs=Visual Studio 14 2015)
   - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2013" (set vs=Visual Studio 12 2013)

From 94a79b8b51591a1bce527a5710c22a8782d31ebe Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 02:55:14 +0430
Subject: [PATCH 54/63] Add bigobj flag to pass x64 debug mode in windows. (see
 #258)

---
 CMakeLists.txt | 4 ++++
 appveyor.yml   | 2 --
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f54ba1f4e..f7b27e5b9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,6 +30,10 @@ target_include_directories(sqlite_orm INTERFACE
 	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 	$<INSTALL_INTERFACE:include>)
 
+if (MSVC AND "${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND CMAKE_BUILD_TYPE EQUAL "Debug")
+    add_compile_options(/bigobj)
+endif()
+
 # Tests
 include(CTest)
 if(SqliteOrm_BuildTests AND BUILD_TESTING)
diff --git a/appveyor.yml b/appveyor.yml
index 216bf573c..9a6fcc924 100755
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -8,7 +8,6 @@ install:
   - git submodule update --init --recursive
  
 image:
-  - Visual Studio 2019 Preview
   - Visual Studio 2017
   
 # configurations to add to build matrix
@@ -24,7 +23,6 @@ environment:
 
 init:
   - echo %APPVEYOR_BUILD_WORKER_IMAGE% - %configuration% - %arch%
-  - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2019 Preview" (set vs=Visual Studio 15 2019 Preview)
   - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2017" (set vs=Visual Studio 15 2017)
   - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2015" (set vs=Visual Studio 14 2015)
   - if "%APPVEYOR_BUILD_WORKER_IMAGE%"=="Visual Studio 2013" (set vs=Visual Studio 12 2013)

From 558f0a889746c7c7f88d479a95cee5bba551a263 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 03:07:40 +0430
Subject: [PATCH 55/63] Remove runtime checks compiler for MSVC to resolve hang
 in appveyor. (see #258)

---
 CMakeLists.txt | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f7b27e5b9..ecfb7c42d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,8 +30,11 @@ target_include_directories(sqlite_orm INTERFACE
 	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 	$<INSTALL_INTERFACE:include>)
 
-if (MSVC AND "${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND CMAKE_BUILD_TYPE EQUAL "Debug")
-    add_compile_options(/bigobj)
+if (MSVC)
+	STRING (REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")	
+	if ("${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND CMAKE_BUILD_TYPE EQUAL "Debug")
+    	add_compile_options(/bigobj)
+	endif()
 endif()
 
 # Tests

From cb4dcd68e37db5fdf18d17d509d0efa56e2ca0d6 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 03:23:46 +0430
Subject: [PATCH 56/63] Remove runtime checks compiler for MSVC to resolve hang
 in appveyor in Debug mode. (see #258)

---
 CMakeLists.txt | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ecfb7c42d..2223a8df5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,7 +31,10 @@ target_include_directories(sqlite_orm INTERFACE
 	$<INSTALL_INTERFACE:include>)
 
 if (MSVC)
-	STRING (REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")	
+	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")	
+	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")	
+	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")	
+
 	if ("${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND CMAKE_BUILD_TYPE EQUAL "Debug")
     	add_compile_options(/bigobj)
 	endif()

From ee705641f70ff60bd484ea463bd0846d7b6061a7 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 05:40:27 +0430
Subject: [PATCH 57/63] Add ucm module to cmake. (see #258)

---
 CMakeLists.txt        |   9 +-
 build/cmake/ucm.cmake | 663 ++++++++++++++++++++++++++++++++++++++++++
 tests/CMakeLists.txt  |   2 +
 3 files changed, 673 insertions(+), 1 deletion(-)
 create mode 100755 build/cmake/ucm.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2223a8df5..ce3bd1864 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,16 +30,23 @@ target_include_directories(sqlite_orm INTERFACE
 	$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 	$<INSTALL_INTERFACE:include>)
 
+include(ucm)
+
 if (MSVC)
 	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")	
 	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")	
 	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")	
+	add_compile_options(/EHsc)
 
-	if ("${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND CMAKE_BUILD_TYPE EQUAL "Debug")
+	if ("${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND ((CMAKE_BUILD_TYPE EQUAL "Debug") OR (CMAKE_BUILD_TYPE EQUAL "" )))
+		message(STATUS "Add /bigobj flag to compiler")
     	add_compile_options(/bigobj)
 	endif()
 endif()
 
+ucm_print_flags()
+message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
+
 # Tests
 include(CTest)
 if(SqliteOrm_BuildTests AND BUILD_TESTING)
diff --git a/build/cmake/ucm.cmake b/build/cmake/ucm.cmake
new file mode 100755
index 000000000..9f44fbd52
--- /dev/null
+++ b/build/cmake/ucm.cmake
@@ -0,0 +1,663 @@
+#
+# ucm.cmake - useful cmake macros
+#
+# Copyright (c) 2016 Viktor Kirilov
+#
+# Distributed under the MIT Software License
+# See accompanying file LICENSE.txt or copy at
+# https://opensource.org/licenses/MIT
+#
+# The documentation can be found at the library's page:
+# https://github.com/onqtam/ucm
+
+cmake_minimum_required(VERSION 2.8.12)
+
+include(CMakeParseArguments)
+
+# optionally include cotire - the git submodule might not be inited (or the user might have already included it)
+if(NOT COMMAND cotire)
+    include(${CMAKE_CURRENT_LIST_DIR}/../cotire/CMake/cotire.cmake OPTIONAL)
+endif()
+
+if(COMMAND cotire AND "1.7.9" VERSION_LESS "${COTIRE_CMAKE_MODULE_VERSION}")
+    set(ucm_with_cotire 1)
+else()
+    set(ucm_with_cotire 0)
+endif()
+
+option(UCM_UNITY_BUILD          "Enable unity build for targets registered with the ucm_add_target() macro"                     OFF)
+option(UCM_NO_COTIRE_FOLDER     "Do not use a cotire folder in the solution explorer for all unity and cotire related targets"  ON)
+
+# ucm_add_flags
+# Adds compiler flags to CMAKE_<LANG>_FLAGS or to a specific config
+macro(ucm_add_flags)
+    cmake_parse_arguments(ARG "C;CXX;CLEAR_OLD" "" "CONFIG" ${ARGN})
+
+    if(NOT ARG_CONFIG)
+        set(ARG_CONFIG " ")
+    endif()
+
+    foreach(CONFIG ${ARG_CONFIG})
+        # determine to which flags to add
+        if(NOT ${CONFIG} STREQUAL " ")
+            string(TOUPPER ${CONFIG} CONFIG)
+            set(CXX_FLAGS CMAKE_CXX_FLAGS_${CONFIG})
+            set(C_FLAGS CMAKE_C_FLAGS_${CONFIG})
+        else()
+            set(CXX_FLAGS CMAKE_CXX_FLAGS)
+            set(C_FLAGS CMAKE_C_FLAGS)
+        endif()
+
+        # clear the old flags
+        if(${ARG_CLEAR_OLD})
+            if("${ARG_CXX}" OR NOT "${ARG_C}")
+                set(${CXX_FLAGS} "")
+            endif()
+            if("${ARG_C}" OR NOT "${ARG_CXX}")
+                set(${C_FLAGS} "")
+            endif()
+        endif()
+
+        # add all the passed flags
+        foreach(flag ${ARG_UNPARSED_ARGUMENTS})
+            if("${ARG_CXX}" OR NOT "${ARG_C}")
+                set(${CXX_FLAGS} "${${CXX_FLAGS}} ${flag}")
+            endif()
+            if("${ARG_C}" OR NOT "${ARG_CXX}")
+                set(${C_FLAGS} "${${C_FLAGS}} ${flag}")
+            endif()
+        endforeach()
+    endforeach()
+
+endmacro()
+
+# ucm_set_flags
+# Sets the CMAKE_<LANG>_FLAGS compiler flags or for a specific config
+macro(ucm_set_flags)
+    ucm_add_flags(CLEAR_OLD ${ARGN})
+endmacro()
+
+# ucm_add_linker_flags
+# Adds linker flags to CMAKE_<TYPE>_LINKER_FLAGS or to a specific config
+macro(ucm_add_linker_flags)
+    cmake_parse_arguments(ARG "CLEAR_OLD;EXE;MODULE;SHARED;STATIC" "" "CONFIG" ${ARGN})
+
+    if(NOT ARG_CONFIG)
+        set(ARG_CONFIG " ")
+    endif()
+
+    foreach(CONFIG ${ARG_CONFIG})
+        string(TOUPPER "${CONFIG}" CONFIG)
+    
+        if(NOT ${ARG_EXE} AND NOT ${ARG_MODULE} AND NOT ${ARG_SHARED} AND NOT ${ARG_STATIC})
+            set(ARG_EXE 1)
+            set(ARG_MODULE 1)
+            set(ARG_SHARED 1)
+            set(ARG_STATIC 1)
+        endif()
+    
+        set(flags_configs "")
+        if(${ARG_EXE})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_EXE_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_EXE_LINKER_FLAGS)
+            endif()
+        endif()
+        if(${ARG_MODULE})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_MODULE_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_MODULE_LINKER_FLAGS)
+            endif()
+        endif()
+        if(${ARG_SHARED})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_SHARED_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_SHARED_LINKER_FLAGS)
+            endif()
+        endif()
+        if(${ARG_STATIC})
+            if(NOT "${CONFIG}" STREQUAL " ")
+                list(APPEND flags_configs CMAKE_STATIC_LINKER_FLAGS_${CONFIG})
+            else()
+                list(APPEND flags_configs CMAKE_STATIC_LINKER_FLAGS)
+            endif()
+        endif()
+    
+        # clear the old flags
+        if(${ARG_CLEAR_OLD})
+            foreach(flags ${flags_configs})
+                set(${flags} "")
+            endforeach()
+        endif()
+
+        # add all the passed flags
+        foreach(flag ${ARG_UNPARSED_ARGUMENTS})
+            foreach(flags ${flags_configs})
+                set(${flags} "${${flags}} ${flag}")
+            endforeach()
+        endforeach()
+    endforeach()
+endmacro()
+
+# ucm_set_linker_flags
+# Sets the CMAKE_<TYPE>_LINKER_FLAGS linker flags or for a specific config
+macro(ucm_set_linker_flags)
+    ucm_add_linker_flags(CLEAR_OLD ${ARGN})
+endmacro()
+
+# ucm_gather_flags
+# Gathers all lists of flags for printing or manipulation
+macro(ucm_gather_flags with_linker result)
+    set(${result} "")
+    # add the main flags without a config
+    list(APPEND ${result} CMAKE_C_FLAGS)
+    list(APPEND ${result} CMAKE_CXX_FLAGS)
+    if(${with_linker})
+        list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS)
+        list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS)
+        list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS)
+        list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS)
+    endif()
+    
+    if("${CMAKE_CONFIGURATION_TYPES}" STREQUAL "" AND NOT "${CMAKE_BUILD_TYPE}" STREQUAL "")
+        # handle single config generators - like makefiles/ninja - when CMAKE_BUILD_TYPE is set
+        string(TOUPPER ${CMAKE_BUILD_TYPE} config)
+        list(APPEND ${result} CMAKE_C_FLAGS_${config})
+        list(APPEND ${result} CMAKE_CXX_FLAGS_${config})
+        if(${with_linker})
+            list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS_${config})
+            list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS_${config})
+            list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS_${config})
+            list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS_${config})
+        endif()
+    else()
+        # handle multi config generators (like msvc, xcode)
+        foreach(config ${CMAKE_CONFIGURATION_TYPES})
+            string(TOUPPER ${config} config)
+            list(APPEND ${result} CMAKE_C_FLAGS_${config})
+            list(APPEND ${result} CMAKE_CXX_FLAGS_${config})
+            if(${with_linker})
+                list(APPEND ${result} CMAKE_EXE_LINKER_FLAGS_${config})
+                list(APPEND ${result} CMAKE_MODULE_LINKER_FLAGS_${config})
+                list(APPEND ${result} CMAKE_SHARED_LINKER_FLAGS_${config})
+                list(APPEND ${result} CMAKE_STATIC_LINKER_FLAGS_${config})
+            endif()
+        endforeach()
+    endif()
+endmacro()
+
+# ucm_set_runtime
+# Sets the runtime (static/dynamic) for msvc/gcc
+macro(ucm_set_runtime)
+    cmake_parse_arguments(ARG "STATIC;DYNAMIC" "" "" ${ARGN})
+
+    if(ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+    
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" STREQUAL "")
+        message(AUTHOR_WARNING "ucm_set_runtime() does not support clang yet!")
+    endif()
+    
+    ucm_gather_flags(0 flags_configs)
+    
+    # add/replace the flags
+    # note that if the user has messed with the flags directly this function might fail
+    # - for example if with MSVC and the user has removed the flags - here we just switch/replace them
+    if("${ARG_STATIC}")
+        foreach(flags ${flags_configs})
+            if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+                if(NOT ${flags} MATCHES "-static-libstdc\\+\\+")
+                    set(${flags} "${${flags}} -static-libstdc++")
+                endif()
+                if(NOT ${flags} MATCHES "-static-libgcc")
+                    set(${flags} "${${flags}} -static-libgcc")
+                endif()
+            elseif(MSVC)
+                if(${flags} MATCHES "/MD")
+                    string(REGEX REPLACE "/MD" "/MT" ${flags} "${${flags}}")
+                endif()
+            endif()
+        endforeach()
+    elseif("${ARG_DYNAMIC}")
+        foreach(flags ${flags_configs})
+            if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+                if(${flags} MATCHES "-static-libstdc\\+\\+")
+                    string(REGEX REPLACE "-static-libstdc\\+\\+" "" ${flags} "${${flags}}")
+                endif()
+                if(${flags} MATCHES "-static-libgcc")
+                    string(REGEX REPLACE "-static-libgcc" "" ${flags} "${${flags}}")
+                endif()
+            elseif(MSVC)
+                if(${flags} MATCHES "/MT")
+                    string(REGEX REPLACE "/MT" "/MD" ${flags} "${${flags}}")
+                endif()
+            endif()
+        endforeach()
+    endif()
+endmacro()
+
+# ucm_print_flags
+# Prints all compiler flags for all configurations
+macro(ucm_print_flags)
+    ucm_gather_flags(1 flags_configs)
+    message("")
+    foreach(flags ${flags_configs})
+        message("${flags}: ${${flags}}")
+    endforeach()
+    message("")
+endmacro()
+
+# ucm_set_xcode_attrib
+# Set xcode attributes - name value CONFIG config1 conifg2..
+macro(ucm_set_xcode_attrib)
+    cmake_parse_arguments(ARG "" "CLEAR" "CONFIG" ${ARGN})
+
+    if(NOT ARG_CONFIG)
+        set(ARG_CONFIG " ")
+    endif()
+
+    foreach(CONFIG ${ARG_CONFIG})
+        # determine to which attributes to add
+        if(${CONFIG} STREQUAL " ")
+            if(${ARG_CLEAR})
+                # clear the old flags
+                unset(CMAKE_XCODE_ATTRIBUTE_${ARGV0})
+            else()
+                set(CMAKE_XCODE_ATTRIBUTE_${ARGV0} ${ARGV1})
+            endif()
+        else()
+            if(${ARG_CLEAR})
+                # clear the old flags
+                unset(CMAKE_XCODE_ATTRIBUTE_${ARGV0}[variant=${CONFIG}])
+            else()
+                set(CMAKE_XCODE_ATTRIBUTE_${ARGV0}[variant=${CONFIG}] ${ARGV1})
+            endif()
+        endif()
+    endforeach()
+endmacro()
+
+# ucm_count_sources
+# Counts the number of source files
+macro(ucm_count_sources)
+    cmake_parse_arguments(ARG "" "RESULT" "" ${ARGN})
+    if(${ARG_RESULT} STREQUAL "")
+        message(FATAL_ERROR "Need to pass RESULT and a variable name to ucm_count_sources()")
+    endif()
+    
+    set(result 0)
+    foreach(SOURCE_FILE ${ARG_UNPARSED_ARGUMENTS})
+        if("${SOURCE_FILE}" MATCHES \\.\(c|C|cc|cp|cpp|CPP|c\\+\\+|cxx|i|ii\)$)
+            math(EXPR result "${result} + 1")
+        endif()
+    endforeach()
+    set(${ARG_RESULT} ${result})
+endmacro()
+
+# ucm_include_file_in_sources
+# Includes the file to the source with compiler flags
+macro(ucm_include_file_in_sources)
+    cmake_parse_arguments(ARG "" "HEADER" "" ${ARGN})
+    if(${ARG_HEADER} STREQUAL "")
+        message(FATAL_ERROR "Need to pass HEADER and a header file to ucm_include_file_in_sources()")
+    endif()
+    
+    foreach(src ${ARG_UNPARSED_ARGUMENTS})
+        if(${src} MATCHES \\.\(c|C|cc|cp|cpp|CPP|c\\+\\+|cxx\)$)
+            # get old flags
+            get_source_file_property(old_compile_flags ${src} COMPILE_FLAGS)
+            if(old_compile_flags STREQUAL "NOTFOUND")
+                set(old_compile_flags "")
+            endif()
+            
+            # update flags
+            if(MSVC)
+                set_source_files_properties(${src} PROPERTIES COMPILE_FLAGS
+                    "${old_compile_flags} /FI\"${CMAKE_CURRENT_SOURCE_DIR}/${ARG_HEADER}\"")
+            else()
+                set_source_files_properties(${src} PROPERTIES COMPILE_FLAGS
+                    "${old_compile_flags} -include \"${CMAKE_CURRENT_SOURCE_DIR}/${ARG_HEADER}\"")
+            endif()
+        endif()
+    endforeach()
+endmacro()
+
+# ucm_dir_list
+# Returns a list of subdirectories for a given directory
+macro(ucm_dir_list thedir result)
+    file(GLOB sub-dir "${thedir}/*")
+    set(list_of_dirs "")
+    foreach(dir ${sub-dir})
+        if(IS_DIRECTORY ${dir})
+            get_filename_component(DIRNAME ${dir} NAME)
+            LIST(APPEND list_of_dirs ${DIRNAME})
+        endif()
+    endforeach()
+    set(${result} ${list_of_dirs})
+endmacro()
+
+# ucm_trim_front_words
+# Trims X times the front word from a string separated with "/" and removes
+# the front "/" characters after that (used for filters for visual studio)
+macro(ucm_trim_front_words source out num_filter_trims)
+    set(result "${source}")
+    set(counter 0)
+    while(${counter} LESS ${num_filter_trims})
+        MATH(EXPR counter "${counter} + 1")
+        # removes everything at the front up to a "/" character
+        string(REGEX REPLACE "^([^/]+)" "" result "${result}")
+        # removes all consecutive "/" characters from the front
+        string(REGEX REPLACE "^(/+)" "" result "${result}")
+    endwhile()
+    set(${out} ${result})
+endmacro()
+
+# ucm_remove_files
+# Removes source files from a list of sources (path is the relative path for it to be found)
+macro(ucm_remove_files)
+    cmake_parse_arguments(ARG "" "FROM" "" ${ARGN})
+    
+    if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass some relative files to ucm_remove_files()")
+    endif()
+    if(${ARG_FROM} STREQUAL "")
+        message(FATAL_ERROR "Need to pass FROM and a variable name to ucm_remove_files()")
+    endif()
+    
+    foreach(cur_file ${ARG_UNPARSED_ARGUMENTS})
+        list(REMOVE_ITEM ${ARG_FROM} ${cur_file})
+    endforeach()
+endmacro()
+
+# ucm_remove_directories
+# Removes all source files from the given directories from the sources list
+macro(ucm_remove_directories)
+    cmake_parse_arguments(ARG "" "FROM" "MATCHES" ${ARGN})
+    
+    if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass some relative directories to ucm_remove_directories()")
+    endif()
+    if(${ARG_FROM} STREQUAL "")
+        message(FATAL_ERROR "Need to pass FROM and a variable name to ucm_remove_directories()")
+    endif()
+    
+    foreach(cur_dir ${ARG_UNPARSED_ARGUMENTS})
+        foreach(cur_file ${${ARG_FROM}})
+            string(REGEX MATCH ${cur_dir} res ${cur_file})
+            if(NOT "${res}" STREQUAL "")
+                if("${ARG_MATCHES}" STREQUAL "")
+                    list(REMOVE_ITEM ${ARG_FROM} ${cur_file})
+                else()
+                    foreach(curr_ptrn ${ARG_MATCHES})
+                        string(REGEX MATCH ${curr_ptrn} res ${cur_file})
+                        if(NOT "${res}" STREQUAL "")
+                            list(REMOVE_ITEM ${ARG_FROM} ${cur_file})
+                            break()
+                        endif()
+                    endforeach()
+                endif()
+            endif()
+        endforeach()
+    endforeach()
+endmacro()
+
+# ucm_add_files_impl
+macro(ucm_add_files_impl result trim files)
+    foreach(cur_file ${files})
+        SET(${result} ${${result}} ${cur_file})
+        get_filename_component(FILEPATH ${cur_file} PATH)
+        ucm_trim_front_words("${FILEPATH}" FILEPATH "${trim}")
+        # replacing forward slashes with back slashes so filters can be generated (back slash used in parsing...)
+        STRING(REPLACE "/" "\\" FILTERS "${FILEPATH}")
+        SOURCE_GROUP("${FILTERS}" FILES ${cur_file})
+    endforeach()
+endmacro()
+
+# ucm_add_files
+# Adds files to a list of sources
+macro(ucm_add_files)
+    cmake_parse_arguments(ARG "" "TO;FILTER_POP" "" ${ARGN})
+    
+    if("${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass some relative files to ucm_add_files()")
+    endif()
+    if(${ARG_TO} STREQUAL "")
+        message(FATAL_ERROR "Need to pass TO and a variable name to ucm_add_files()")
+    endif()
+    
+    if("${ARG_FILTER_POP}" STREQUAL "")
+        set(ARG_FILTER_POP 0)
+    endif()
+    
+    ucm_add_files_impl(${ARG_TO} ${ARG_FILTER_POP} "${ARG_UNPARSED_ARGUMENTS}")
+endmacro()
+
+# ucm_add_dir_impl
+macro(ucm_add_dir_impl result rec trim dirs_in additional_ext)
+    set(dirs "${dirs_in}")
+    
+    # handle the "" and "." cases
+    if("${dirs}" STREQUAL "" OR "${dirs}" STREQUAL ".")
+        set(dirs "./")
+    endif()
+    
+    foreach(cur_dir ${dirs})
+        # to circumvent some linux/cmake/path issues - barely made it work...
+        if(cur_dir STREQUAL "./")
+            set(cur_dir "")
+        else()
+            set(cur_dir "${cur_dir}/")
+        endif()
+        
+        # since unix is case sensitive - add these valid extensions too
+        # we don't use "UNIX" but instead "CMAKE_HOST_UNIX" because we might be cross
+        # compiling (for example emscripten) under windows and UNIX may be set to 1
+        # Also OSX is case insensitive like windows...
+        set(additional_file_extensions "")
+        if(CMAKE_HOST_UNIX AND NOT APPLE)
+            set(additional_file_extensions
+                "${cur_dir}*.CPP"
+                "${cur_dir}*.C"
+                "${cur_dir}*.H"
+                "${cur_dir}*.HPP"
+                )
+        endif()
+        
+        foreach(ext ${additional_ext})
+            list(APPEND additional_file_extensions "${cur_dir}*.${ext}")
+        endforeach()
+        
+        # find all sources and set them as result
+        FILE(GLOB found_sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+        # https://gcc.gnu.org/onlinedocs/gcc-4.4.1/gcc/Overall-Options.html#index-file-name-suffix-71
+        # sources
+            "${cur_dir}*.cpp"
+            "${cur_dir}*.cxx"
+            "${cur_dir}*.c++"
+            "${cur_dir}*.cc"
+            "${cur_dir}*.cp"
+            "${cur_dir}*.c"
+            "${cur_dir}*.i"
+            "${cur_dir}*.ii"
+        # headers
+            "${cur_dir}*.h"
+            "${cur_dir}*.h++"
+            "${cur_dir}*.hpp"
+            "${cur_dir}*.hxx"
+            "${cur_dir}*.hh"
+            "${cur_dir}*.inl"
+            "${cur_dir}*.inc"
+            "${cur_dir}*.ipp"
+            "${cur_dir}*.ixx"
+            "${cur_dir}*.txx"
+            "${cur_dir}*.tpp"
+            "${cur_dir}*.tcc"
+            "${cur_dir}*.tpl"
+            ${additional_file_extensions})
+        SET(${result} ${${result}} ${found_sources})
+        
+        # set the proper filters
+        ucm_trim_front_words("${cur_dir}" cur_dir "${trim}")
+        # replacing forward slashes with back slashes so filters can be generated (back slash used in parsing...)
+        STRING(REPLACE "/" "\\" FILTERS "${cur_dir}")
+        SOURCE_GROUP("${FILTERS}" FILES ${found_sources})
+    endforeach()
+    
+    if(${rec})
+        foreach(cur_dir ${dirs})
+            ucm_dir_list("${cur_dir}" subdirs)
+            foreach(subdir ${subdirs})
+                ucm_add_dir_impl(${result} ${rec} ${trim} "${cur_dir}/${subdir}" "${additional_ext}")
+            endforeach()
+        endforeach()
+    endif()
+endmacro()
+
+# ucm_add_dirs
+# Adds all files from directories traversing them recursively to a list of sources
+# and generates filters according to their location (accepts relative paths only).
+# Also this macro trims X times the front word from the filter string for visual studio filters.
+macro(ucm_add_dirs)
+    cmake_parse_arguments(ARG "RECURSIVE" "TO;FILTER_POP" "ADDITIONAL_EXT" ${ARGN})
+    
+    if(${ARG_TO} STREQUAL "")
+        message(FATAL_ERROR "Need to pass TO and a variable name to ucm_add_dirs()")
+    endif()
+    
+    if("${ARG_FILTER_POP}" STREQUAL "")
+        set(ARG_FILTER_POP 0)
+    endif()
+    
+    ucm_add_dir_impl(${ARG_TO} ${ARG_RECURSIVE} ${ARG_FILTER_POP} "${ARG_UNPARSED_ARGUMENTS}" "${ARG_ADDITIONAL_EXT}")
+endmacro()
+
+# ucm_add_target
+# Adds a target eligible for cotiring - unity build and/or precompiled header
+macro(ucm_add_target)
+    cmake_parse_arguments(ARG "UNITY" "NAME;TYPE;PCH_FILE;CPP_PER_UNITY" "UNITY_EXCLUDED;SOURCES" ${ARGN})
+    
+    if(NOT "${ARG_UNPARSED_ARGUMENTS}" STREQUAL "")
+        message(FATAL_ERROR "Unrecognized options passed to ucm_add_target()")
+    endif()
+    if("${ARG_NAME}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass NAME and a name for the target to ucm_add_target()")
+    endif()
+    set(valid_types EXECUTABLE STATIC SHARED MODULE)
+    list(FIND valid_types "${ARG_TYPE}" is_type_valid)
+    if(${is_type_valid} STREQUAL "-1")
+        message(FATAL_ERROR "Need to pass TYPE and the type for the target [EXECUTABLE/STATIC/SHARED/MODULE] to ucm_add_target()")
+    endif()
+    if("${ARG_SOURCES}" STREQUAL "")
+        message(FATAL_ERROR "Need to pass SOURCES and a list of source files to ucm_add_target()")
+    endif()
+    
+    # init with the global unity flag
+    set(do_unity ${UCM_UNITY_BUILD})
+    
+    # check the UNITY argument
+    if(NOT ARG_UNITY)
+        set(do_unity FALSE)
+    endif()
+    
+    # if target is excluded through the exclusion list
+    list(FIND UCM_UNITY_BUILD_EXCLUDE_TARGETS ${ARG_NAME} is_target_excluded)
+    if(NOT ${is_target_excluded} STREQUAL "-1")
+        set(do_unity FALSE)
+    endif()
+    
+    # unity build only for targets with > 1 source file (otherwise there will be an additional unnecessary target)
+    if(do_unity) # optimization
+        ucm_count_sources(${ARG_SOURCES} RESULT num_sources)
+        if(${num_sources} LESS 2)
+            set(do_unity FALSE)
+        endif()
+    endif()
+    
+    set(wanted_cotire ${do_unity})
+    
+    # if cotire cannot be used
+    if(do_unity AND NOT ucm_with_cotire)
+        set(do_unity FALSE)
+    endif()
+    
+	# inform the developer that the current target might benefit from a unity build
+	if(NOT ARG_UNITY AND ${UCM_UNITY_BUILD})
+		ucm_count_sources(${ARG_SOURCES} RESULT num_sources)
+		if(${num_sources} GREATER 1)
+			message(AUTHOR_WARNING "Target '${ARG_NAME}' may benefit from a unity build.\nIt has ${num_sources} sources - enable with UNITY flag")
+		endif()
+	endif()
+    
+    # prepare for the unity build
+    set(orig_target ${ARG_NAME})
+    if(do_unity)
+        # the original target will be added with a different name than the requested
+        set(orig_target ${ARG_NAME}_ORIGINAL)
+        
+        # exclude requested files from unity build of the current target
+        foreach(excluded_file "${ARG_UNITY_EXCLUDED}")
+            set_source_files_properties(${excluded_file} PROPERTIES COTIRE_EXCLUDED TRUE)
+        endforeach()
+    endif()
+    
+    # add the original target
+    if(${ARG_TYPE} STREQUAL "EXECUTABLE")
+        add_executable(${orig_target} ${ARG_SOURCES})
+    else()
+        add_library(${orig_target} ${ARG_TYPE} ${ARG_SOURCES})
+    endif()
+    
+    if(do_unity)
+        # set the number of unity cpp files to be used for the unity target
+        if(NOT "${ARG_CPP_PER_UNITY}" STREQUAL "")
+            set_property(TARGET ${orig_target} PROPERTY COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "${ARG_CPP_PER_UNITY}")
+		else()
+			set_property(TARGET ${orig_target} PROPERTY COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "100")
+		endif()
+        
+        if(NOT "${ARG_PCH_FILE}" STREQUAL "")
+            set_target_properties(${orig_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${ARG_PCH_FILE}")
+        else()
+            set_target_properties(${orig_target} PROPERTIES COTIRE_ENABLE_PRECOMPILED_HEADER FALSE)
+        endif()
+        # add a unity target for the original one with the name intended for the original
+        set_target_properties(${orig_target} PROPERTIES COTIRE_UNITY_TARGET_NAME ${ARG_NAME})
+        
+        # this is the library call that does the magic
+        cotire(${orig_target})
+        set_target_properties(clean_cotire PROPERTIES FOLDER "CMakePredefinedTargets")
+        
+        # disable the original target and enable the unity one
+        get_target_property(unity_target_name ${orig_target} COTIRE_UNITY_TARGET_NAME)
+        set_target_properties(${orig_target} PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1)
+        set_target_properties(${unity_target_name} PROPERTIES EXCLUDE_FROM_ALL 0 EXCLUDE_FROM_DEFAULT_BUILD 0)
+        
+        # also set the name of the target output as the original one
+        set_target_properties(${unity_target_name} PROPERTIES OUTPUT_NAME ${ARG_NAME})
+        if(UCM_NO_COTIRE_FOLDER)
+            # reset the folder property so all unity targets dont end up in a single folder in the solution explorer of VS
+            set_target_properties(${unity_target_name} PROPERTIES FOLDER "")
+        endif()
+        set_target_properties(all_unity PROPERTIES FOLDER "CMakePredefinedTargets")
+    elseif(NOT "${ARG_PCH_FILE}" STREQUAL "")
+        set(wanted_cotire TRUE)
+        if(ucm_with_cotire)
+            set_target_properties(${orig_target} PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
+            set_target_properties(${orig_target} PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${ARG_PCH_FILE}")
+            cotire(${orig_target})
+            set_target_properties(clean_cotire PROPERTIES FOLDER "CMakePredefinedTargets")
+        endif()
+    endif()
+    
+    # print a message if the target was requested to be cotired but it couldn't
+    if(wanted_cotire AND NOT ucm_with_cotire)
+        if(NOT COMMAND cotire)
+            message(AUTHOR_WARNING "Target \"${ARG_NAME}\" not cotired because cotire isn't loaded")
+        else()
+            message(AUTHOR_WARNING "Target \"${ARG_NAME}\" not cotired because cotire is older than the required version")
+        endif()
+    endif()
+endmacro()
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5e53ee5a1..8f437e608 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -12,6 +12,8 @@ add_executable(unit_tests tests.cpp)
 
 target_link_libraries(unit_tests PRIVATE sqlite_orm sqlite3)
 
+enable_testing()
+
 add_test(NAME "All_in_one_unit_test"
     COMMAND unit_tests
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})

From 80ddd166147324afb1f178adc17ae712379d5408 Mon Sep 17 00:00:00 2001
From: Seyyed Soroosh Hosseinalipour <soorosh_abi@hotmail.com>
Date: Tue, 2 Apr 2019 06:07:38 +0430
Subject: [PATCH 58/63] bigobj flag added for release mode in Win64
 compilation. (see #258)

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ce3bd1864..5dd151ba8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -38,7 +38,7 @@ if (MSVC)
 	string(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")	
 	add_compile_options(/EHsc)
 
-	if ("${CMAKE_GENERATOR}" MATCHES "(Win64|x64)" AND ((CMAKE_BUILD_TYPE EQUAL "Debug") OR (CMAKE_BUILD_TYPE EQUAL "" )))
+	if ("${CMAKE_GENERATOR}" MATCHES "(Win64|x64)")
 		message(STATUS "Add /bigobj flag to compiler")
     	add_compile_options(/bigobj)
 	endif()

From c303050b80a4fe8750e285f0ae7ffcf0432f0794 Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 2 Apr 2019 14:37:47 +0300
Subject: [PATCH 59/63] changed assert 0 to throw

---
 tests/tests.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/tests.cpp b/tests/tests.cpp
index af9e4263a..4e6861085 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -654,7 +654,7 @@ void testExplicitInsert() {
         user4.name = "Egor";
         try {
             storage.insert(user4, columns(&User::name));
-            assert(0);
+            throw std::runtime_error("Must not fire");
         } catch (std::system_error e) {
             //        cout << e.what() << endl;
         }
@@ -701,14 +701,14 @@ void testExplicitInsert() {
         visit3.setId(10);
         try {
             storage.insert(visit3, columns(&Visit::id));
-            assert(0);
+            throw std::runtime_error("Must not fire");
         } catch (std::system_error e) {
             //        cout << e.what() << endl;
         }
         
         try {
             storage.insert(visit3, columns(&Visit::setId));
-            assert(0);
+            throw std::runtime_error("Must not fire");
         } catch (std::system_error e) {
             //        cout << e.what() << endl;
         }
@@ -1398,7 +1398,7 @@ void testSelect() {
     rc = sqlite3_step(stmt);
     if(rc != SQLITE_DONE){
         cout << sqlite3_errmsg(db) << endl;
-        assert(0);
+        throw std::runtime_error(sqlite3_errmsg(db));
     }
     sqlite3_finalize(stmt);
 
@@ -1415,7 +1415,7 @@ void testSelect() {
     rc = sqlite3_step(stmt);
     if(rc != SQLITE_DONE){
         cout << sqlite3_errmsg(db) << endl;
-        assert(0);
+        throw std::runtime_error(sqlite3_errmsg(db));
     }
     sqlite3_finalize(stmt);
 
@@ -1432,7 +1432,7 @@ void testSelect() {
     rc = sqlite3_step(stmt);
     if(rc != SQLITE_DONE){
         cout << sqlite3_errmsg(db) << endl;
-        assert(0);
+        throw std::runtime_error(sqlite3_errmsg(db));
     }
     sqlite3_finalize(stmt);
 
@@ -1825,7 +1825,7 @@ void testTransactionGuard() {
         storage.insert(Object{0, "Lincoln"});
 
     }catch(...){
-        assert(0);
+        throw std::runtime_error("Must not fire");
     }
     auto countNow = storage.count<Object>();
     assert(countNow == countBefore + 1);
@@ -2105,7 +2105,7 @@ void testSynchronous() {
     const auto newValue = 2;
     try{
         storage.pragma.synchronous(newValue);
-        assert(0);
+        throw std::runtime_error("Must not fire");
     }catch(std::system_error) {
         //  Safety level may not be changed inside a transaction
         assert(storage.pragma.synchronous() == value);

From 4cd95dd889d96ef0b4c122908cd53b3c8e85cb9c Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 2 Apr 2019 16:15:57 +0300
Subject: [PATCH 60/63] changed assert argument

---
 tests/tests.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/tests.cpp b/tests/tests.cpp
index 4e6861085..5b1399a9a 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -643,7 +643,8 @@ void testExplicitInsert() {
         user3.name = "Sia";
         user3.age = 42;
         user3.email = "sia@gmail.com";
-        assert(user3.id == storage.insert(user3, columns(&User::id, &User::name, &User::age, &User::email)));
+        auto insertedId = storage.insert(user3, columns(&User::id, &User::name, &User::age, &User::email));
+        assert(user3.id == insertedId);
         auto insertedUser3 = storage.get<User>(user3.id);
         assert(insertedUser3.email == user3.email);
         assert(insertedUser3.age == user3.age);

From d6284439e9cd05b6a296b335e5a938aac4ad2a9f Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Tue, 2 Apr 2019 18:16:47 +0300
Subject: [PATCH 61/63] fixed NDEBUG tests

---
 tests/tests.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/tests.cpp b/tests/tests.cpp
index 5b1399a9a..176950927 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -685,13 +685,15 @@ void testExplicitInsert() {
         visit2.setId(2);
         visit2.setUsedId(1);
         {
-            assert(visit2.id() == storage.insert(visit2, columns(&Visit::id, &Visit::usedId)));
+            auto insertedId = storage.insert(visit2, columns(&Visit::id, &Visit::usedId));
+            assert(visit2.id() == insertedId);
             auto visitFromStorage = storage.get<Visit>(visit2.id());
             assert(visitFromStorage.usedId() == visit2.usedId());
             storage.remove<Visit>(visit2.id());
         }
         {
-            assert(visit2.id() == storage.insert(visit2, columns(&Visit::setId, &Visit::setUsedId)));
+            auto insertedId = storage.insert(visit2, columns(&Visit::setId, &Visit::setUsedId));
+            assert(visit2.id() == insertedId);
             auto visitFromStorage = storage.get<Visit>(visit2.id());
             assert(visitFromStorage.usedId() == visit2.usedId());
             storage.remove<Visit>(visit2.id());

From d31aa94f858f01974f695df2c2e2ae03a176f149 Mon Sep 17 00:00:00 2001
From: soroshsabz <soorosh_abi@hotmail.com>
Date: Thu, 4 Apr 2019 02:15:05 +0430
Subject: [PATCH 62/63] Update README. (see #258)

Add appveyor badge
---
 README.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ee64ccb86..85af0b387 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,6 @@
 </p>
 
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-[![Build Status](https://travis-ci.org/fnc12/sqlite_orm.svg?branch=master)](https://travis-ci.org/fnc12/sqlite_orm)
 [![Donate using PayPal](https://img.shields.io/badge/donate-PayPal-brightgreen.svg)](https://paypal.me/fnc12)
 [![Twitter URL](https://img.shields.io/twitter/url/https/twitter.com/fold_left.svg?style=social&label=Follow%20%40sqlite_orm)](https://twitter.com/sqlite_orm)
 
@@ -11,6 +10,12 @@
 # SQLite ORM
 SQLite ORM light header only library for modern C++
 
+# Status
+| Branch | Travis | Appveyor | Coverity Scan | codecov.io | Website |
+| :----- | :----- | :------- | :------------ | :--------- | :------ |
+| [`master`](https://github.com/fcn12/sqlite_orm/tree/master) | [![Build Status](https://travis-ci.org/fnc12/sqlite_orm.svg?branch=master)](https://travis-ci.org/fcn12/sqlite_orm) | [![Build status](https://ci.appveyor.com/api/projects/status/github/fnc12/sqlite_orm?branch=master&svg=true)](https://ci.appveyor.com/project/fnc12/sqlite-orm/history) | | | [![Website](https://img.shields.io/badge/official-website-brightgreen.svg)](https://github.com/fcn12/sqlite_orm/) |
+| [`dev`](https://github.com/fcn12/sqlite_orm/tree/dev) | [![Build Status](https://travis-ci.org/fnc12/sqlite_orm.svg?branch=dev)](https://travis-ci.org/fcn12/sqlite_orm) | [![Build status](https://ci.appveyor.com/api/projects/status/github/fnc12/sqlite_orm?branch=dev&svg=true)](https://ci.appveyor.com/project/fnc12/sqlite-orm/history) | | | [![Website](https://img.shields.io/badge/official-website-brightgreen.svg)](https://github.com/fcn12/sqlite_orm/tree/dev) |
+
 # Advantages
 
 * **No raw string queries**

From 22935a2b9054ea09803d82feebb2681f73921f6f Mon Sep 17 00:00:00 2001
From: fnc12 <fnc12345@gmail.com>
Date: Sun, 7 Apr 2019 01:11:34 +0300
Subject: [PATCH 63/63] added arithmetic support for where

---
 dev/conditions.h                |  4 ++--
 dev/storage.h                   | 10 +++++----
 include/sqlite_orm/sqlite_orm.h | 14 +++++++------
 tests/tests.cpp                 | 36 +++++++++++++++++++++++++++++++++
 4 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/dev/conditions.h b/dev/conditions.h
index d4c47963f..bf550a0b9 100644
--- a/dev/conditions.h
+++ b/dev/conditions.h
@@ -900,7 +900,7 @@ namespace sqlite_orm {
     template<
     class L,
     class R,
-    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value && std::is_base_of<conditions::condition_t, R>::value>::type
+    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value || std::is_base_of<conditions::condition_t, R>::value>::type
     >
     conditions::and_condition_t<L, R> operator &&(const L &l, const R &r) {
         return {l, r};
@@ -909,7 +909,7 @@ namespace sqlite_orm {
     template<
     class L,
     class R,
-    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value && std::is_base_of<conditions::condition_t, R>::value>::type
+    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value || std::is_base_of<conditions::condition_t, R>::value>::type
     >
     conditions::or_condition_t<L, R> operator ||(const L &l, const R &r) {
         return {l, r};
diff --git a/dev/storage.h b/dev/storage.h
index 905b98de6..defbe6a76 100644
--- a/dev/storage.h
+++ b/dev/storage.h
@@ -1023,11 +1023,13 @@ namespace sqlite_orm {
                 return ss.str();
             }
             
-            /**
-             *  Common case. Is used to process binary conditions like is_equal, not_equal
-             */
+            template<class T>
+            typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type process_where(const T &c) {
+                return this->string_from_expression(c);
+            }
+            
             template<class C>
-            std::string process_where(const C &c) {
+            typename std::enable_if<is_base_of_template<C, conditions::binary_condition>::value, std::string>::type process_where(const C &c) {
                 auto leftString = this->string_from_expression(c.l, false, true);
                 auto rightString = this->string_from_expression(c.r, false, true);
                 std::stringstream ss;
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
index 597b2bb99..a1de47556 100644
--- a/include/sqlite_orm/sqlite_orm.h
+++ b/include/sqlite_orm/sqlite_orm.h
@@ -2408,7 +2408,7 @@ namespace sqlite_orm {
     template<
     class L,
     class R,
-    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value && std::is_base_of<conditions::condition_t, R>::value>::type
+    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value || std::is_base_of<conditions::condition_t, R>::value>::type
     >
     conditions::and_condition_t<L, R> operator &&(const L &l, const R &r) {
         return {l, r};
@@ -2417,7 +2417,7 @@ namespace sqlite_orm {
     template<
     class L,
     class R,
-    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value && std::is_base_of<conditions::condition_t, R>::value>::type
+    typename = typename std::enable_if<std::is_base_of<conditions::condition_t, L>::value || std::is_base_of<conditions::condition_t, R>::value>::type
     >
     conditions::or_condition_t<L, R> operator ||(const L &l, const R &r) {
         return {l, r};
@@ -7503,11 +7503,13 @@ namespace sqlite_orm {
                 return ss.str();
             }
             
-            /**
-             *  Common case. Is used to process binary conditions like is_equal, not_equal
-             */
+            template<class T>
+            typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type process_where(const T &c) {
+                return this->string_from_expression(c);
+            }
+            
             template<class C>
-            std::string process_where(const C &c) {
+            typename std::enable_if<is_base_of_template<C, conditions::binary_condition>::value, std::string>::type process_where(const C &c) {
                 auto leftString = this->string_from_expression(c.l, false, true);
                 auto rightString = this->string_from_expression(c.r, false, true);
                 std::stringstream ss;
diff --git a/tests/tests.cpp b/tests/tests.cpp
index 176950927..008c0fa9b 100644
--- a/tests/tests.cpp
+++ b/tests/tests.cpp
@@ -2309,6 +2309,40 @@ void testEscapedIndexName() {
     storage.sync_schema();
 }
 
+void testWhere() {
+    cout << __func__ << endl;
+    
+    struct User{
+        int id = 0;
+        std::string name;
+    };
+    
+    auto storage = make_storage("",
+                                make_table("users",
+                                           make_column("id", &User::id, primary_key()),
+                                           make_column("name", &User::name)));
+    storage.sync_schema();
+    
+    storage.replace(User{ 1, "Jeremy" });
+    storage.replace(User{ 2, "Nataly" });
+    
+    auto users = storage.get_all<User>();
+    assert(users.size() == 2);
+    
+    auto users2 = storage.get_all<User>(where(true));
+    assert(users2.size() == 2);
+    
+    auto users3 = storage.get_all<User>(where(false));
+    assert(users3.size() == 0);
+    
+    auto users4 = storage.get_all<User>(where(true and c(&User::id) == 1));
+    assert(users4.size() == 1);
+    assert(users4.front().id == 1);
+    
+    auto users5 = storage.get_all<User>(where(false and c(&User::id) == 1));
+    assert(users5.size() == 0);
+}
+
 int main(int argc, char **argv) {
 
     cout << "version = " << make_storage("").libversion() << endl;
@@ -2396,4 +2430,6 @@ int main(int argc, char **argv) {
     testSimpleQuery();
     
     testCast();
+    
+    testWhere();
 }