bug fixes

engine/ddl.py

@@ -28,7 +28,7 @@ class create_table(ast_node):
         # create an empty new table
         if self.cexprs is None:
             for c in tbl.columns:
-                self.emit(f"{c.cxt_name}.init();")
+                self.emit(f"{c.cxt_name}.init({c.name});")
         # create an output table
         else:
             # 1 to 1 lineage.
@@ -40,7 +40,7 @@ class create_table(ast_node):
                 else:
                     self.lineage = None
                 for i, c in enumerate(tbl.columns):
-                    self.emit(f"{c.cxt_name}.init();")
+                    self.emit(f"{c.cxt_name}.init({c.name});")
                     self.emit(f"{c.cxt_name} = {self.cexprs[i](self.lineage)};")
                 self.lineage = None
                 self.parent.assumptions = None
@@ -54,7 +54,7 @@ class create_table(ast_node):
                     scanner.add(f"{lineage_var}.emplace_back({counter_var}++);", "front")
                     self.lineage = f"{lineage_var}.rid"
                 for i, c in enumerate(tbl.columns):
-                    scanner.add(f"{c.cxt_name}.init();", "init")
+                    scanner.add(f"{c.cxt_name}.init({c.name});", "init")
                     scanner.add(f"{c.cxt_name} = {self.cexprs[i](scanner.it_ver)};")
                     
 class insert(ast_node):

engine/expr.py

@@ -50,6 +50,7 @@ class expr(ast_node):
         self.inside_agg = False
         if(type(parent) is expr):
             self.inside_agg = parent.inside_agg
+            self.__abs = parent.__abs
         ast_node.__init__(self, parent, node, None)
 
     def init(self, _):

engine/groupby.py

@@ -55,7 +55,7 @@ class groupby(ast_node):
         gscanner = scan(self, self.group)
         val_var = 'val_'+base62uuid(7)
         gscanner.add(f'auto &{val_var} = {gscanner.it_ver}.second;')
-        gscanner.add(f'{out.cxt_name}->order_by<{assumption.result()}>(&{val_var});')
+        gscanner.add(f'{self.datasource.cxt_name}->order_by<{assumption.result()}>(&{val_var});')
         gscanner.finalize()
         
     def finalize(self, cexprs, out:TableInfo):

moving_avg.a

@@ -10,5 +10,5 @@ FROM sale
 INTO OUTFILE "moving_avg_output.csv"
 FIELDS TERMINATED BY ";"
 
-select sales, mins(2,Month) from sale group by sales
+select Month, mins(2,sales) from sale assuming desc Month group by sales 
 into outfile "flatten.csv" 

msc-plugin/msc-plugin.vcxproj

@@ -32,6 +32,7 @@
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>false</EnableASAN>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -39,12 +40,15 @@
     <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
+    <EnableFuzzer>false</EnableFuzzer>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
@@ -52,6 +56,7 @@
     <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -94,11 +99,14 @@
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpplatest</LanguageStandard>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <EnableModules>true</EnableModules>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <GenerateDebugInformation>DebugFull</GenerateDebugInformation>
       <OutputFile>$(ProjectDir)\..\dll.so</OutputFile>
+      <AssemblyDebug>true</AssemblyDebug>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -123,14 +131,22 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_ALLOW_RTCc_IN_STL;_CRT_SECURE_NO_WARNINGS;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpplatest</LanguageStandard>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <EnableModules>true</EnableModules>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
+      <OmitFramePointers>false</OmitFramePointers>
+      <SmallerTypeCheck>true</SmallerTypeCheck>
+      <SupportJustMyCode>false</SupportJustMyCode>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <GenerateDebugInformation>DebugFull</GenerateDebugInformation>
       <OutputFile>$(ProjectDir)\..\dll.so</OutputFile>
+      <AssemblyDebug>true</AssemblyDebug>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

out.cpp

@@ -1,61 +1,79 @@
-#include "./server/hasher.h"
-#include "./server/aggregations.h"
-#include "csv.h"
 #include "./server/libaquery.h"
