bill
/
AQuery
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/sunyinqi0508/AQuery2

Browse Source
dev
bill 2 years ago
parent c39ec80e1d
commit 10a7b7eafa
9 changed files with 274 additions and 200 deletions
Show Stats Download Patch File Download Diff File

14
build_instructions.txt
Unescape View File

@ -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'))

4
msc-plugin/libaquery.vcxproj
Unescape View File

@ -100,6 +100,8 @@
<PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile> <PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>$(ProjectDir)\..\monetdb\msvc</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>$(ProjectDir)\..\monetdb\msvc</AdditionalIncludeDirectories>
<PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile> <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
@ -161,6 +163,8 @@
<PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile> <PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile>
<AdditionalIncludeDirectories>$(ProjectDir)\..\monetdb\msvc</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>$(ProjectDir)\..\monetdb\msvc</AdditionalIncludeDirectories>
<PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile> <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>

2
msc-plugin/msc-plugin.vcxproj
Unescape View File

@ -108,6 +108,7 @@
<PrecompiledHeaderFile>./server/pch.hpp</PrecompiledHeaderFile> <PrecompiledHeaderFile>./server/pch.hpp</PrecompiledHeaderFile>
<PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile> <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
<MultiProcessorCompilation>true</MultiProcessorCompilation> <MultiProcessorCompilation>true</MultiProcessorCompilation>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
@ -178,6 +179,7 @@
<PrecompiledHeaderFile>./server/pch.hpp</PrecompiledHeaderFile> <PrecompiledHeaderFile>./server/pch.hpp</PrecompiledHeaderFile>
<PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile> <PrecompiledHeaderOutputFile>../libaquery.pch</PrecompiledHeaderOutputFile>
<MultiProcessorCompilation>true</MultiProcessorCompilation> <MultiProcessorCompilation>true</MultiProcessorCompilation>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>

4
msc-plugin/sdk_example.vcxproj
Unescape View File

@ -98,6 +98,8 @@
<ConformanceMode>true</ConformanceMode> <ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard> <LanguageStandard>stdcpplatest</LanguageStandard>
<LanguageStandard_C>stdc17</LanguageStandard_C> <LanguageStandard_C>stdc17</LanguageStandard_C>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
@ -130,6 +132,8 @@
<ConformanceMode>true</ConformanceMode> <ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard> <LanguageStandard>stdcpplatest</LanguageStandard>
<LanguageStandard_C>stdc17</LanguageStandard_C> <LanguageStandard_C>stdc17</LanguageStandard_C>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>

6
sdk/aquery.h
Unescape View File

