From 10a7b7eafaf0a34499ac33c0e59424ed7e637424 Mon Sep 17 00:00:00 2001
From: bill <sunyinqi0508@gmail.com>
Date: Wed, 28 Sep 2022 00:09:47 +0800
Subject: [PATCH] Merge branch 'master' of
 https://github.com/sunyinqi0508/AQuery2

---
 build_instructions.txt         |  14 ---
 msc-plugin/libaquery.vcxproj   |   4 +
 msc-plugin/msc-plugin.vcxproj  |   2 +
 msc-plugin/sdk_example.vcxproj |   4 +
 sdk/aquery.h                   |   6 ++
 server/aggregations.h          |  83 +++++++++-----
 server/server.cpp              |  59 +++++-----
 server/table.h                 | 192 +++++++++++++++++----------------
 server/types.h                 | 110 ++++++++++++-------
 9 files changed, 274 insertions(+), 200 deletions(-)
 delete mode 100644 build_instructions.txt

diff --git a/build_instructions.txt b/build_instructions.txt
deleted file mode 100644
index d5d8297..0000000
--- a/build_instructions.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-## Windows 
-- clang-msvc:
-    - "%CXX%" -D_CRT_SECURE_NO_WARNINGS -shared server/server.cpp server/winhelper.cpp server/monetdb_conn.cpp -Imonetdb/msvc -Lmonetdb/msvc -lmonetdbe.lib --std=c++2a -o server.so
-    - os.add_dll_directory(os.path.abspath('./monetdb/msvc'))
-- gcc-mingw (link w/ msvc monetdb):
-    - "%CXX%" -shared -fPIC server/server.cpp server/winhelper.cpp server/monetdb_conn.cpp -Imonetdb/msvc msc-plugin/monetdbe.dll --std=c++2a -o server.so
-    - os.add_dll_directory('c:/msys64/usr/bin')
-    - os.add_dll_directory(os.path.abspath('./monetdb/msvc'))
-- gcc-mingw (link w/ mingw monetdb, can only load under mingw python):
-    - $(CXX) server/server.cpp server/monetdb_conn.cpp -fPIC -shared $(OS_SUPPORT) --std=c++1z -O3 -march=native -o server.so -I./monetdb/msys64 -L./lib -lmonetdbe
-    - add_dll_dir(os.path.abspath('./lib'))
-- msvc:
-    - D:\gg\vs22\MSBuild\Current\Bin\msbuild "d:\gg\AQuery++\server\server.vcxproj" /p:configuration=Release /p:platform=x64
-    - os.add_dll_directory(os.path.abspath('./monetdb/msvc'))
diff --git a/msc-plugin/libaquery.vcxproj b/msc-plugin/libaquery.vcxproj
index 7da895f..96b11f8 100644
--- a/msc-plugin/libaquery.vcxproj
+++ b/msc-plugin/libaquery.vcxproj
@@ -100,6 +100,8 @@
       <PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile>
       <AdditionalIncludeDirectories>$(ProjectDir)\..\monetdb\msvc</AdditionalIncludeDirectories>
       <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -161,6 +163,8 @@
       <PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile>
       <AdditionalIncludeDirectories>$(ProjectDir)\..\monetdb\msvc</AdditionalIncludeDirectories>
       <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
diff --git a/msc-plugin/msc-plugin.vcxproj b/msc-plugin/msc-plugin.vcxproj
index c187361..e0765b4 100644
--- a/msc-plugin/msc-plugin.vcxproj
+++ b/msc-plugin/msc-plugin.vcxproj
@@ -108,6 +108,7 @@
       <PrecompiledHeaderFile>./server/pch.hpp</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -178,6 +179,7 @@
       <PrecompiledHeaderFile>./server/pch.hpp</PrecompiledHeaderFile>
       <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
diff --git a/msc-plugin/sdk_example.vcxproj b/msc-plugin/sdk_example.vcxproj
index 09ddc80..f55e7a9 100644
--- a/msc-plugin/sdk_example.vcxproj
+++ b/msc-plugin/sdk_example.vcxproj
@@ -98,6 +98,8 @@
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpplatest</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -130,6 +132,8 @@
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpplatest</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
diff --git a/sdk/aquery.h b/sdk/aquery.h
index 3ef5bb6..fbe6517 100644
--- a/sdk/aquery.h
+++ b/sdk/aquery.h
@@ -75,7 +75,13 @@ extern void register_memory(void* ptr, deallocator_t deallocator);
 __AQEXPORT__(void) init_session(Context* cxt);
 
 #define __AQ_NO_SESSION__ __AQEXPORT__(void) init_session(Context*) {}
+
+#ifdef _MSC_VER
+void* _cdecl memcpy(void*, void*, size_t);
+#else 
 void* memcpy(void*, const void*, unsigned long long);