-#include <unordered_map>
+#include "./server/aggregations.h"
 
     extern "C" int __DLLEXPORT__ dllmain(Context* cxt) { 
         using namespace std;
         using namespace types;
         
-    auto sale = new TableInfo<int,int>("sale", 2);
-cxt->tables.insert({"sale", sale});
-auto& sale_Month = *(ColRef<int> *)(&sale->colrefs[0]);
-auto& sale_sales = *(ColRef<int> *)(&sale->colrefs[1]);
-sale_Month.init();
-sale_sales.init();
-io::CSVReader<2> csv_reader_6T89Ll("moving_avg.csv");
-csv_reader_6T89Ll.read_header(io::ignore_extra_column, "Month","sales");
-int tmp_5vttJ2yV;
-int tmp_2ckq15YU;
-while(csv_reader_6T89Ll.read_row(tmp_5vttJ2yV,tmp_2ckq15YU)) { 
-
-sale_Month.emplace_back(tmp_5vttJ2yV);
-sale_sales.emplace_back(tmp_2ckq15YU);
-}
-auto out_2UiD = new TableInfo<value_type<decays<decltype(sale_Month)>>,value_type<decays<decltype(avgw(3,sale_sales))>>>("out_2UiD", 2);
-cxt->tables.insert({"out_2UiD", out_2UiD});
-auto& out_2UiD_Month = *(ColRef<value_type<decays<decltype(sale_Month)>>> *)(&out_2UiD->colrefs[0]);
-auto& out_2UiD_avgw3salesales = *(ColRef<value_type<decays<decltype(avgw(3,sale_sales))>>> *)(&out_2UiD->colrefs[1]);
-auto order_1NNZ9F = sale->order_by<0>();
-out_2UiD_Month.init();
-out_2UiD_Month = sale_Month[*order_1NNZ9F];
-out_2UiD_avgw3salesales.init();
-out_2UiD_avgw3salesales = avgw(3,sale_sales[*order_1NNZ9F]);
-print(*out_2UiD);
-FILE* fp_6xIJn4 = fopen("moving_avg_output.csv", "w");
-out_2UiD->printall(";", "\n", nullptr, fp_6xIJn4);
-fclose(fp_6xIJn4);
-typedef record<decltype(sale_sales[0])> record_type6Lepq5T;
-unordered_map<record_type6Lepq5T, vector_type<uint32_t>, transTypes<record_type6Lepq5T, hasher>> g4loWjmn;
-for (uint32_t i5g = 0; i5g < sale_sales.size; ++i5g){
-g4loWjmn[forward_as_tuple(sale_sales[i5g])].emplace_back(i5g);
-}
-auto out_2YlO = new TableInfo<value_type<decays<decltype(sale_sales)>>,decays<decltype(minw(2,sale_Month))>>("out_2YlO", 2);
-cxt->tables.insert({"out_2YlO", out_2YlO});
-auto& out_2YlO_sales = *(ColRef<value_type<decays<decltype(sale_sales)>>> *)(&out_2YlO->colrefs[0]);
-auto& out_2YlO_minw2saleMonth = *(ColRef<decays<decltype(minw(2,sale_Month))>> *)(&out_2YlO->colrefs[1]);
-out_2YlO_sales.init();
-out_2YlO_minw2saleMonth.init();
-for(auto& iFU : g4loWjmn) {
-auto &key_3AwvKMR = iFU.first;
-auto &val_7jtE12E = iFU.second;
-out_2YlO_sales.emplace_back(get<0>(key_3AwvKMR));
-out_2YlO_minw2saleMonth.emplace_back(minw(2,sale_Month[val_7jtE12E]));
-}
-print(*out_2YlO);
-FILE* fp_45ld6S = fopen("flatten.csv", "w");
-out_2YlO->printall(",", "\n", nullptr, fp_45ld6S);
-fclose(fp_45ld6S);
+    auto stocks = new TableInfo<int,int>("stocks", 2);
+cxt->tables.insert({"stocks", stocks});
+auto& stocks_timestamp = *(ColRef<int> *)(&stocks->colrefs[0]);
+auto& stocks_price = *(ColRef<int> *)(&stocks->colrefs[1]);
+stocks_timestamp.init();
+stocks_price.init();
+stocks_timestamp.emplace_back(1);
+stocks_price.emplace_back(15);
+stocks_timestamp.emplace_back(2);
+stocks_price.emplace_back(19);
+stocks_timestamp.emplace_back(3);
+stocks_price.emplace_back(16);
+stocks_timestamp.emplace_back(4);
+stocks_price.emplace_back(17);
+stocks_timestamp.emplace_back(5);
+stocks_price.emplace_back(15);
+stocks_timestamp.emplace_back(6);
+stocks_price.emplace_back(13);
+stocks_timestamp.emplace_back(7);
+stocks_price.emplace_back(5);
+stocks_timestamp.emplace_back(8);
+stocks_price.emplace_back(8);
+stocks_timestamp.emplace_back(9);
+stocks_price.emplace_back(7);
+stocks_timestamp.emplace_back(10);
+stocks_price.emplace_back(13);
+stocks_timestamp.emplace_back(11);
+stocks_price.emplace_back(11);
+stocks_timestamp.emplace_back(12);
+stocks_price.emplace_back(14);
+stocks_timestamp.emplace_back(13);
+stocks_price.emplace_back(10);
+stocks_timestamp.emplace_back(14);
+stocks_price.emplace_back(5);
+stocks_timestamp.emplace_back(15);
+stocks_price.emplace_back(2);
+stocks_timestamp.emplace_back(16);
+stocks_price.emplace_back(5);
+auto out_oMxe = new TableInfo<value_type<decays<decltype(max((stocks_price-min(stocks_timestamp))))>>>("out_oMxe", 1);
+cxt->tables.insert({"out_oMxe", out_oMxe});
+auto& out_oMxe_maxstockspriceminstockstimestamp = *(ColRef<value_type<decays<decltype(max((stocks_price-min(stocks_timestamp))))>>> *)(&out_oMxe->colrefs[0]);
+out_oMxe_maxstockspriceminstockstimestamp.init();
+out_oMxe_maxstockspriceminstockstimestamp = max((stocks_price-min(stocks_timestamp)));
+print(*out_oMxe);
+auto out_2ZWg = new TableInfo<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>>("out_2ZWg", 1);
+cxt->tables.insert({"out_2ZWg", out_2ZWg});
+auto& out_2ZWg_maxstockspriceminsstocksprice = *(ColRef<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>> *)(&out_2ZWg->colrefs[0]);
+out_2ZWg_maxstockspriceminsstocksprice.init();
+out_2ZWg_maxstockspriceminsstocksprice = max((stocks_price-mins(stocks_price)));
+print(*out_2ZWg);
+const auto& tmp_sz_B19sAY = stocks_timestamp.size;
+auto out_JZsz = new TableInfo<value_type<decays<decltype(stocks_price)>>,value_type<decays<decltype(stocks_timestamp)>>>("out_JZsz", 2);
+cxt->tables.insert({"out_JZsz", out_JZsz});
+auto& out_JZsz_price = *(ColRef<value_type<decays<decltype(stocks_price)>>> *)(&out_JZsz->colrefs[0]);
+auto& out_JZsz_timestamp = *(ColRef<value_type<decays<decltype(stocks_timestamp)>>> *)(&out_JZsz->colrefs[1]);
+out_JZsz_price.init();
+out_JZsz_timestamp.init();
+for (uint32_t i3D = 0; i3D < tmp_sz_B19sAY; ++i3D){
+if ((((stocks_price[i3D]-stocks_timestamp[i3D])>=1)&&!(((stocks_price[i3D]*stocks_timestamp[i3D])<100)))) {
+out_JZsz_price = stocks_price[i3D];
+out_JZsz_timestamp = stocks_timestamp[i3D];
+}}
+print(*out_JZsz);
+auto out_2Fm0 = new TableInfo<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>>("out_2Fm0", 1);
+cxt->tables.insert({"out_2Fm0", out_2Fm0});
+auto& out_2Fm0_maxstockspriceminsstocksprice = *(ColRef<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>> *)(&out_2Fm0->colrefs[0]);
+auto order_5qqTLa = stocks->order_by<-1>();
+out_2Fm0_maxstockspriceminsstocksprice.init();
+out_2Fm0_maxstockspriceminsstocksprice = max((stocks_price[*order_5qqTLa]-mins(stocks_price[*order_5qqTLa])));
+print(*out_2Fm0);
 return 0;
 }

