fts5 first draft

Author: EugeneBaldZakharov

.gitignore

@@ -6,3 +6,4 @@ cmake-build-debug/
 .idea/
 
 /compile
+build

dev/ast/match.h

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace sqlite_orm {
+    namespace internal {
+
+    	template<class T, class X>
+    	struct match_t {
+    		using mapped_type = T;
+    		using argument_type = X;
+
+    		argument_type argument;
+
+    		match_t(argument_type argument): argument(std::move(argument)) {}
+    	};
+	}
+	
+	template<class T, class X>
+	internal::match_t<T, X> match(X argument) {
+		return {std::move(argument)};
+	}
+
+}

dev/ast_iterator.h

@@ -20,6 +20,7 @@
 #include "ast/group_by.h"
 #include "ast/exists.h"
 #include "ast/set.h"
+#include "ast/match.h"
 
 namespace sqlite_orm {
 
@@ -141,9 +142,19 @@ namespace sqlite_orm {
             using node_type = binary_operator<L, R, Ds...>;
 
             template<class C>
-            void operator()(const node_type& binaryOperator, C& lambda) const {
-                iterate_ast(binaryOperator.lhs, lambda);
-                iterate_ast(binaryOperator.rhs, lambda);
+            void operator()(const node_type& node, C& lambda) const {
+                iterate_ast(node.lhs, lambda);
+                iterate_ast(node.rhs, lambda);
+            }
+        };
+
+        template<class L, class R>
+        struct ast_iterator<is_equal_with_table_t<L, R>, void> {
+            using node_type = is_equal_with_table_t<L, R>;
+
+            template<class C>
+            void operator()(const node_type& node, C& lambda) const {
+                iterate_ast(node.rhs, lambda);
             }
         };
 
@@ -212,6 +223,16 @@ namespace sqlite_orm {
             }
         };
 
+        template<class T, class X>
+        struct ast_iterator<match_t<T, X>, void> {
+            using node_type = match_t<T, X>;
+
+            template<class L>
+            void operator()(const node_type& node, L& lambda) const {
+                iterate_ast(node.argument, lambda);
+            }
+        };
+
         template<class T>
         struct ast_iterator<into_t<T>, void> {
             using node_type = into_t<T>;

dev/column_names_getter.h

@@ -21,8 +21,8 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         template<class T, class Ctx>
         std::vector<std::string>& collect_table_column_names(std::vector<std::string>& collectedExpressions,

dev/conditions.h

@@ -210,6 +210,16 @@ namespace sqlite_orm {
             }
         };
 
+        template<class L, class R>
+        struct is_equal_with_table_t: negatable_t {
+            using left_type = L;
+            using right_type = R;
+
+            right_type rhs;
+
+            is_equal_with_table_t(right_type rhs): rhs(std::move(rhs)) {}
+        };
+
         struct is_not_equal_string {
             operator std::string() const {
                 return "!=";
@@ -1085,6 +1095,11 @@ namespace sqlite_orm {
         return {std::move(l), std::move(r)};
     }
 
+    template<class L, class R>
+    internal::is_equal_with_table_t<L, R> is_equal(R rhs) {
+        return {std::move(rhs)};
+    }
+
     template<class L, class R>
     internal::is_not_equal_t<L, R> is_not_equal(L l, R r) {
         return {std::move(l), std::move(r)};

dev/default_value_extractor.h

@@ -10,8 +10,8 @@ namespace sqlite_orm {
 
     namespace internal {
 
-        template<class T, class DBOs>
-        std::string serialize(const T&, const serializer_context<DBOs>&);
+        template<class T, class C>
+        std::string serialize(const T& t, const C& context);
 
         /**
          *  Serialize default value of a column's default valu

dev/eponymous_vtabs/dbstat.h

@@ -5,7 +5,7 @@
 #endif
 
 #include "../column.h"
-#include "../table.h"
+#include "../schema/table.h"
 
 namespace sqlite_orm {
 #ifdef SQLITE_ENABLE_DBSTAT_VTAB

dev/implementations/table_definitions.h

@@ -10,7 +10,7 @@
 #include "../functional/cxx_universal.h"  //  ::size_t
 #include "../type_printer.h"
 #include "../column.h"
-#include "../table.h"
+#include "../schema/table.h"
 
 namespace sqlite_orm {
     namespace internal {

dev/node_tuple.h

@@ -20,9 +20,9 @@
 #include "ast/where.h"
 #include "ast/into.h"
 #include "ast/group_by.h"
+#include "ast/match.h"
 
 namespace sqlite_orm {
-
     namespace internal {
 
         template<class T, class SFINAE = void>
@@ -89,6 +89,9 @@ namespace sqlite_orm {
         template<class E>
         struct node_tuple<order_by_t<E>, void> : node_tuple<E> {};
 
+        template<class L, class R>
+        struct node_tuple<is_equal_with_table_t<L, R>, void> : node_tuple<R> {};
+
         template<class T>
         struct node_tuple<T, match_if<is_binary_condition, T>> {
             using node_type = T;
@@ -158,6 +161,9 @@ namespace sqlite_orm {
         template<class T>
         struct node_tuple<into_t<T>, void> : node_tuple<void> {};
 
+        template<class T, class X>
+        struct node_tuple<match_t<T, X>, void> : node_tuple<X> {};
+
         template<class... Args>
         struct node_tuple<values_t<Args...>, void> {
             using type = tuple_cat_t<node_tuple_t<Args>...>;