|
|
|
@ -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;
|
|
|
|
@ -133,11 +133,11 @@ public:
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
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));
|
|
|
|
@ -398,14 +398,14 @@ struct TableInfo {
|
|
|
|
|
+ 1 // padding for msvc not allowing empty arrays
|
|
|
|
|
];
|
|
|
|
|
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();
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
@ -421,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);
|
|
|
|
@ -434,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));
|
|
|
|
|
}
|
|
|
|
@ -487,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;
|
|
|
|
|
}
|
|
|
|
@ -521,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));
|
|
|
|
|
}
|
|
|
|
@ -560,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>
|
|
|
|
@ -583,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;
|
|
|
|
@ -595,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;
|
|
|
|
@ -799,7 +802,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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -807,10 +810,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) {
|
|
|
|
@ -824,10 +827,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
|
|
|
|
|