prompt.py

@@ -42,27 +42,31 @@ def rm():
         cleanup = False
    
 atexit.register(rm)
-    
-shm = base62uuid()
-if sys.platform != 'win32':
-    import readline
-    shm += '.shm'
-    basecmd = ['bash', '-c', 'rlwrap k']
-    mm = None
-    if not os.path.isfile(shm):
-        # create initial file
-        with open(shm, "w+b") as handle:
-            handle.write(b'\x01\x00') # [running, new job]
-            handle.flush()
-            mm = mmap.mmap(handle.fileno(), 2, access=mmap.ACCESS_WRITE, offset=0)
-    if mm is None:
-        exit(1)
-else:
-    basecmd = ['bash.exe', '-c', 'rlwrap ./k']
-    mm = mmap.mmap(0, 2, shm)
-    mm.write(b'\x01\x00')
-    mm.flush()
-server = subprocess.Popen(["./server.bin", shm])
+
+def init():
+    global shm, server, basecmd, mm
+    shm = base62uuid()
+    if sys.platform != 'win32':
+        import readline
+        shm += '.shm'
+        basecmd = ['bash', '-c', 'rlwrap k']
+        mm = None
+        if not os.path.isfile(shm):
+            # create initial file
+            with open(shm, "w+b") as handle:
+                handle.write(b'\x01\x00') # [running, new job]
+                handle.flush()
+                mm = mmap.mmap(handle.fileno(), 2, access=mmap.ACCESS_WRITE, offset=0)
+        if mm is None:
+            exit(1)
+    else:
+        basecmd = ['bash.exe', '-c', 'rlwrap ./k']
+        mm = mmap.mmap(0, 2, shm)
+        mm.write(b'\x01\x00')
+        mm.flush()
+    server = subprocess.Popen(["./server.bin", shm])
+
+init()
 
 test_parser = True
 