+#endif
+
 struct ColRef_storage {
 	void* container;
 	unsigned int capacity, size;
diff --git a/server/aggregations.h b/server/aggregations.h
index 514e4a6..583f246 100644
--- a/server/aggregations.h
+++ b/server/aggregations.h
@@ -16,7 +16,7 @@ constexpr static inline size_t count(const T&) { return 1; }
 
 // TODO: Specializations for dt/str/none
 template<class T, template<typename ...> class VT>
-types::GetLongType<T> 
+types::GetLongType<T>
 sum(const VT<T>& v) {
 	types::GetLongType<T> ret = 0;
 	for (const auto& _v : v)
@@ -31,8 +31,8 @@ double avg(const VT<T>& v) {
 
 template<class T, template<typename ...> class VT>
 VT<double> sqrt(const VT<T>& v) {
-	VT<double> ret {v.size};
-	for (uint32_t i = 0; i < v.size; ++i){
+	VT<double> ret{ v.size };
+	for (uint32_t i = 0; i < v.size; ++i) {
 		ret[i] = sqrt(v[i]);
 	}
 	return ret;
@@ -53,10 +53,10 @@ T min(const VT<T>& v) {
 	return min_v;
 }
 template<class T, template<typename ...> class VT>
-decayed_t<VT,T> mins(const VT<T>& arr) {
+decayed_t<VT, T> mins(const VT<T>& arr) {
 	const uint32_t& len = arr.size;
 	std::deque<std::pair<T, uint32_t>> cache;
-	decayed_t<VT,T> ret(len);
+	decayed_t<VT, T> ret(len);
 	T min = std::numeric_limits<T>::max();
 	for (int i = 0; i < len; ++i) {
 		if (arr[i] < min)
@@ -66,9 +66,9 @@ decayed_t<VT,T> mins(const VT<T>& arr) {
 	return ret;
 }
 template<class T, template<typename ...> class VT>
-decayed_t<VT,T> maxs(const VT<T>& arr) {
+decayed_t<VT, T> maxs(const VT<T>& arr) {
 	const uint32_t& len = arr.size;
-	decayed_t<VT,T> ret(len);
+	decayed_t<VT, T> ret(len);
 	T max = std::numeric_limits<T>::min();
 	for (int i = 0; i < len; ++i) {
 		if (arr[i] > max)
@@ -79,9 +79,9 @@ decayed_t<VT,T> maxs(const VT<T>& arr) {
 }
 
 template<class T, template<typename ...> class VT>
-decayed_t<VT,T> minw(uint32_t w, const VT<T>& arr) {
+decayed_t<VT, T> minw(uint32_t w, const VT<T>& arr) {
 	const uint32_t& len = arr.size;
-	decayed_t<VT,T> ret{len};
+	decayed_t<VT, T> ret{ len };
 	std::deque<std::pair<T, uint32_t>> cache;
 	for (int i = 0; i < len; ++i) {
 		if (!cache.empty() && cache.front().second == i - w) cache.pop_front();
@@ -93,7 +93,7 @@ decayed_t<VT,T> minw(uint32_t w, const VT<T>& arr) {
 }
 
 template<class T, template<typename ...> class VT>
-decayed_t<VT,T> maxw(uint32_t w, const VT<T>& arr) {
+decayed_t<VT, T> maxw(uint32_t w, const VT<T>& arr) {
 	const uint32_t& len = arr.size;
 	decayed_t<VT, T> ret(len);
 	std::deque<std::pair<T, uint32_t>> cache;
@@ -106,14 +106,27 @@ decayed_t<VT,T> maxw(uint32_t w, const VT<T>& arr) {
 	return ret;
 }
 
+template<class T, template<typename ...> class VT>
+decayed_t<VT, types::GetFPType<T>> ratios(const VT<T>& arr) {
+	uint32_t len = arr.size - 1;
+	if (!arr.size)
+		len = 1;
+	decayed_t<VT, types::GetFPType<T>> ret(len);
+	ret[0] = 0;
+
+	for (uint32_t i = 1; i < arr.size; ++i)
+		ret[i - 1] = arr[i] / arr[i - 1];
+	return ret;
+}
+
 template<class T, template<typename ...> class VT>
 decayed_t<VT, types::GetLongType<T>> sums(const VT<T>& arr) {
 	const uint32_t& len = arr.size;
 	decayed_t<VT, types::GetLongType<T>> ret(len);
 	uint32_t i = 0;
-	if(len) ret[i++] = arr[0];
-	for (; i < len; ++i) 
-		ret[i] = ret[i-1] + arr[i];
+	if (len) ret[i++] = arr[0];
+	for (; i < len; ++i)
+		ret[i] = ret[i - 1] + arr[i];
 	return ret;
 }
 template<class T, template<typename ...> class VT>
@@ -123,9 +136,9 @@ decayed_t<VT, types::GetFPType<types::GetLongType<T>>> avgs(const VT<T>& arr) {
 	decayed_t<VT, FPType> ret(len);
 	uint32_t i = 0;
 	types::GetLongType<T> s;
-	if(len) s = ret[i++] = arr[0];
-	for (; i < len; ++i) 
-		ret[i] = (s+=arr[i])/(FPType)(i+1);
+	if (len) s = ret[i++] = arr[0];
+	for (; i < len; ++i)
+		ret[i] = (s += arr[i]) / (FPType)(i + 1);
 	return ret;
 }
 template<class T, template<typename ...> class VT>
@@ -134,11 +147,11 @@ decayed_t<VT, types::GetLongType<T>> sumw(uint32_t w, const VT<T>& arr) {
 	decayed_t<VT, types::GetLongType<T>> ret(len);
 	uint32_t i = 0;
 	w = w > len ? len : w;
-	if(len) ret[i++] = arr[0];
-	for (; i < w; ++i) 
-		ret[i] = ret[i-1] + arr[i];
-	for (; i < len; ++i) 
-		ret[i] = ret[i-1] + arr[i] - arr[i-w];
+	if (len) ret[i++] = arr[0];
+	for (; i < w; ++i)
+		ret[i] = ret[i - 1] + arr[i];
+	for (; i < len; ++i)
+		ret[i] = ret[i - 1] + arr[i] - arr[i - w];
 	return ret;
 }
 template<class T, template<typename ...> class VT>
@@ -149,11 +162,11 @@ decayed_t<VT, types::GetFPType<types::GetLongType<T>>> avgw(uint32_t w, const VT
 	uint32_t i = 0;
 	types::GetLongType<T> s{};
 	w = w > len ? len : w;
-	if(len)	s = ret[i++] = arr[0];
-	for (; i < w; ++i) 
-		ret[i] = (s += arr[i])/(FPType)(i+1);
-	for (; i < len; ++i) 
-		ret[i] = ret[i-1] + (arr[i] - arr[i-w])/(FPType)w;
+	if (len)	s = ret[i++] = arr[0];
+	for (; i < w; ++i)
+		ret[i] = (s += arr[i]) / (FPType)(i + 1);
+	for (; i < len; ++i)
+		ret[i] = ret[i - 1] + (arr[i] - arr[i - w]) / (FPType)w;
 	return ret;
 }
 
@@ -163,18 +176,29 @@ decayed_t<VT, T> deltas(const VT<T>& arr) {
 	const uint32_t& len = arr.size;
 	decayed_t<VT, T> ret(len);
 	uint32_t i = 0;
-	if(len) ret[i++] = 0;
-	for (; i < len; ++i) 
-		ret[i] = arr[i] - arr[i-1];
+	if (len) ret[i++] = 0;
+	for (; i < len; ++i)
+		ret[i] = arr[i] - arr[i - 1];
 	return ret;
 }
 
 template<class T, template<typename ...> class VT>
 T last(const VT<T>& arr) {
+	if (!arr.size) return 0;
 	const uint32_t& len = arr.size;
 	return arr[arr.size - 1];
 }
 
+template<class T, template<typename ...> class VT>
+T first(const VT<T>& arr) {
+	if (!arr.size) return 0;
+	const uint32_t& len = arr.size;
+	return arr[0];
+}
+
+#define __DEFAULT_AGGREGATE_FUNCTION__(NAME, RET) \
+template <class T> constexpr inline T NAME(const T& v) { return RET; }
+
 // wrong behavior with count(0)
 template <class T> constexpr inline T count(const T& v) { return 1; }
 template <class T> constexpr inline T max(const T& v) { return v; }
@@ -191,3 +215,4 @@ template <class T> constexpr inline T avgs(const T& v) { return v; }
 template <class T> constexpr inline T sums(const T& v) { return v; }
 template <class T> constexpr inline T last(const T& v) { return v; }
 template <class T> constexpr inline T daltas(const T& v) { return 0; }
+template <class T> constexpr inline T ratios(const T& v) { return 1; }
diff --git a/server/server.cpp b/server/server.cpp
index c92d25a..b10ca80 100644
--- a/server/server.cpp
+++ b/server/server.cpp
@@ -320,35 +320,44 @@ int test_main()
     Server* server = reinterpret_cast<Server*>(cxt->alt_server);
 
     const char* qs[]= {
-        "CREATE TABLE test1(a INT, b INT, c INT, d INT);",
-        "COPY OFFSET 2 INTO test1 FROM  'w:/gg/AQuery++/data/test.csv'  ON SERVER    USING DELIMITERS  ',';",
-        "SELECT sum(a), b, d, c  FROM test1 GROUP BY c, b, d  ORDER BY b ;",
+        "QCREATE TABLE trade(stocksymbol INT, time INT, quantity INT, price INT);",
+        "QCOPY OFFSET 2 INTO trade FROM  'w:/gg/AQuery++/data/trade_numerical.csv'  ON SERVER    USING DELIMITERS  ',';",
+        "QSELECT stocksymbol, (SUM((quantity * price)) / SUM(quantity)) AS weighted_average  FROM trade GROUP BY stocksymbol  ;",
+        "Pdll_5lYrMY",
+        "QSELECT stocksymbol, price  FROM trade ORDER BY time  ;",
+        "Pdll_4Sg6Ri",
+        "QSELECT stocksymbol, quantity, price  FROM trade ORDER BY time  ;",
+        "Pdll_5h4kL2",
+        "QSELECT stocksymbol, price  FROM trade ORDER BY time  ;",
+        "Pdll_7tEWCO",
+        "QSELECT query_c.weighted_moving_averages, query_c.stocksymbol  FROM query_c;",
+        "Pdll_7FCPnF"
     };
     n_recv = sizeof(qs)/(sizeof (char*));
 	n_recvd = const_cast<char**>(qs);
-    if (n_recv > 0) {
-        for (int i = 0; i < n_recv; ++i)
-        {
-            server->exec(n_recvd[i]);
-            printf("Exec Q%d: %s\n", i, n_recvd[i]);
-        }
-        n_recv = 0;
-    }
+            void* handle = 0;
+                    handle = dlopen("./dll.so", RTLD_LAZY);
+                    cxt->init_session();
+                    for (int i = 0; i < n_recv; ++i)
+                    {
+                        //printf("%s, %d\n", n_recvd[i], n_recvd[i][0] == 'Q');
+                        switch (n_recvd[i][0]) {
+                        case 'Q': // SQL query for monetdbe
+                        {
+                            server->exec(n_recvd[i] + 1);
+                            printf("Exec Q%d: %s\n", i, n_recvd[i]);
+                        }
+                        break;
+                        case 'P': // Postprocessing procedure 
+                            if (handle && !server->haserror()) {
+                                code_snippet c = reinterpret_cast<code_snippet>(dlsym(handle, n_recvd[i] + 1));
+                                c(cxt);
+                            }
+                            break;
+                        }
+                    }
+                    n_recv = 0;
 
-    cxt->log_level = LOG_INFO;
-    puts(cpp_17 ?"true":"false");
-    void* handle = dlopen("./dll.so", RTLD_LAZY);
-    cxt->log("handle: %p\n", handle);
-    if (handle) {
-        cxt->log("inner\n");
-        code_snippet c = reinterpret_cast<code_snippet>(dlsym(handle, "dll_C4nJZu"));
-        cxt->log("routine: %p\n", c);
-        if (c) {
-            cxt->log("inner\n");
-            cxt->log("return: %d\n", c(cxt));
-        }
-        dlclose(handle);
-    }
     //static_assert(std::is_same_v<decltype(fill_integer_array<5, 1>()), std::integer_sequence<bool, 1,1,1,1,1>>, "");
     
     return 0;
diff --git a/server/table.h b/server/table.h
index 1e07968..76f5fb0 100644
--- a/server/table.h
+++ b/server/table.h
@@ -34,13 +34,13 @@ std::ostream& operator<<(std::ostream& os, const VT<T>& v)
 }
 
 #ifdef __AQ__HAS__INT128__
-std::ostream& operator<<(std::ostream& os, __int128 & v);
-std::ostream& operator<<(std::ostream& os, __uint128_t & v);
+std::ostream& operator<<(std::ostream& os, __int128& v);
+std::ostream& operator<<(std::ostream& os, __uint128_t& v);
 #endif
 
-std::ostream& operator<<(std::ostream& os, types::date_t & v);
-std::ostream& operator<<(std::ostream& os, types::time_t & v);
-std::ostream& operator<<(std::ostream& os, types::timestamp_t & v);
+std::ostream& operator<<(std::ostream& os, types::date_t& v);
+std::ostream& operator<<(std::ostream& os, types::time_t& v);
+std::ostream& operator<<(std::ostream& os, types::timestamp_t& v);
 template<typename _Ty>
 class ColView;
 template<typename _Ty>
@@ -50,27 +50,27 @@ public:
 	typedef ColRef<_Ty> Decayed_t;
 	const char* name;
 	types::Type_t ty = types::Type_t::ERROR;
-	ColRef(const ColRef<_Ty>& vt) : vector_type<_Ty>(vt) {} 
+	ColRef(const ColRef<_Ty>& vt) : vector_type<_Ty>(vt) {}
 	ColRef(ColRef<_Ty>&& vt) : vector_type<_Ty>(std::move(vt)) {}
 	ColRef() : vector_type<_Ty>(0), name("") {}
 	ColRef(const uint32_t& size, const char* name = "") : vector_type<_Ty>(size), name(name) {}
 	ColRef(const char* name) : name(name) {}
 	ColRef(const uint32_t size, void* data, const char* name = "") : vector_type<_Ty>(size, data), name(name) {}
 	void init(const char* name = "") { ty = types::Types<_Ty>::getType();  this->size = this->capacity = 0; this->container = 0; this->name = name; }
-	void initfrom(uint32_t sz, void*container, const char* name = "") {
-		ty = types::Types<_Ty>::getType();  
+	void initfrom(uint32_t sz, void* container, const char* name = "") {
+		ty = types::Types<_Ty>::getType();
 		this->size = sz;
 		this->capacity = 0;
-		this->container = (_Ty*)container; 
-		this->name = name; 
+		this->container = (_Ty*)container;
+		this->name = name;
 	}
 	template<template <typename ...> class VT, typename T>
-	void initfrom(const VT<T>& v, const char* name = ""){
-		ty = types::Types<_Ty>::getType();  
+	void initfrom(const VT<T>& v, const char* name = "") {
+		ty = types::Types<_Ty>::getType();
 		this->size = v.size;
 		this->capacity = 0;
-		this->container = (_Ty*)(v.container); 
-		this->name = name; 
+		this->container = (_Ty*)(v.container);
+		this->name = name;
 	}
 	template <class T>
 	ColRef<_Ty>& operator =(ColRef<T>&& vt) {
@@ -86,7 +86,7 @@ public:
 	using vector_type<_Ty>::subvec;
 	using vector_type<_Ty>::subvec_memcpy;
 	using vector_type<_Ty>::subvec_deep;
-	ColRef<_Ty>& operator= (const _Ty& vt){
+	ColRef<_Ty>& operator= (const _Ty& vt) {
 		vector_type<_Ty>::operator=(vt);
 		return *this;
 	}
@@ -98,7 +98,7 @@ public:
 		vector_type<_Ty>::operator=(std::move(vt));
 		return *this;
 	}
-	ColView<_Ty> operator [](const vector_type<uint32_t>&idxs) const {
+	ColView<_Ty> operator [](const vector_type<uint32_t>& idxs) const {
 		return ColView<_Ty>(*this, idxs);
 	}
 
@@ -117,12 +117,12 @@ public:
 				std::cout << this->operator[](i) << sep;
 			std::cout << this->operator[](i);
 		}
-		std::cout<< more;
+		std::cout << more;
 		std::cout << ')';
 	}
 	template<typename T>
 	ColRef<T> scast();
-	
+
 	ColRef<_Ty>* rename(const char* name) {
 		this->name = name;
 		return this;
@@ -130,14 +130,14 @@ public:
 
 	// defined in table_ext_monetdb.hpp
 	void* monetdb_get_col();
-	
+
 };
 template<>
-class ColRef<void> : public ColRef<int>{};
+class ColRef<void> : public ColRef<int> {};
 
 template<typename _Ty>
 class ColView {
-public: 
+public:
 	typedef ColRef<_Ty> Decayed_t;
 	const uint32_t size;
 	const ColRef<_Ty> orig;
@@ -145,7 +145,7 @@ public:
 	ColView(const ColRef<_Ty>& orig, vector_type<uint32_t>&& idxs) : orig(orig), size(idxs.size), idxs(std::move(idxs)) {}
 	ColView(const ColRef<_Ty>& orig, const vector_type<uint32_t>& idxs) : orig(orig), idxs(idxs), size(idxs.size) {}
 	ColView(const ColView<_Ty>& orig, const vector_type<uint32_t>& idxs) : orig(orig.orig), idxs(idxs), size(idxs.size) {
-		for (uint32_t i = 0; i < size; ++i) 
+		for (uint32_t i = 0; i < size; ++i)
 			idxs[i] = orig.idxs[idxs[i]];
 	}
 	_Ty& operator [](const uint32_t& i) const {
@@ -177,9 +177,9 @@ public:
 	}
 	void out(uint32_t n = 4, const char* sep = " ") const {
 		n = n > size ? size : n;
-		std::cout<<'(';
-		for (uint32_t i = 0; i < n; ++i) 
-			std::cout << this->operator[](i)<< sep;
+		std::cout << '(';
+		for (uint32_t i = 0; i < n; ++i)
+			std::cout << this->operator[](i) << sep;
 		std::cout << ')';
 	}
 	operator ColRef<_Ty>() {
@@ -192,7 +192,7 @@ public:
 		uint32_t len = end - start;
 		return ColView<_Ty>(orig, idxs.subvec(start, end));
 	}
-	ColRef<_Ty> subvec_deep(uint32_t start, uint32_t end) const{
+	ColRef<_Ty> subvec_deep(uint32_t start, uint32_t end) const {
 		uint32_t len = end - start;
 		ColRef<_Ty> subvec(len);
 		for (uint32_t i = 0; i < len; ++i)
@@ -202,10 +202,10 @@ public:
 	std::unordered_set<_Ty> distinct_common() {
 		return std::unordered_set<_Ty> {begin(), end()};
 	}
-	uint32_t distinct_size(){
+	uint32_t distinct_size() {
 		return distinct_common().size();
 	}
-	ColRef<_Ty> distinct(){
+	ColRef<_Ty> distinct() {
 		auto set = distinct_common();
 		ColRef<_Ty> ret(set.size());
 		uint32_t i = 0;
@@ -235,8 +235,8 @@ template <long long _Index, bool order = true, class... _Types>
 constexpr inline auto& get(const TableInfo<_Types...>& table) noexcept {
 	if constexpr (order)
 		return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.colrefs[_Index]);
-	else 
-		return *(ColRef<std::tuple_element_t<-1-_Index, std::tuple<_Types...>>> *) & (table.colrefs[-1-_Index]);
+	else
+		return *(ColRef<std::tuple_element_t<-1 - _Index, std::tuple<_Types...>>> *) & (table.colrefs[-1 - _Index]);
 }
 
 template <long long _Index, class... _Types>
@@ -267,7 +267,7 @@ struct TableInfo {
 		TableInfo<Types...>* this_table;
 		TableInfo<Types2...>* table;
 		vector_type<uint32_t> rid;
-		constexpr lineage_t(TableInfo<Types...>*this_table, TableInfo<Types2...> *table) 
+		constexpr lineage_t(TableInfo<Types...>* this_table, TableInfo<Types2...>* table)
 			: this_table(this_table), table(table), rid(0) {}
 		constexpr lineage_t() : this_table(0), table(0), rid(0) {}
 
@@ -279,12 +279,12 @@ struct TableInfo {
 			rid.emplace_back(v);
 		}
 	};
-	
+
 	template<class ...Types2>
 	auto bind(TableInfo<Types2...>* table2) {
 		return lineage_t(this, table2);
 	}
-	
+
 	template <size_t i = 0>
 	auto& get_col() {
 		return *reinterpret_cast<ColRef<std::tuple_element_t <i, tuple_type>>*>(colrefs + i);
@@ -293,30 +293,30 @@ struct TableInfo {
 	template <size_t j = 0>
 	typename std::enable_if<j == sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
 	template <size_t j = 0>
-	typename std::enable_if<j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
+	typename std::enable_if < j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
 	template <size_t ...Idxs>
 	struct GetTypes {
 		typedef typename std::tuple<typename std::tuple_element<Idxs, tuple_type>::type ...> type;
 	};
-	
+
 	template <size_t ...Idxs>
 	using getRecordType = typename GetTypes<Idxs...>::type;
 	TableInfo(const char* name, uint32_t n_cols);
-	TableInfo(const char* name = "", const char **col_names = nullptr);
+	TableInfo(const char* name = "", const char** col_names = nullptr);
 	template <int prog = 0>
 	inline void materialize(const vector_type<uint32_t>& idxs, TableInfo<Types...>* tbl = nullptr) { // inplace materialize
-		if constexpr(prog == 0) tbl = (tbl == 0 ? this : tbl);
+		if constexpr (prog == 0) tbl = (tbl == 0 ? this : tbl);
 		if constexpr (prog == sizeof...(Types)) return;
 		else {
 			auto& col = get<prog>(*this);
-			auto new_col = decays<decltype(col)>{idxs.size};
-			for(uint32_t i = 0; i < idxs.size; ++i)
+			auto new_col = decays<decltype(col)>{ idxs.size };
+			for (uint32_t i = 0; i < idxs.size; ++i)
 				new_col[i] = col[idxs[i]];
 			get<prog>(*tbl) = new_col;
 			materialize<prog + 1>(idxs, tbl);
 		}
 	}
-	inline TableInfo<Types...>* materialize_copy(const vector_type<uint32_t>& idxs) { 
+	inline TableInfo<Types...>* materialize_copy(const vector_type<uint32_t>& idxs) {
 		auto tbl = new TableInfo<Types...>(this->name, sizeof...(Types));
 		materialize<0>(idxs, tbl);
 		return tbl;
@@ -337,16 +337,16 @@ struct TableInfo {
 		return ord;
 	}
 	template <int ...cols>
-	auto order_by_view () {
+	auto order_by_view() {
 		return TableView<Types...>(order_by<cols...>(), *this);
 	}
 
 	// Print 2 -- generate printf string first, supports flattening, supports sprintf/printf/fprintf
-	template <int col, int ...rem_cols, class Fn, class ...__Types> 
+	template <int col, int ...rem_cols, class Fn, class ...__Types>
 	inline void print2_impl(Fn func, const uint32_t& i, const __Types& ... args) const {
 		using this_type = typename std::tuple_element<col, tuple_type>::type;
 		const auto& this_value = get<col>(*this)[i];
-		const auto& next = [&](auto &v) {
+		const auto& next = [&](auto& v) {
 			if constexpr (sizeof...(rem_cols) == 0)
 				func(args..., print_hook(v));
 			else
@@ -358,7 +358,7 @@ struct TableInfo {
 		else
 			next(this_value);
 	}
-	std::string get_header_string(const char* __restrict sep, const char* __restrict end) const{
+	std::string get_header_string(const char* __restrict sep, const char* __restrict end) const {
 		std::string header_string = std::string();
 		for (uint32_t i = 0; i < sizeof...(Types); ++i)
 			header_string += std::string(this->colrefs[i].name) + sep + '|' + sep;
@@ -371,17 +371,17 @@ struct TableInfo {
 	template <int ...cols>
 	void print2(const char* __restrict sep = ",", const char* __restrict end = "\n",
 		const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) const {
-		
+
 		std::string printf_string =
 			generate_printf_string<typename std::tuple_element<cols, tuple_type>::type ...>(sep, end);
 		std::string header_string = std::string();
 		constexpr static int a_cols[] = { cols... };
-		for(int i = 0; i < sizeof...(cols); ++i)
+		for (int i = 0; i < sizeof...(cols); ++i)
 			header_string += std::string(this->colrefs[a_cols[i]].name) + sep;
 		const size_t l_sep = strlen(sep);
-		if(header_string.size() - l_sep >= 0)
+		if (header_string.size() - l_sep >= 0)
 			header_string.resize(header_string.size() - l_sep);
-		
+
 		const auto& prt_loop = [&fp, &view, &printf_string, *this](const auto& f) {
 #ifdef __AQ__HAS__INT128__			
 			constexpr auto num_hge = count_type<__int128_t, __uint128_t>((tuple_type*)(0));
@@ -391,20 +391,21 @@ struct TableInfo {
 			constexpr auto num_date = count_type<types::date_t>((tuple_type*)(0));
 			constexpr auto num_time = count_type<types::time_t>((tuple_type*)(0));
 			constexpr auto num_timestamp = count_type<types::timestamp_t>((tuple_type*)(0));
-			char cbuf[ num_hge * 41 
-				+ num_time * types::time_t::string_length() 
-				+ num_date * types::date_t::string_length() 
-				+ num_timestamp * types::timestamp_t::string_length() 
+			char cbuf[num_hge * 41
+				+ num_time * types::time_t::string_length()
+				+ num_date * types::date_t::string_length()
+				+ num_timestamp * types::timestamp_t::string_length()
+				+ 1
 			];
 			setgbuf(cbuf);
-			if(view)
-				for (uint32_t i = 0; i < view->size; ++i){
+			if (view)
+				for (uint32_t i = 0; i < view->size; ++i) {
 					print2_impl<cols...>(f, (*view)[i], printf_string.c_str());
 					setgbuf();
 				}
 			else
-				for (uint32_t i = 0; i < colrefs[0].size; ++i){
-					print2_impl<cols...>(f, i, printf_string.c_str());		
+				for (uint32_t i = 0; i < colrefs[0].size; ++i) {
+					print2_impl<cols...>(f, i, printf_string.c_str());
 					setgbuf();
 				}
 		};
@@ -420,10 +421,13 @@ struct TableInfo {
 		}
 	}
 	template <int ...vals> struct applier {
-	inline constexpr static void apply(const TableInfo<Types...>& t, const char* __restrict sep = ",", const char* __restrict end = "\n",
-		const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr)
-	{ t.template print2<vals ...>(sep, end, view, fp); }};
-	
+		inline constexpr static void apply(const TableInfo<Types...>& t, const char* __restrict sep = ",", const char* __restrict end = "\n",
+			const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr)
+		{
+			t.template print2<vals ...>(sep, end, view, fp);
+		}
+	};
+
 	inline void printall(const char* __restrict sep = ",", const char* __restrict end = "\n",
 		const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) {
 		applyIntegerSequence<sizeof...(Types), applier>::apply(*this, sep, end, view, fp);
@@ -433,33 +437,33 @@ struct TableInfo {
 		this->name = name;
 		return this;
 	}
-	template <size_t ...Is> 
+	template <size_t ...Is>
 	void inline
-	reserve(std::index_sequence<Is...>, uint32_t size) {
-		const auto& assign_sz = [&size](auto& col){ 
+		reserve(std::index_sequence<Is...>, uint32_t size) {
+		const auto& assign_sz = [&size](auto& col) {
 			col.size = size;
 			col.grow();
 		};
 		(assign_sz(get_col<Is>()), ...);
 	}
-	template <size_t ...Is> 
-	decltype(auto) inline 
-	get_record(std::index_sequence<Is...>, uint32_t i) {
+	template <size_t ...Is>
+	decltype(auto) inline
+		get_record(std::index_sequence<Is...>, uint32_t i) {
 		return std::forward_as_tuple(get_col<Is>()[i] ...);
 	}
-	template <size_t ...Is> 
-	void inline 
-	set_record(std::index_sequence<Is...>, const tuple_type& t, uint32_t i) {
-		const auto& assign_field = 
-			[](auto& l, const auto& r){
-				l = r;
-			};
+	template <size_t ...Is>
+	void inline
+		set_record(std::index_sequence<Is...>, const tuple_type& t, uint32_t i) {
+		const auto& assign_field =
+			[](auto& l, const auto& r) {
+			l = r;
+		};
 		(assign_field(get_col<Is>()[i], std::get<Is>(t)), ...);
 	}
 	TableInfo<Types ...>* distinct() {
 		std::unordered_set<tuple_type> d_records;
 		std::make_index_sequence<sizeof...(Types)> seq;
-		
+
 		for (uint32_t j = 0; j < colrefs[0].size; ++j) {
 			d_records.insert(get_record(seq, j));
 		}
@@ -486,20 +490,20 @@ struct TableView {
 	typename std::enable_if<j == sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
 	template <size_t j = 0>
 	typename std::enable_if < j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
-	
-	template <size_t ...Is> 
-	decltype(auto) inline 
-	get_record(std::index_sequence<Is...>, uint32_t i) {
+
+	template <size_t ...Is>
+	decltype(auto) inline
+		get_record(std::index_sequence<Is...>, uint32_t i) {
 		return std::forward_as_tuple(info.template get_col<Is>()[idxs[i]] ...);
 	}
-	
+
 	TableInfo<Types ...>* get_tableinfo(const char* name = nullptr, const char** names = nullptr) {
-		if (name == nullptr) 
+		if (name == nullptr)
 			name = info.name;
 
 		const char* info_names[sizeof...(Types)];
 		if (name == nullptr) {
-			for(uint32_t i = 0; i < sizeof...(Types); ++i) 
+			for (uint32_t i = 0; i < sizeof...(Types); ++i)
 				info_names[i] = info.colrefs[i].name;
 			names = info_names;
 		}
@@ -520,7 +524,7 @@ struct TableView {
 	TableInfo<Types ...>* distinct(const char* name = nullptr, const char** names = nullptr) {
 		std::unordered_set<tuple_type> d_records;
 		std::make_index_sequence<sizeof...(Types)> seq;
-		
+
 		for (uint32_t j = 0; j < idxs->size; ++j) {
 			d_records.insert(get_record(seq, j));
 		}
@@ -559,7 +563,7 @@ template<class ...Types>
 TableInfo<Types...>::TableInfo(const char* name, const char** col_names) : name(name), n_cols(sizeof...(Types)) {
 	this->colrefs = (ColRef<void>*)malloc(sizeof(ColRef<void>) * this->n_cols);
 	for (uint32_t i = 0; i < n_cols; ++i) {
-		this->colrefs[i].init(col_names? col_names[i] : "");
+		this->colrefs[i].init(col_names ? col_names[i] : "");
 	}
 }
 template <class ...Types>
@@ -582,7 +586,7 @@ template<class ...Types>
 inline void TableView<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
 	std::string header_string = info.get_header_string(sep, end);
 	std::cout << header_string.c_str();
-	
+
 	uint32_t n_rows = 0;
 	if (info.colrefs[0].size > 0)
 		n_rows = info.colrefs[0].size;
@@ -594,25 +598,25 @@ inline void TableView<Types...>::print(const char* __restrict sep, const char* _
 template <class ...Types>
 template <size_t j>
 inline typename std::enable_if<j == sizeof...(Types) - 1, void>::type
-	TableInfo<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
+TableInfo<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
 	std::cout << (get<j>(*this))[i];
 }
 
 template<class ...Types>
 template<size_t j>
-inline typename std::enable_if<j < sizeof...(Types) - 1, void>::type 
+inline typename std::enable_if < j < sizeof...(Types) - 1, void>::type
 	TableInfo<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
 {
 	std::cout << (get<j>(*this))[i] << sep;
-	print_impl<j+1>(i, sep);
+	print_impl<j + 1>(i, sep);
 }
 
 template<class ...Types>
 inline void TableInfo<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
-	
+
 	std::string header_string = get_header_string(sep, end);
 	std::cout << header_string.c_str();
-	
+
 	uint32_t n_rows = 0;
 	if (n_cols > 0 && colrefs[0].size > 0)
 		n_rows = colrefs[0].size;
@@ -740,7 +744,7 @@ void print(const TableView<Types...>& v, const char* delimiter = " ", const char
 }
 template <class T>
 void print(const T& v, const char* delimiter = " ") {
-	std::cout<< v<< delimiter;
+	std::cout << v << delimiter;
 	// printf(types::printf_str[types::Types<T>::getType()], v);
 }
 
@@ -748,10 +752,10 @@ void print(const T& v, const char* delimiter = " ") {
 template <>
 void print<__int128_t>(const __int128_t& v, const char* delimiter);
 template <>
-void print<__uint128_t>(const __uint128_t&v, const char* delimiter);
+void print<__uint128_t>(const __uint128_t& v, const char* delimiter);
 #endif
 template <>
-void print<bool>(const bool&v, const char* delimiter);
+void print<bool>(const bool& v, const char* delimiter);
 
 template <class T>
 void inline print_impl(const T& v, const char* delimiter, const char* endline) {
@@ -765,10 +769,10 @@ void inline print_impl(const T& v, const char* delimiter, const char* endline) {
 }
 
 template <class T, template<typename> class VT>
-typename std::enable_if<!std::is_same<VT<T>, TableInfo<T>>::value>::type 
+typename std::enable_if<!std::is_same<VT<T>, TableInfo<T>>::value>::type
 print(const VT<T>& v, const char* delimiter = " ", const char* endline = "\n") {
 	print_impl(v, delimiter, endline);
 }
- 
+
 
 #endif
diff --git a/server/types.h b/server/types.h
index d4a5656..8aa13ca 100644
--- a/server/types.h
+++ b/server/types.h
@@ -29,22 +29,22 @@ namespace types {
 	static constexpr const char* printf_str[] = { "%d", "%f", "%s", "%lf", "%Lf", "%ld", "%d", "%hi", "%s", "%s", "%c",
 		"%u", "%lu", "%s", "%hu", "%hhu", "%s", "%s", "Vector<%s>", "%s", "NULL", "ERROR" };
 	static constexpr const char* SQL_Type[] = { "INT", "REAL", "TEXT", "DOUBLE", "DOUBLE", "BIGINT", "HUGEINT", "SMALLINT", "DATE", "TIME", "TINYINT",
-		"INT", "BIGINT", "HUGEINT", "SMALLINT", "TINYINT", "BIGINT", "BOOL", "BIGINT", "TIMESTAMP", "NULL", "ERROR"};
-	
-	
+		"INT", "BIGINT", "HUGEINT", "SMALLINT", "TINYINT", "BOOL", "BLOB", "TIMESTAMP", "NULL", "ERROR" };
+
+
 	// TODO: deal with data/time <=> str/uint conversion
-	struct date_t{
+	struct date_t {
 		unsigned char day = 0;
 		unsigned char month = 0;
 		short year = 0;
 
 		date_t() = default;
-		date_t(unsigned char day, unsigned char month, short year) : 
-			day (day), month (month), year(year) {}
+		date_t(unsigned char day, unsigned char month, short year) :
+			day(day), month(month), year(year) {}
 		date_t(const char*);
 		date_t& fromString(const char*);
 		bool validate() const;
-		constexpr static unsigned string_length(){
+		constexpr static unsigned string_length() {
 			return 11;
 		};
 		char* toString(char* buf) const;
@@ -56,16 +56,16 @@ namespace types {
 		bool operator != (const date_t&) const;
 	};
 
-	struct time_t{
+	struct time_t {
 		unsigned int ms = 0;
 		unsigned char seconds = 0;
 		unsigned char minutes = 0;
 		unsigned char hours = 0;
 
-		time_t() = default; 
-		time_t(unsigned int ms, unsigned char seconds, unsigned char minutes, unsigned char hours) : 
-			ms (ms), seconds (seconds), minutes(minutes), hours(hours) {}; 
-		time_t(const char*); 
+		time_t() = default;
+		time_t(unsigned int ms, unsigned char seconds, unsigned char minutes, unsigned char hours) :
+			ms(ms), seconds(seconds), minutes(minutes), hours(hours) {};
+		time_t(const char*);
 		time_t& fromString(const char*);
 		bool validate() const;
 		constexpr static unsigned string_length() {
@@ -79,15 +79,15 @@ namespace types {
 		bool operator == (const time_t&) const;
 		bool operator != (const time_t&) const;
 	};
-	struct timestamp_t{
+	struct timestamp_t {
 		date_t date;
 		time_t time;
 		timestamp_t() = default;
 		timestamp_t(const date_t& d, const time_t& t) : date(d), time(t) {}
-		timestamp_t(const char*); 
+		timestamp_t(const char*);
 		timestamp_t& fromString(const char*);
 		bool validate() const;
-		constexpr static unsigned string_length(){
+		constexpr static unsigned string_length() {
 			return date_t::string_length() + time_t::string_length();
 		};
 		char* toString(char* buf) const;
@@ -135,10 +135,10 @@ namespace types {
 		inline constexpr static Type_t getType() {
 #define	TypeConnect(x, y) if constexpr(std::is_same<x, T>::value) return y; else
 			ConnectTypes(TypeConnect)
-			if constexpr (is_vector_type<T>) 
-				return VECTOR;
-			else
-				return NONE;
+				if constexpr (is_vector_type<T>)
+					return VECTOR;
+				else
+					return NONE;
 		}
 	};
 #define ATypeSize(t, at) sizeof(t),
@@ -167,17 +167,51 @@ namespace types {
 	};
 	template<class T>
 	using GetLongType = typename GetLongTypeImpl<typename std::decay<T>::type>::type;
+
+
+	template<class T>
+	struct GetLongerTypeImpl {
+		using type = Cond(
+
+			__U(T), Cond(__Eq(char), unsigned short,
+				Cond(__Eq(short), unsigned int,
+					Cond(__Eq(int), unsigned long long,
+						ULL_Type
+					))),
+
+			Cond(Fp(T), double,
+
+				Cond(__Eq(char), short,
+					Cond(__Eq(short), int,
+						Cond(__Eq(int), long,
+							LL_Type
+						))))
+
+		);
+	};
+	template<class T>
+	using GetLongerType = typename GetLongerTypeImpl<typename std::decay<T>::type>::type;
 }
 
+
 struct astring_view {
 	const unsigned char* str = 0;
-	constexpr astring_view(const char* str) :
+
+#if defined(__clang__) || !defined(__GNUC__)
+	constexpr
+#endif
+		astring_view(const char* str) noexcept :
 		str((const unsigned char*)(str)) {}
-	constexpr astring_view(const signed char* str) :
+#if defined(__clang__) || !defined(__GNUC__)
+	constexpr
+#endif 
+		astring_view(const signed char* str) noexcept :
 		str((const unsigned char*)(str)) {}
-	constexpr astring_view(const unsigned char* str) :
+
+	constexpr
+		astring_view(const unsigned char* str) noexcept :
 		str(str) {}
-	constexpr astring_view() = default;
+	constexpr astring_view() noexcept = default;
 
 	bool operator==(const astring_view& r) const {
 		auto this_str = str;
@@ -190,8 +224,8 @@ struct astring_view {
 		}
 		return !(*this_str || *other_str);
 	}
-	bool operator >(const astring_view&r) const{
-		
+	bool operator >(const astring_view& r) const {
+
 	}
 	operator const char* () const {
 		return reinterpret_cast<const char*>(str);
@@ -200,7 +234,7 @@ struct astring_view {
 		return reinterpret_cast<const unsigned char*>(str);
 	}
 	operator const signed char* () const {
-		return reinterpret_cast<const signed  char*>(str);
+		return reinterpret_cast<const signed char*>(str);
 	}
 };
 
@@ -245,7 +279,7 @@ struct decayS {
 	using type = typename std::decay<T>::type;
 };
 template<template<typename ...> class T, typename ...Types>
-struct decayS <T<Types...>>{
+struct decayS <T<Types...>> {
 	using type = T<typename std::decay<Types>::type ...>;
 };
 template <class T>
@@ -284,7 +318,7 @@ using transValues = typename transValues_s<std::make_integer_sequence<vT, i>, vT
 template <int i, template <int ...> class rT>
 using applyIntegerSequence = typename transValues_s<std::make_integer_sequence<int, i>, int, rT>::type;
 template <template <class ...> class T, class ...Types>
-struct decayed_impl{ typedef T<Types...> type;};
+struct decayed_impl { typedef T<Types...> type; };
 template <template <typename ...> class VT, class ...Types>
 using decayed_t = typename decayed_impl<VT, Types...>::type;
 
@@ -324,19 +358,19 @@ template<>
 struct nullval_impl<double> { constexpr static double value = -std::numeric_limits<double>::quiet_NaN(); };
 
 constexpr size_t sum_type(size_t a[], size_t sz) {
-    size_t ret = 0;
-    for (int i = 0; i < sz; ++i) 
-        ret += a[i];
-    return ret;
+	size_t ret = 0;
+	for (int i = 0; i < sz; ++i)
+		ret += a[i];
+	return ret;
 }
-template<class Types, class ...T1> 
+template<class Types, class ...T1>
 constexpr size_t sum_type() {
-    size_t t[] = {std::is_same_v<Types, T1> ...};
-    return sum_type(t, sizeof...(T1));
+	size_t t[] = { std::is_same_v<Types, T1> ... };
+	return sum_type(t, sizeof...(T1));
 }
-template<class ...T1, class ...Types> 
+template<class ...T1, class ...Types>
 constexpr size_t count_type(std::tuple<Types...>* ts) {
-    size_t t[] = {sum_type<Types, T1...>() ...};
-    return sum_type(t, sizeof...(Types));
+	size_t t[] = { sum_type<Types, T1...>() ... };
+	return sum_type(t, sizeof...(Types));
 }
 #endif // !_TYPES_H