@ -75,7 +75,13 @@ extern void register_memory(void* ptr, deallocator_t deallocator);
__AQEXPORT__(void) init_session(Context* cxt); __AQEXPORT__(void) init_session(Context* cxt);
#define __AQ_NO_SESSION__ __AQEXPORT__(void) init_session(Context*) {} #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); void* memcpy(void*, const void*, unsigned long long);
#endif
struct ColRef_storage { struct ColRef_storage {
void* container; void* container;
unsigned int capacity, size; unsigned int capacity, size;

83
server/aggregations.h
Unescape View File

@ -16,7 +16,7 @@ constexpr static inline size_t count(const T&) { return 1; }
// TODO: Specializations for dt/str/none // TODO: Specializations for dt/str/none
template<class T, template<typename ...> class VT> template<class T, template<typename ...> class VT>
types::GetLongType<T> types::GetLongType<T>
sum(const VT<T>& v) { sum(const VT<T>& v) {
types::GetLongType<T> ret = 0; types::GetLongType<T> ret = 0;
for (const auto& _v : v) for (const auto& _v : v)
@ -31,8 +31,8 @@ double avg(const VT<T>& v) {
template<class T, template<typename ...> class VT> template<class T, template<typename ...> class VT>
VT<double> sqrt(const VT<T>& v) { VT<double> sqrt(const VT<T>& v) {
VT<double> ret {v.size}; VT<double> ret{ v.size };
for (uint32_t i = 0; i < v.size; ++i){ for (uint32_t i = 0; i < v.size; ++i) {
ret[i] = sqrt(v[i]); ret[i] = sqrt(v[i]);
} }
return ret; return ret;
@ -53,10 +53,10 @@ T min(const VT<T>& v) {
return min_v; return min_v;
} }
template<class T, template<typename ...> class VT> 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; const uint32_t& len = arr.size;
std::deque<std::pair<T, uint32_t>> cache; 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(); T min = std::numeric_limits<T>::max();
for (int i = 0; i < len; ++i) { for (int i = 0; i < len; ++i) {
if (arr[i] < min) if (arr[i] < min)
@ -66,9 +66,9 @@ decayed_t<VT,T> mins(const VT<T>& arr) {
return ret; return ret;
} }
template<class T, template<typename ...> class VT> 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; 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(); T max = std::numeric_limits<T>::min();
for (int i = 0; i < len; ++i) { for (int i = 0; i < len; ++i) {
if (arr[i] > max) if (arr[i] > max)
@ -79,9 +79,9 @@ decayed_t<VT,T> maxs(const VT<T>& arr) {
} }
template<class T, template<typename ...> class VT> 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; 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; std::deque<std::pair<T, uint32_t>> cache;
for (int i = 0; i < len; ++i) { for (int i = 0; i < len; ++i) {
if (!cache.empty() && cache.front().second == i - w) cache.pop_front(); 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> 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; 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; 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; 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> template<class T, template<typename ...> class VT>
decayed_t<VT, types::GetLongType<T>> sums(const VT<T>& arr) { decayed_t<VT, types::GetLongType<T>> sums(const VT<T>& arr) {
const uint32_t& len = arr.size; const uint32_t& len = arr.size;
decayed_t<VT, types::GetLongType<T>> ret(len); decayed_t<VT, types::GetLongType<T>> ret(len);
uint32_t i = 0; uint32_t i = 0;
if(len) ret[i++] = arr[0]; if (len) ret[i++] = arr[0];
for (; i < len; ++i) for (; i < len; ++i)
ret[i] = ret[i-1] + arr[i]; ret[i] = ret[i - 1] + arr[i];
return ret; return ret;
} }
template<class T, template<typename ...> class VT> 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); decayed_t<VT, FPType> ret(len);
uint32_t i = 0; uint32_t i = 0;
types::GetLongType<T> s; types::GetLongType<T> s;
if(len) s = ret[i++] = arr[0]; if (len) s = ret[i++] = arr[0];
for (; i < len; ++i) for (; i < len; ++i)
ret[i] = (s+=arr[i])/(FPType)(i+1); ret[i] = (s += arr[i]) / (FPType)(i + 1);
return ret; return ret;
} }
template<class T, template<typename ...> class VT> 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); decayed_t<VT, types::GetLongType<T>> ret(len);
uint32_t i = 0; uint32_t i = 0;
w = w > len ? len : w; w = w > len ? len : w;
if(len) ret[i++] = arr[0]; if (len) ret[i++] = arr[0];
for (; i < w; ++i) for (; i < w; ++i)
ret[i] = ret[i-1] + arr[i]; ret[i] = ret[i - 1] + arr[i];
for (; i < len; ++i) for (; i < len; ++i)
ret[i] = ret[i-1] + arr[i] - arr[i-w]; ret[i] = ret[i - 1] + arr[i] - arr[i - w];
return ret; return ret;
} }
template<class T, template<typename ...> class VT> 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; uint32_t i = 0;
types::GetLongType<T> s{}; types::GetLongType<T> s{};
w = w > len ? len : w; w = w > len ? len : w;
if(len) s = ret[i++] = arr[0]; if (len) s = ret[i++] = arr[0];
for (; i < w; ++i) for (; i < w; ++i)
ret[i] = (s += arr[i])/(FPType)(i+1); ret[i] = (s += arr[i]) / (FPType)(i + 1);
for (; i < len; ++i) for (; i < len; ++i)
ret[i] = ret[i-1] + (arr[i] - arr[i-w])/(FPType)w; ret[i] = ret[i - 1] + (arr[i] - arr[i - w]) / (FPType)w;
return ret; return ret;
} }
@ -163,18 +176,29 @@ decayed_t<VT, T> deltas(const VT<T>& arr) {
const uint32_t& len = arr.size; const uint32_t& len = arr.size;
decayed_t<VT, T> ret(len); decayed_t<VT, T> ret(len);
uint32_t i = 0; uint32_t i = 0;
if(len) ret[i++] = 0; if (len) ret[i++] = 0;
for (; i < len; ++i) for (; i < len; ++i)
ret[i] = arr[i] - arr[i-1]; ret[i] = arr[i] - arr[i - 1];
return ret; return ret;
} }
template<class T, template<typename ...> class VT> template<class T, template<typename ...> class VT>
T last(const VT<T>& arr) { T last(const VT<T>& arr) {
if (!arr.size) return 0;
const uint32_t& len = arr.size; const uint32_t& len = arr.size;
return arr[arr.size - 1]; 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) // wrong behavior with count(0)
template <class T> constexpr inline T count(const T& v) { return 1; } template <class T> constexpr inline T count(const T& v) { return 1; }
template <class T> constexpr inline T max(const T& v) { return v; } 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 sums(const T& v) { return v; }
template <class T> constexpr inline T last(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 daltas(const T& v) { return 0; }
template <class T> constexpr inline T ratios(const T& v) { return 1; }

59
server/server.cpp
Unescape View File

@ -320,35 +320,44 @@ int test_main()
Server* server = reinterpret_cast<Server*>(cxt->alt_server); Server* server = reinterpret_cast<Server*>(cxt->alt_server);
const char* qs[]= { const char* qs[]= {
"CREATE TABLE test1(a INT, b INT, c INT, d INT);", "QCREATE TABLE trade(stocksymbol INT, time INT, quantity INT, price INT);",
"COPY OFFSET 2 INTO test1 FROM 'w:/gg/AQuery++/data/test.csv' ON SERVER USING DELIMITERS ',';", "QCOPY OFFSET 2 INTO trade FROM 'w:/gg/AQuery++/data/trade_numerical.csv' ON SERVER USING DELIMITERS ',';",
"SELECT sum(a), b, d, c FROM test1 GROUP BY c, b, d ORDER BY b ;", "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_recv = sizeof(qs)/(sizeof (char*));
n_recvd = const_cast<char**>(qs); n_recvd = const_cast<char**>(qs);
if (n_recv > 0) { void* handle = 0;
for (int i = 0; i < n_recv; ++i) handle = dlopen("./dll.so", RTLD_LAZY);
{ cxt->init_session();
server->exec(n_recvd[i]); for (int i = 0; i < n_recv; ++i)
printf("Exec Q%d: %s\n", i, n_recvd[i]); {
} //printf("%s, %d\n", n_recvd[i], n_recvd[i][0] == 'Q');
n_recv = 0; 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>>, ""); //static_assert(std::is_same_v<decltype(fill_integer_array<5, 1>()), std::integer_sequence<bool, 1,1,1,1,1>>, "");
return 0; return 0;

192
server/table.h
Unescape View File

@ -34,13 +34,13 @@ std::ostream& operator<<(std::ostream& os, const VT<T>& v)
} }
#ifdef __AQ__HAS__INT128__ #ifdef __AQ__HAS__INT128__
std::ostream& operator<<(std::ostream& os, __int128 & v); std::ostream& operator<<(std::ostream& os, __int128& v);
std::ostream& operator<<(std::ostream& os, __uint128_t & v); std::ostream& operator<<(std::ostream& os, __uint128_t& v);
#endif #endif
std::ostream& operator<<(std::ostream& os, types::date_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::time_t& v);
std::ostream& operator<<(std::ostream& os, types::timestamp_t & v); std::ostream& operator<<(std::ostream& os, types::timestamp_t& v);
template<typename _Ty> template<typename _Ty>
class ColView; class ColView;
template<typename _Ty> template<typename _Ty>
@ -50,27 +50,27 @@ public:
typedef ColRef<_Ty> Decayed_t; typedef ColRef<_Ty> Decayed_t;
const char* name; const char* name;
types::Type_t ty = types::Type_t::ERROR; 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(ColRef<_Ty>&& vt) : vector_type<_Ty>(std::move(vt)) {}
ColRef() : vector_type<_Ty>(0), name("") {} ColRef() : vector_type<_Ty>(0), name("") {}
ColRef(const uint32_t& size, const char* name = "") : vector_type<_Ty>(size), name(name) {} ColRef(const uint32_t& size, const char* name = "") : vector_type<_Ty>(size), name(name) {}
ColRef(const char* name) : 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) {} 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 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 = "") { void initfrom(uint32_t sz, void* container, const char* name = "") {
ty = types::Types<_Ty>::getType(); ty = types::Types<_Ty>::getType();
this->size = sz; this->size = sz;
this->capacity = 0; this->capacity = 0;
this->container = (_Ty*)container; this->container = (_Ty*)container;
this->name = name; this->name = name;
} }
template<template <typename ...> class VT, typename T> template<template <typename ...> class VT, typename T>
void initfrom(const VT<T>& v, const char* name = ""){ void initfrom(const VT<T>& v, const char* name = "") {
ty = types::Types<_Ty>::getType(); ty = types::Types<_Ty>::getType();
this->size = v.size; this->size = v.size;
this->capacity = 0; this->capacity = 0;
this->container = (_Ty*)(v.container); this->container = (_Ty*)(v.container);
this->name = name; this->name = name;
} }
template <class T> template <class T>
ColRef<_Ty>& operator =(ColRef<T>&& vt) { ColRef<_Ty>& operator =(ColRef<T>&& vt) {
@ -86,7 +86,7 @@ public:
using vector_type<_Ty>::subvec; using vector_type<_Ty>::subvec;
using vector_type<_Ty>::subvec_memcpy; using vector_type<_Ty>::subvec_memcpy;
using vector_type<_Ty>::subvec_deep; using vector_type<_Ty>::subvec_deep;
ColRef<_Ty>& operator= (const _Ty& vt){ ColRef<_Ty>& operator= (const _Ty& vt) {
vector_type<_Ty>::operator=(vt); vector_type<_Ty>::operator=(vt);
return *this; return *this;
} }
@ -98,7 +98,7 @@ public:
vector_type<_Ty>::operator=(std::move(vt)); vector_type<_Ty>::operator=(std::move(vt));
return *this; 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); return ColView<_Ty>(*this, idxs);
} }
@ -117,12 +117,12 @@ public:
std::cout << this->operator[](i) << sep; std::cout << this->operator[](i) << sep;
std::cout << this->operator[](i); std::cout << this->operator[](i);
} }
std::cout<< more; std::cout << more;
std::cout << ')'; std::cout << ')';
} }
template<typename T> template<typename T>
ColRef<T> scast(); ColRef<T> scast();
ColRef<_Ty>* rename(const char* name) { ColRef<_Ty>* rename(const char* name) {
this->name = name; this->name = name;
return this; return this;
@ -130,14 +130,14 @@ public:
// defined in table_ext_monetdb.hpp // defined in table_ext_monetdb.hpp
void* monetdb_get_col(); void* monetdb_get_col();
}; };
template<> template<>
class ColRef<void> : public ColRef<int>{}; class ColRef<void> : public ColRef<int> {};
template<typename _Ty> template<typename _Ty>
class ColView { class ColView {
public: public:
typedef ColRef<_Ty> Decayed_t; typedef ColRef<_Ty> Decayed_t;
const uint32_t size; const uint32_t size;
const ColRef<_Ty> orig; 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, 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 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) { 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]]; idxs[i] = orig.idxs[idxs[i]];
} }
_Ty& operator [](const uint32_t& i) const { _Ty& operator [](const uint32_t& i) const {
@ -177,9 +177,9 @@ public:
} }
void out(uint32_t n = 4, const char* sep = " ") const { void out(uint32_t n = 4, const char* sep = " ") const {
n = n > size ? size : n; n = n > size ? size : n;
std::cout<<'('; std::cout << '(';
for (uint32_t i = 0; i < n; ++i) for (uint32_t i = 0; i < n; ++i)
std::cout << this->operator[](i)<< sep; std::cout << this->operator[](i) << sep;
std::cout << ')'; std::cout << ')';
} }
operator ColRef<_Ty>() { operator ColRef<_Ty>() {
@ -192,7 +192,7 @@ public:
uint32_t len = end - start; uint32_t len = end - start;
return ColView<_Ty>(orig, idxs.subvec(start, end)); 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; uint32_t len = end - start;
ColRef<_Ty> subvec(len); ColRef<_Ty> subvec(len);
for (uint32_t i = 0; i < len; ++i) for (uint32_t i = 0; i < len; ++i)
@ -202,10 +202,10 @@ public:
std::unordered_set<_Ty> distinct_common() { std::unordered_set<_Ty> distinct_common() {
return std::unordered_set<_Ty> {begin(), end()}; return std::unordered_set<_Ty> {begin(), end()};
} }
uint32_t distinct_size(){ uint32_t distinct_size() {
return distinct_common().size(); return distinct_common().size();
} }
ColRef<_Ty> distinct(){ ColRef<_Ty> distinct() {
auto set = distinct_common(); auto set = distinct_common();
ColRef<_Ty> ret(set.size()); ColRef<_Ty> ret(set.size());
uint32_t i = 0; 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 { constexpr inline auto& get(const TableInfo<_Types...>& table) noexcept {
if constexpr (order) if constexpr (order)
return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.colrefs[_Index]); return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.colrefs[_Index]);
else else
return *(ColRef<std::tuple_element_t<-1-_Index, std::tuple<_Types...>>> *) & (table.colrefs[-1-_Index]); return *(ColRef<std::tuple_element_t<-1 - _Index, std::tuple<_Types...>>> *) & (table.colrefs[-1 - _Index]);
} }
template <long long _Index, class... _Types> template <long long _Index, class... _Types>
@ -267,7 +267,7 @@ struct TableInfo {
TableInfo<Types...>* this_table; TableInfo<Types...>* this_table;
TableInfo<Types2...>* table; TableInfo<Types2...>* table;
vector_type<uint32_t> rid; 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) {} : this_table(this_table), table(table), rid(0) {}
constexpr lineage_t() : this_table(0), table(0), rid(0) {} constexpr lineage_t() : this_table(0), table(0), rid(0) {}
@ -279,12 +279,12 @@ struct TableInfo {
rid.emplace_back(v); rid.emplace_back(v);
} }
}; };
template<class ...Types2> template<class ...Types2>
auto bind(TableInfo<Types2...>* table2) { auto bind(TableInfo<Types2...>* table2) {
return lineage_t(this, table2); return lineage_t(this, table2);
} }
template <size_t i = 0> template <size_t i = 0>
auto& get_col() { auto& get_col() {
return *reinterpret_cast<ColRef<std::tuple_element_t <i, tuple_type>>*>(colrefs + i); return *reinterpret_cast<ColRef<std::tuple_element_t <i, tuple_type>>*>(colrefs + i);
@ -293,30 +293,30 @@ struct TableInfo {
template <size_t j = 0> 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 j = 0> 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> template <size_t ...Idxs>
struct GetTypes { struct GetTypes {
typedef typename std::tuple<typename std::tuple_element<Idxs, tuple_type>::type ...> type; typedef typename std::tuple<typename std::tuple_element<Idxs, tuple_type>::type ...> type;
}; };
template <size_t ...Idxs> template <size_t ...Idxs>
using getRecordType = typename GetTypes<Idxs...>::type; using getRecordType = typename GetTypes<Idxs...>::type;
TableInfo(const char* name, uint32_t n_cols); 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> template <int prog = 0>
inline void materialize(const vector_type<uint32_t>& idxs, TableInfo<Types...>* tbl = nullptr) { // inplace materialize 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; if constexpr (prog == sizeof...(Types)) return;
else { else {
auto& col = get<prog>(*this); auto& col = get<prog>(*this);
auto new_col = decays<decltype(col)>{idxs.size}; auto new_col = decays<decltype(col)>{ idxs.size };
for(uint32_t i = 0; i < idxs.size; ++i) for (uint32_t i = 0; i < idxs.size; ++i)
new_col[i] = col[idxs[i]]; new_col[i] = col[idxs[i]];
get<prog>(*tbl) = new_col; get<prog>(*tbl) = new_col;
materialize<prog + 1>(idxs, tbl); 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)); auto tbl = new TableInfo<Types...>(this->name, sizeof...(Types));
materialize<0>(idxs, tbl); materialize<0>(idxs, tbl);
return tbl; return tbl;
@ -337,16 +337,16 @@ struct TableInfo {
return ord; return ord;
} }
template <int ...cols> template <int ...cols>
auto order_by_view () { auto order_by_view() {
return TableView<Types...>(order_by<cols...>(), *this); return TableView<Types...>(order_by<cols...>(), *this);
} }
// Print 2 -- generate printf string first, supports flattening, supports sprintf/printf/fprintf // 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 { 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; using this_type = typename std::tuple_element<col, tuple_type>::type;
const auto& this_value = get<col>(*this)[i]; const auto& this_value = get<col>(*this)[i];
const auto& next = [&](auto &v) { const auto& next = [&](auto& v) {
if constexpr (sizeof...(rem_cols) == 0) if constexpr (sizeof...(rem_cols) == 0)
func(args..., print_hook(v)); func(args..., print_hook(v));
else else
@ -358,7 +358,7 @@ struct TableInfo {
else else
next(this_value); 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(); std::string header_string = std::string();
for (uint32_t i = 0; i < sizeof...(Types); ++i) for (uint32_t i = 0; i < sizeof...(Types); ++i)
header_string += std::string(this->colrefs[i].name) + sep + '|' + sep; header_string += std::string(this->colrefs[i].name) + sep + '|' + sep;
@ -371,17 +371,17 @@ struct TableInfo {
template <int ...cols> template <int ...cols>
void print2(const char* __restrict sep = ",", const char* __restrict end = "\n", void print2(const char* __restrict sep = ",", const char* __restrict end = "\n",
const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) const { const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) const {
std::string printf_string = std::string printf_string =
generate_printf_string<typename std::tuple_element<cols, tuple_type>::type ...>(sep, end); generate_printf_string<typename std::tuple_element<cols, tuple_type>::type ...>(sep, end);
std::string header_string = std::string(); std::string header_string = std::string();
constexpr static int a_cols[] = { cols... }; 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; header_string += std::string(this->colrefs[a_cols[i]].name) + sep;
const size_t l_sep = strlen(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); header_string.resize(header_string.size() - l_sep);
const auto& prt_loop = [&fp, &view, &printf_string, *this](const auto& f) { const auto& prt_loop = [&fp, &view, &printf_string, *this](const auto& f) {
#ifdef __AQ__HAS__INT128__ #ifdef __AQ__HAS__INT128__
constexpr auto num_hge = count_type<__int128_t, __uint128_t>((tuple_type*)(0)); 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_date = count_type<types::date_t>((tuple_type*)(0));
constexpr auto num_time = count_type<types::time_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)); constexpr auto num_timestamp = count_type<types::timestamp_t>((tuple_type*)(0));
char cbuf[ num_hge * 41 char cbuf[num_hge * 41
+ num_time * types::time_t::string_length() + num_time * types::time_t::string_length()
+ num_date * types::date_t::string_length() + num_date * types::date_t::string_length()
+ num_timestamp * types::timestamp_t::string_length() + num_timestamp * types::timestamp_t::string_length()
+ 1
]; ];
setgbuf(cbuf); setgbuf(cbuf);
if(view) if (view)
for (uint32_t i = 0; i < view->size; ++i){ for (uint32_t i = 0; i < view->size; ++i) {
print2_impl<cols...>(f, (*view)[i], printf_string.c_str()); print2_impl<cols...>(f, (*view)[i], printf_string.c_str());
setgbuf(); setgbuf();
} }
else else
for (uint32_t i = 0; i < colrefs[0].size; ++i){ for (uint32_t i = 0; i < colrefs[0].size; ++i) {
print2_impl<cols...>(f, i, printf_string.c_str()); print2_impl<cols...>(f, i, printf_string.c_str());
setgbuf(); setgbuf();
} }
}; };
@ -420,10 +421,13 @@ struct TableInfo {
} }
} }
template <int ...vals> struct applier { template <int ...vals> struct applier {
inline constexpr static void apply(const TableInfo<Types...>& t, const char* __restrict sep = ",", const char* __restrict end = "\n", 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) const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr)
{ t.template print2<vals ...>(sep, end, view, fp); }}; {
t.template print2<vals ...>(sep, end, view, fp);
}
};
inline void printall(const char* __restrict sep = ",", const char* __restrict end = "\n", inline void printall(const char* __restrict sep = ",", const char* __restrict end = "\n",
const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) { const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) {
applyIntegerSequence<sizeof...(Types), applier>::apply(*this, sep, end, view, fp); applyIntegerSequence<sizeof...(Types), applier>::apply(*this, sep, end, view, fp);
@ -433,33 +437,33 @@ struct TableInfo {
this->name = name; this->name = name;
return this; return this;
} }
template <size_t ...Is> template <size_t ...Is>
void inline void inline
reserve(std::index_sequence<Is...>, uint32_t size) { reserve(std::index_sequence<Is...>, uint32_t size) {
const auto& assign_sz = [&size](auto& col){ const auto& assign_sz = [&size](auto& col) {
col.size = size; col.size = size;
col.grow(); col.grow();
}; };
(assign_sz(get_col<Is>()), ...); (assign_sz(get_col<Is>()), ...);
} }
template <size_t ...Is> template <size_t ...Is>
decltype(auto) inline decltype(auto) inline
get_record(std::index_sequence<Is...>, uint32_t i) { get_record(std::index_sequence<Is...>, uint32_t i) {
return std::forward_as_tuple(get_col<Is>()[i] ...); return std::forward_as_tuple(get_col<Is>()[i] ...);
} }
template <size_t ...Is> template <size_t ...Is>
void inline void inline
set_record(std::index_sequence<Is...>, const tuple_type& t, uint32_t i) { set_record(std::index_sequence<Is...>, const tuple_type& t, uint32_t i) {
const auto& assign_field = const auto& assign_field =
[](auto& l, const auto& r){ [](auto& l, const auto& r) {
l = r; l = r;
}; };
(assign_field(get_col<Is>()[i], std::get<Is>(t)), ...); (assign_field(get_col<Is>()[i], std::get<Is>(t)), ...);
} }
TableInfo<Types ...>* distinct() { TableInfo<Types ...>* distinct() {
std::unordered_set<tuple_type> d_records; std::unordered_set<tuple_type> d_records;
std::make_index_sequence<sizeof...(Types)> seq; std::make_index_sequence<sizeof...(Types)> seq;
for (uint32_t j = 0; j < colrefs[0].size; ++j) { for (uint32_t j = 0; j < colrefs[0].size; ++j) {
d_records.insert(get_record(seq, 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; 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> 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 ...Is> template <size_t ...Is>
decltype(auto) inline decltype(auto) inline
get_record(std::index_sequence<Is...>, uint32_t i) { get_record(std::index_sequence<Is...>, uint32_t i) {
return std::forward_as_tuple(info.template get_col<Is>()[idxs[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) { TableInfo<Types ...>* get_tableinfo(const char* name = nullptr, const char** names = nullptr) {
if (name == nullptr) if (name == nullptr)
name = info.name; name = info.name;
const char* info_names[sizeof...(Types)]; const char* info_names[sizeof...(Types)];
if (name == nullptr) { 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; info_names[i] = info.colrefs[i].name;
names = info_names; names = info_names;
} }
@ -520,7 +524,7 @@ struct TableView {
TableInfo<Types ...>* distinct(const char* name = nullptr, const char** names = nullptr) { TableInfo<Types ...>* distinct(const char* name = nullptr, const char** names = nullptr) {
std::unordered_set<tuple_type> d_records; std::unordered_set<tuple_type> d_records;
std::make_index_sequence<sizeof...(Types)> seq; std::make_index_sequence<sizeof...(Types)> seq;
for (uint32_t j = 0; j < idxs->size; ++j) { for (uint32_t j = 0; j < idxs->size; ++j) {
d_records.insert(get_record(seq, 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)) { 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); this->colrefs = (ColRef<void>*)malloc(sizeof(ColRef<void>) * this->n_cols);
for (uint32_t i = 0; i < n_cols; ++i) { 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> template <class ...Types>
@ -582,7 +586,7 @@ template<class ...Types>
inline void TableView<Types...>::print(const char* __restrict sep, const char* __restrict end) const { 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::string header_string = info.get_header_string(sep, end);
std::cout << header_string.c_str(); std::cout << header_string.c_str();
uint32_t n_rows = 0; uint32_t n_rows = 0;
if (info.colrefs[0].size > 0) if (info.colrefs[0].size > 0)
n_rows = info.colrefs[0].size; 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 <class ...Types>
template <size_t j> 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 { TableInfo<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
std::cout << (get<j>(*this))[i]; std::cout << (get<j>(*this))[i];
} }
template<class ...Types> template<class ...Types>
template<size_t j> 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 TableInfo<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
{ {
std::cout << (get<j>(*this))[i] << sep; std::cout << (get<j>(*this))[i] << sep;
print_impl<j+1>(i, sep); print_impl<j + 1>(i, sep);
} }
template<class ...Types> template<class ...Types>
inline void TableInfo<Types...>::print(const char* __restrict sep, const char* __restrict end) const { inline void TableInfo<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
std::string header_string = get_header_string(sep, end); std::string header_string = get_header_string(sep, end);
std::cout << header_string.c_str(); std::cout << header_string.c_str();
uint32_t n_rows = 0; uint32_t n_rows = 0;
if (n_cols > 0 && colrefs[0].size > 0) if (n_cols > 0 && colrefs[0].size > 0)
n_rows = colrefs[0].size; n_rows = colrefs[0].size;
@ -740,7 +744,7 @@ void print(const TableView<Types...>& v, const char* delimiter = " ", const char
} }
template <class T> template <class T>
void print(const T& v, const char* delimiter = " ") { 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); // printf(types::printf_str[types::Types<T>::getType()], v);
} }
@ -748,10 +752,10 @@ void print(const T& v, const char* delimiter = " ") {
template <> template <>
void print<__int128_t>(const __int128_t& v, const char* delimiter); void print<__int128_t>(const __int128_t& v, const char* delimiter);
template <> template <>
void print<__uint128_t>(const __uint128_t&v, const char* delimiter); void print<__uint128_t>(const __uint128_t& v, const char* delimiter);
#endif #endif
template <> template <>
void print<bool>(const bool&v, const char* delimiter); void print<bool>(const bool& v, const char* delimiter);
template <class T> template <class T>
void inline print_impl(const T& v, const char* delimiter, const char* endline) { 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> 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(const VT<T>& v, const char* delimiter = " ", const char* endline = "\n") {
print_impl(v, delimiter, endline); print_impl(v, delimiter, endline);
} }
#endif #endif

110
server/types.h
Unescape View File

@ -29,22 +29,22 @@ namespace types {
static constexpr const char* printf_str[] = { "%d", "%f", "%s", "%lf", "%Lf", "%ld", "%d", "%hi", "%s", "%s", "%c", 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" }; "%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", 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 // TODO: deal with data/time <=> str/uint conversion
struct date_t{ struct date_t {
unsigned char day = 0; unsigned char day = 0;
unsigned char month = 0; unsigned char month = 0;
short year = 0; short year = 0;
date_t() = default; date_t() = default;
date_t(unsigned char day, unsigned char month, short year) : date_t(unsigned char day, unsigned char month, short year) :
day (day), month (month), year(year) {} day(day), month(month), year(year) {}
date_t(const char*); date_t(const char*);
date_t& fromString(const char*); date_t& fromString(const char*);
bool validate() const; bool validate() const;
constexpr static unsigned string_length(){ constexpr static unsigned string_length() {
return 11; return 11;
}; };
char* toString(char* buf) const; char* toString(char* buf) const;
@ -56,16 +56,16 @@ namespace types {
bool operator != (const date_t&) const; bool operator != (const date_t&) const;
}; };
struct time_t{ struct time_t {
unsigned int ms = 0; unsigned int ms = 0;
unsigned char seconds = 0; unsigned char seconds = 0;
unsigned char minutes = 0; unsigned char minutes = 0;
unsigned char hours = 0; unsigned char hours = 0;
time_t() = default; time_t() = default;
time_t(unsigned int ms, unsigned char seconds, unsigned char minutes, unsigned char hours) : time_t(unsigned int ms, unsigned char seconds, unsigned char minutes, unsigned char hours) :
ms (ms), seconds (seconds), minutes(minutes), hours(hours) {}; ms(ms), seconds(seconds), minutes(minutes), hours(hours) {};
time_t(const char*); time_t(const char*);
time_t& fromString(const char*); time_t& fromString(const char*);
bool validate() const; bool validate() const;
constexpr static unsigned string_length() { constexpr static unsigned string_length() {
@ -79,15 +79,15 @@ namespace types {
bool operator == (const time_t&) const; bool operator == (const time_t&) const;
bool operator != (const time_t&) const; bool operator != (const time_t&) const;
}; };
struct timestamp_t{ struct timestamp_t {
date_t date; date_t date;
time_t time; time_t time;
timestamp_t() = default; timestamp_t() = default;
timestamp_t(const date_t& d, const time_t& t) : date(d), time(t) {} 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*); timestamp_t& fromString(const char*);
bool validate() const; bool validate() const;
constexpr static unsigned string_length(){ constexpr static unsigned string_length() {
return date_t::string_length() + time_t::string_length(); return date_t::string_length() + time_t::string_length();
}; };
char* toString(char* buf) const; char* toString(char* buf) const;
@ -135,10 +135,10 @@ namespace types {
inline constexpr static Type_t getType() { inline constexpr static Type_t getType() {
#define TypeConnect(x, y) if constexpr(std::is_same<x, T>::value) return y; else #define TypeConnect(x, y) if constexpr(std::is_same<x, T>::value) return y; else
ConnectTypes(TypeConnect) ConnectTypes(TypeConnect)
if constexpr (is_vector_type<T>) if constexpr (is_vector_type<T>)
return VECTOR; return VECTOR;
else else
return NONE; return NONE;
} }
}; };
#define ATypeSize(t, at) sizeof(t), #define ATypeSize(t, at) sizeof(t),
@ -167,17 +167,51 @@ namespace types {
}; };
template<class T> template<class T>
using GetLongType = typename GetLongTypeImpl<typename std::decay<T>::type>::type; 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 { struct astring_view {
const unsigned char* str = 0; 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)) {} 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)) {} str((const unsigned char*)(str)) {}
constexpr astring_view(const unsigned char* str) :
constexpr
astring_view(const unsigned char* str) noexcept :
str(str) {} str(str) {}
constexpr astring_view() = default; constexpr astring_view() noexcept = default;
bool operator==(const astring_view& r) const { bool operator==(const astring_view& r) const {
auto this_str = str; auto this_str = str;
@ -190,8 +224,8 @@ struct astring_view {
} }
return !(*this_str || *other_str); return !(*this_str || *other_str);
} }
bool operator >(const astring_view&r) const{ bool operator >(const astring_view& r) const {
} }
operator const char* () const { operator const char* () const {
return reinterpret_cast<const char*>(str); return reinterpret_cast<const char*>(str);
@ -200,7 +234,7 @@ struct astring_view {
return reinterpret_cast<const unsigned char*>(str); return reinterpret_cast<const unsigned char*>(str);
} }
operator const signed char* () const { 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; using type = typename std::decay<T>::type;
}; };
template<template<typename ...> class T, typename ...Types> template<template<typename ...> class T, typename ...Types>
struct decayS <T<Types...>>{ struct decayS <T<Types...>> {
using type = T<typename std::decay<Types>::type ...>; using type = T<typename std::decay<Types>::type ...>;
}; };
template <class T> 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> template <int i, template <int ...> class rT>
using applyIntegerSequence = typename transValues_s<std::make_integer_sequence<int, i>, int, rT>::type; using applyIntegerSequence = typename transValues_s<std::make_integer_sequence<int, i>, int, rT>::type;
template <template <class ...> class T, class ...Types> 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> template <template <typename ...> class VT, class ...Types>
using decayed_t = typename decayed_impl<VT, Types...>::type; 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(); }; 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) { constexpr size_t sum_type(size_t a[], size_t sz) {
size_t ret = 0; size_t ret = 0;
for (int i = 0; i < sz; ++i) for (int i = 0; i < sz; ++i)
ret += a[i]; ret += a[i];
return ret; return ret;
} }
template<class Types, class ...T1> template<class Types, class ...T1>
constexpr size_t sum_type() { constexpr size_t sum_type() {
size_t t[] = {std::is_same_v<Types, T1> ...}; size_t t[] = { std::is_same_v<Types, T1> ... };
return sum_type(t, sizeof...(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) { constexpr size_t count_type(std::tuple<Types...>* ts) {
size_t t[] = {sum_type<Types, T1...>() ...}; size_t t[] = { sum_type<Types, T1...>() ... };
return sum_type(t, sizeof...(Types)); return sum_type(t, sizeof...(Types));
} }
#endif // !_TYPES_H #endif // !_TYPES_H

Write Preview
Loading…
Cancel
Save