@@ -92,10 +96,8 @@ cxt = None
 while test_parser:
     try:
         if server.poll() is not None:
-            mm.seek(0,os.SEEK_SET)
-            mm.write(b'\x01\x00')
-            server = subprocess.Popen(["./server.bin", shm])
-        q = input()
+            init()
+        q = input().lower()
         if q == 'exec':
             if not keep or cxt is None:
                 cxt = engine.initialize()
@@ -145,7 +147,7 @@ while test_parser:
                             else trimed[1]
                 
             with open(fn, 'r') as file:
-                contents = file.read()
+                contents = file.read()#.lower()
             stmts = parser.parse(contents)
             continue
         stmts = parser.parse(q)

server/enc_temp_folder/3ad6cbe3a5dd4f9a9284fdca02eb4ea/IO.H

@@ -0,0 +1,15 @@
+#pragma once
+#include "types.h"
+#include <cstdio>
+#include <string>
+template <class ...Types>
+std::string generate_printf_string(const char* sep = " ", const char* end = "\n") {
+	std::string str;
+	((str += types::printf_str[types::Types<value_type_r<Types>>::getType()], str += sep), ...);
+	const auto trim = str.size() - strlen(sep);
+	if (trim > 0)
+		str.resize(trim);
+	str += end;
+	return str;
+}
+

server/enc_temp_folder/d544cc15c643dbd4f18da52d811c040/table.h

@@ -0,0 +1,443 @@
+// TODO: Replace `cout, printf` with sprintf&fputs and custom buffers
+
+#ifndef _TABLE_H
+#define _TABLE_H
+
+#include "types.h"
+#include "vector_type.hpp"
+#include <iostream>
+#include <string>
+#include "io.h"
+template <typename T>
+class vector_type;
+template <>
+class vector_type<void>;
+
+#ifdef _MSC_VER
+namespace types {
+	enum Type_t;
+	template <typename T>
+	struct Types;
+	template <class T1, class T2>
+	struct Coercion;
+}
+#endif
+template<typename _Ty>
+class ColView;
+template<typename _Ty>
+class ColRef : public vector_type<_Ty>
+{
+public:
+	typedef ColRef<_Ty> Decayed_t;
+	const char* name;
+	types::Type_t ty = types::ERROR;
+	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) {}
+	void init(const char* name = "") { ty = types::Types<_Ty>::getType();  this->size = this->capacity = 0; this->container = 0; this->name = name; }
+	ColRef(const char* name, types::Type_t ty) : name(name), ty(ty) {}
+	using vector_type<_Ty>::operator[];
+	using vector_type<_Ty>::operator=;
+	ColView<_Ty> operator [](const vector_type<uint32_t>&idxs) const {
+		return ColView<_Ty>(*this, idxs);
+	}
+
+	void out(uint32_t n = 4, const char* sep = " ") const {
+		n = n > this->size ? this->size : n;
+		std::cout << '(';
+			for (uint32_t i = 0; i < n; ++i)
+				std::cout << this->operator[](i) << sep;
+		std::cout << ')';
+	}
+	template<typename T>
+	ColRef<T> scast();
+};
+
+template<typename _Ty>
+class ColView {
+public: 
+	typedef ColRef<_Ty> Decayed_t;
+	const vector_type<uint32_t>& idxs;
+	const ColRef<_Ty>& orig;
+	const uint32_t& 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) {
+		for (uint32_t i = 0; i < size; ++i) 
+			idxs[i] = orig.idxs[idxs[i]];
+	}
+	_Ty& operator [](const uint32_t& i) const {
+		return orig[idxs[i]];
+	}
+	struct Iterator_t {
+		const uint32_t* val;
+		const ColRef<_Ty>& orig;
+		constexpr Iterator_t(const uint32_t* val, const ColRef<_Ty>& orig) noexcept : val(val), orig(orig) {}
+		_Ty& operator*() { return orig[*val]; }
+		bool operator != (const Iterator_t& rhs) { return rhs.val != val; }
+		Iterator_t& operator++ () {
+			++val;
+			return *this;
+		}
+		Iterator_t operator++ (int) {
+			Iterator_t tmp = *this;
+			++val;
+			return tmp;
+		}
+	};
+	Iterator_t begin() const {
+		return Iterator_t(idxs.begin(), orig);
+	}
+	Iterator_t end() const {
+		return Iterator_t(idxs.end(), orig);
+	}
+	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 << ')';
+	}
+	operator ColRef<_Ty>() {
+		auto ret = ColRef<_Ty>(size);
+		for (uint32_t i = 0; i < size; ++i)
+			ret[i] = orig[idxs[i]];
+		return ret;
+	}
+};
+template <template <class...> class VT, class T>
+std::ostream& operator<<(std::ostream& os, const VT<T>& v)
+{
+	v.out();
+	return os;
+}
+template <class Type>
+struct decayed_impl<ColView, Type> { typedef ColRef<Type> type; };
+template<typename _Ty>
+template<typename T>
+inline ColRef<T> ColRef<_Ty>::scast()
+{
+	this->ty = types::Types<T>::getType();
+	return *(ColRef<T> *)this;
+}
+using uColRef = ColRef<void>;
+
+template<class ...Types> struct TableInfo;
+template<class ...Types> struct TableView;
+
+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]);
+}
+
+template <long long _Index, class... _Types>
+constexpr inline ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>>& get(const TableView<_Types...>& table) noexcept {
+	return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.info.colrefs[_Index]);
+}
+
+template <class V>
+struct is_vector_impl<ColRef<V>> : std::true_type {};
+template <class V>
+struct is_vector_impl<ColView<V>> : std::true_type {};
+template <class V>
+struct is_vector_impl<vector_type<V>> : std::true_type {};
+
+template<class ...Types>
+struct TableView;
+template<class ...Types>
+struct TableInfo {
+	const char* name;
+	ColRef<void>* colrefs;
+	uint32_t n_cols;
+	typedef std::tuple<Types...> tuple_type;
+	void print(const char* __restrict sep, const char* __restrict end) const;
+
+	template <class ...Types2>
+	struct lineage_t {
+		TableInfo<Types...>* this_table;
+		TableInfo<Types2...>* table;
+		vector_type<uint32_t> rid;
+		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) {}
+
+		template <int col>
+		inline auto& get(uint32_t idx) {
+			return get<col>(*table)[rid[idx]];
+		}
+		void emplace_back(const uint32_t& v) {
+			rid.emplace_back(v);
+		}
+	};
+	template<class ...Types2>
+	auto bind(TableInfo<Types2...>* table2) {
+		return lineage_t(this, table2);
+	}
+	
+	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;
+	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);
+	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 == 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)
+				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) { 
+		auto tbl = new TableInfo<Types...>(this->name, sizeof...(Types));
+		materialize<0>(idxs, tbl);
+		return tbl;
+	}
+	template<int ...cols>
+	inline vector_type<uint32_t>* order_by(vector_type<uint32_t>* ord = nullptr) {
+		if (!ord) {
+			ord = new vector_type<uint32_t>(colrefs[0].size);
+			for (uint32_t i = 0; i < colrefs[0].size; ++i)
+				(*ord)[i] = i;
+		}
+		std::sort(ord->begin(), ord->end(), [this](const uint32_t& lhs, const uint32_t& rhs) {
+			return
+				std::forward_as_tuple((cols >= 0 ? get<cols, (cols >= 0)>(*this)[lhs] : -get<cols, (cols >= 0)>(*this)[lhs]) ...)
+				<
+				std::forward_as_tuple((cols >= 0 ? get<cols, (cols >= 0)>(*this)[rhs] : -get<cols, (cols >= 0)>(*this)[rhs]) ...);
+			});
+		return ord;
+	}
+	template <int ...cols>
+	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> 
+	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) {
+			if constexpr (sizeof...(rem_cols) == 0)
+				func(args..., v);
+			else
+				print2_impl<rem_cols...>(func, i, args ..., v);
+		};
+		if constexpr (is_vector_type<this_type>)
+			for (int j = 0; j < this_value.size; ++j)
+				next(this_value[j]);
+		else
+			next(this_value);
+	}
+	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);
+		const auto& prt_loop = [&fp, &view, &printf_string, *this](const auto& f) {
+			if(view)
+				for (int i = 0; i < view->size; ++i)
+					print2_impl<cols...>(f, (*view)[i], printf_string.c_str());
+			else
+				for (int i = 0; i < colrefs[0].size; ++i)
+					print2_impl<cols...>(f, i, printf_string.c_str());
+		};
+		if (fp)
+			prt_loop([&fp](auto... args) { fprintf(fp, args...); });
+		else
+			prt_loop(printf);
+	}
+	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 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);
+	}
+};
+
+
+template<class ...Types>
+struct TableView {
+	const vector_type<uint32_t>* idxs;
+	const TableInfo<Types...>& info;
+	constexpr TableView(const vector_type<uint32_t>* idxs, const TableInfo<Types...>& info) noexcept : idxs(idxs), info(info) {}
+	void print(const char* __restrict sep, const char* __restrict end) 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 j = 0>
+	typename std::enable_if < j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
+	
+	~TableView() {
+		delete idxs;
+	}
+};
+
+template <class T>
+constexpr static inline bool is_vector(const ColRef<T>&) {
+	return true;
+}
+template <class T>
+constexpr static inline bool is_vector(const vector_type<T>&) {
+	return true;
+}
+
+template<class ...Types>
+TableInfo<Types...>::TableInfo(const char* name, uint32_t n_cols) : name(name), n_cols(n_cols) {
+	this->colrefs = (ColRef<void>*)malloc(sizeof(ColRef<void>) * n_cols);
+}
+template <class ...Types>
+template <size_t j>
+inline typename std::enable_if<j == sizeof...(Types) - 1, void>::type
+TableView<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
+	std::cout << (get<j>(*this))[(*idxs)[i]];
+}
+
+template<class ...Types>
+template<size_t j>
+inline typename std::enable_if < j < sizeof...(Types) - 1, void>::type
+	TableView<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
+{
+	std::cout << (get<j>(*this))[(*idxs)[i]] << sep;
+	print_impl<j + 1>(i, sep);
+}
+
+template<class ...Types>
+inline void TableView<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
+	int n_rows = 0;
+	if (info.colrefs[0].size > 0)
+		n_rows = info.colrefs[0].size;
+	for (int i = 0; i < n_rows; ++i) {
+		print_impl(i);
+		std::cout << end;
+	}
+}
+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 {
+	std::cout << (get<j>(*this))[i];
+}
+
+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
+{
+	std::cout << (get<j>(*this))[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 {
+	int n_rows = 0;
+	if (n_cols > 0 && colrefs[0].size > 0)
+		n_rows = colrefs[0].size;
+	for (int i = 0; i < n_rows; ++i) {
+		print_impl(i);
+		std::cout << end;
+	}
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator -(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] - rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator -(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] - rhs;
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator +(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] + rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator +(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] + rhs;
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator *(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] * rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator *(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] * rhs;
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator /(const VT<T1>& lhs, const VT2<T2>& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] / rhs[i];
+	return ret;
+}
+template <class T1, class T2, template<typename ...> class VT>
+decayed_t<VT, typename types::Coercion<T1, T2>::type> operator /(const VT<T1>& lhs, const T2& rhs) {
+	auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
+	for (int i = 0; i < lhs.size; ++i)
+		ret[i] = lhs[i] / rhs;
+	return ret;
+}
+
+template <class ...Types>
+void print(const TableInfo<Types...>& v, const char* delimiter = " ", const char* endline = "\n") {
+	v.print(delimiter, endline);
+}
+template <class ...Types>
+void print(const TableView<Types...>& v, const char* delimiter = " ", const char* endline = "\n") {
+	v.print(delimiter, endline);
+}
+template <class T>
+void print(const T& v, const char* delimiter = " ") {
+	std::cout<< v;
+	// printf(types::printf_str[types::Types<T>::getType()], v);
+}
+template <class T>
+void inline print_impl(const T& v, const char* delimiter, const char* endline) {
+	for (const auto& vi : v) {
+		print(vi);
+		std::cout << delimiter;
+		// printf("%s", delimiter);
+	}
+	std::cout << endline;
+	//printf("%s", endline);
+}
+
+template <class T, template<typename> class VT>
+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

server/server.vcxproj

@@ -29,28 +29,32 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>false</EnableASAN>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
+    <EnableASAN>true</EnableASAN>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
@@ -91,6 +95,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -108,6 +113,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -125,6 +131,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -142,6 +149,7 @@
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <LanguageStandard>stdcpplatest</LanguageStandard>
+      <LanguageStandard_C>stdc17</LanguageStandard_C>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

server/table.h

@@ -34,7 +34,7 @@ public:
 	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) {}
-	void init() { ty = types::Types<_Ty>::getType();  this->size = this->capacity = 0; this->container = 0; }
+	void init(const char* name = "") { ty = types::Types<_Ty>::getType();  this->size = this->capacity = 0; this->container = 0; this->name = name; }
 	ColRef(const char* name, types::Type_t ty) : name(name), ty(ty) {}
 	using vector_type<_Ty>::operator[];
 	using vector_type<_Ty>::operator=;
@@ -97,6 +97,12 @@ public:
 			std::cout << this->operator[](i)<< sep;
 		std::cout << ')';
 	}
+	operator ColRef<_Ty>() {
+		auto ret = ColRef<_Ty>(size);
+		for (uint32_t i = 0; i < size; ++i)
+			ret[i] = orig[idxs[i]];
+		return ret;
+	}
 };
 template <template <class...> class VT, class T>
 std::ostream& operator<<(std::ostream& os, const VT<T>& v)

server/vector_type.hpp

@@ -84,7 +84,7 @@ public:
 	template <template <class> class VT>
 	vector_type<_Ty> operator =(const VT<_Ty>& vt) {
 		if (capacity > 0) free(container);
-		container = static_cast<_Ty*>(malloc(size * sizeof(_Ty)));
+		container = static_cast<_Ty*>(malloc(vt.size * sizeof(_Ty)));
 		
 		size = vt.size;
 		capacity = size;