FindQuery

7 files changed, 193 insertions, 60 deletions

diff --git a/Makefile b/Makefile
index 381b573..acef217 100644
--- a/Makefile
+++ b/Makefile
@@ -1,30 +1,23 @@
-CC=gcc
-CXX=g++
-CFLAGS=-Wall -O2
-CPPFLAGS=-Wall -O2 -std=c++11
+CXXFLAGS = -Wall -O2 -std=c++11
+CXX = g++
 
-BINARIES=engine
-OBJS=enginedata.o util.o
-DEPFILES=$(OBJS:.o=.d)
+BINARIES = engine
+CXX_FILES = $(shell echo *.cpp)
+H_FILES = *.h
+OBJ_FILES = $(CXX_FILES:.cpp=.o)
 
-
-.PHONY: all clean
+.PHONY: all clean remake
 
 all: $(BINARIES)
 
 clean:
-	rm -f $(BINARIES) $(OBJS) $(DEPFILES)
-
-
--include $(OBJS:.o=.d)
-
+	rm -f $(BINARIES) $(OBJ_FILES)
 
-engine: engine.cpp enginedata.o util.o
-	$(CXX) $(CPPFLAGS) -o $@ $^
+remake: clean all
 
-enginedata: enginedata.cpp enginedata.h util.o
-	$(CXX) $(CPPFLAGS) -o %@ enginedata.cpp
+engine: $(OBJ_FILES)
+	$(CXX) $(CXXFLAGS) -o $@ $(OBJ_FILES)
+	strip $@
 
 %.o: %.cpp %.h
-	$(CXX) $(CPPFLAGS) $*.cpp -c -o $*.o
-	$(CXX) -MM $(CPPFLAGS) $*.cpp > $*.d
+	$(CXX) $(CXXFLAGS) -c -o $*.o $*.cpp
diff --git a/Maybe.h b/Maybe.h
index 000b32f..a612d7b 100644
--- a/Maybe.h
+++ b/Maybe.h
@@ -11,6 +11,7 @@ class Maybe{
 public:
 	Maybe(void):is_something(false),wr(nullptr){}
 	Maybe(const T &_v):is_something(true),wr(new t_v_wrapper({_v})){}
+	Maybe(const T &&_v):is_something(true),wr(new t_v_wrapper({move(_v)})){}
 	~Maybe(void){if(wr)delete wr;}
 
 	operator bool() const{return this->is_something;}
diff --git a/engine.cpp b/engine.cpp
index 67c9524..098a55e 100644
--- a/engine.cpp
+++ b/engine.cpp
@@ -1,10 +1,12 @@
 #include "enginedata.h"
-#include "Maybe.h"
+#include "query.h"
 #include <iostream>
 #include <vector>
 #include <map>
 #include <list>
+#include <utility>
 #include <cstdlib>
+#include <cstring>
 #include <climits>
 
 using namespace std;
@@ -13,25 +15,46 @@ using namespace std;
 map<string,Table> tables;
 
 
+template <class... T>
+void createTable(string name,T&&... args){
+	//const Table tbl=Table(forward<T>(args)...);
+	//tables.emplace(tbl.name,move(tbl));
+	tables.emplace(piecewise_construct,
+	               forward_as_tuple(name),
+	               forward_as_tuple(name,forward<T>(args)...));
+}
+
+
 int main(int argc,char **argv){
 	ColHeader *header=new ColHeader[3];
 	header[0]={RH_INT32,0};
 	header[1]={RH_UINT32,0};
 	header[2]={RH_BYTES,10};
-	tables.emplace("hoi",Table("hoi",3,header));
+	//tables.emplace("hoi",Table("hoi",3,header));
+	createTable("hoi",3,header);
 	Table *hoitb=&tables.at("hoi");
 	Row row(3,hoitb);
-	row.items[0].u.rh_int32=UINT_MAX;
-	row.items[1].u.rh_uint32=UINT_MAX;
-	row.items[2].u.rh_bytes=new unsigned char[10];
-	strcpy((char*)row.items[2].u.rh_bytes,"hallo daar");
+	row.items[0].rh_int32=UINT_MAX;
+	row.items[1].rh_uint32=UINT_MAX;
+	row.items[2].rh_bytes=new unsigned char[10];
+	strcpy((char*)row.items[2].rh_bytes,"hallo daar");
+	// cerr<<row.items[2].rh_bytes<<endl;
 	if(!hoitb->insert(row))cout<<"Failed to insert row!"<<endl; else cout<<"Success."<<endl;
 	if(!hoitb->insert(row))cout<<"Failed to insert row!"<<endl; else cout<<"Success."<<endl;
 	cout<<"hoitb has "<<hoitb->rows.size()<<" row"<<(hoitb->rows.size()==1?"":"s")<<'.'<<endl;
-	list<Row> found=hoitb->find(serialise((int32_t)-1));
+	/*list<Row> found=hoitb->find(serialise((int32_t)-1));
 	cout<<"Found for key -1:"<<endl;
 	for(Row r : found){
 		cout<<r<<endl;
+	}*/
+	FindQuery qu;
+	qu.from="hoi";
+	RowItem ri; ri.rh_int32=-1;
+	qu.where.emplace_back(0,ri);
+	QueryResult res=qu.execute(tables);
+	cout<<"Result: "<<res.res<<":"<<endl;
+	for(const Row &r : res.rows){
+		cout<<"- "<<r<<endl;
 	}
 	return 0;
 }
diff --git a/enginedata.cpp b/enginedata.cpp
index ecb4c82..95a2b11 100644
--- a/enginedata.cpp
+++ b/enginedata.cpp
@@ -13,7 +13,6 @@ Row::~Row(void){
 	if(items)delete[] items;
 }
 Row::Row(Row &&other):nc(other.nc),table(other.table),items(other.items){ //move constr
-	other.table=nullptr;
 	other.items=nullptr;
 }
 Row::Row(const Row &other):nc(other.nc),table(other.table){ //copy constr
@@ -39,6 +38,9 @@ Table::Table(const string &_n,const int _nc,const ColHeader *const _hd):name(_n)
 Table::~Table(void){
 	if(header)delete[] header;
 }
+Table::Table(const Table &other):name(other.name),nc(other.nc),rows(other.rows){
+	memcpy(header,other.header,nc*sizeof(ColHeader));
+}
 Table::Table(Table &&other):name(move(other.name)),nc(other.nc),header(other.header),rows(move(other.rows)){
 	other.header=nullptr;
 }
@@ -54,30 +56,34 @@ bool Table::insert(Row &row){
 	return rows.emplace(key,row).second;
 }
 
-list<Row> Table::find(const string &key){
-	typedef map<string,Row>::const_iterator cit_t;
-	cit_t end=rows.cend();
-	list<Row> ret;
-	for(cit_t it=rows.cbegin();it!=end;it++){
-		if(serialise(it->second.table->header[0],it->second.items[0])==key)
-			ret.emplace_back(it->second);
-	}
-	return ret;
-}
-
 
 string serialise(const ColHeader &header,const RowItem &rowitem){
 	switch(header.type){
-	case RH_INT32:
-		return serialise(rowitem.u.rh_int32);
-	case RH_UINT32:
-		return serialise(rowitem.u.rh_uint32);
-	case RH_BYTES:
-		return serialise(rowitem.u.rh_bytes,header.arg);
-	default:
-		assert(false);
+	case RH_INT32:  return serialise(rowitem.rh_int32);
+	case RH_UINT32: return serialise(rowitem.rh_uint32);
+	case RH_BYTES:  return serialise(rowitem.rh_bytes,header.arg);
+	default: assert(false);
 	}
 }
 string serialise(int32_t v){return to_string(v);}
 string serialise(uint32_t v){return to_string(v);}
 string serialise(unsigned char *v,int len){return string((char*)v,len);}
+
+int riCompare(const ColHeader &header,const RowItem &ri1,const RowItem &ri2){
+	switch(header.type){
+	case RH_INT32:  return riCompare(ri1.rh_int32,ri2.rh_int32);
+	case RH_UINT32: return riCompare(ri1.rh_uint32,ri2.rh_uint32);
+	case RH_BYTES:  return riCompare(ri1.rh_bytes,ri2.rh_bytes,header.arg);
+	default: assert(false);
+	}
+}
+int riCompare(int32_t v1,int32_t v2){return v1-v2;}
+int riCompare(uint32_t v1,uint32_t v2){return v1-v2;}
+int riCompare(unsigned char *v1,unsigned char *v2,int len){
+	int i;
+	cerr<<"Comparing "<<(void*)v1<<" ("<<v1<<") and "<<(void*)v2<<" ("<<v2<<')'<<endl;
+	for(i=0;i<len;i++){
+		if(v1[i]!=v2[i])return v1[i]-v2[i];
+	}
+	return 0;
+}
diff --git a/enginedata.h b/enginedata.h
index e5d488e..9cf0b53 100644
--- a/enginedata.h
+++ b/enginedata.h
@@ -3,7 +3,6 @@
 #include <string>
 #include <map>
 #include <list>
-#include "Maybe.h"
 
 using namespace std;
 
@@ -12,18 +11,10 @@ struct Row;
 struct ColHeader;
 struct Table;
 
-string serialise(const ColHeader &header,const RowItem &rowitem);
-string serialise(int32_t v);
-string serialise(uint32_t v);
-string serialise(unsigned char *v,int len);
-
-
 struct RowItem{
-	union { //watch the pointerness or not-pointerness of the attributes!
-		int32_t rh_int32;
-		uint32_t rh_uint32;
-		unsigned char *rh_bytes;
-	} u;
+	int32_t rh_int32;
+	uint32_t rh_uint32;
+	unsigned char *rh_bytes;
 };
 
 enum ColHeaderType{
@@ -57,9 +48,19 @@ struct Table{
 
 	Table(const string &_n,const int _nc,const ColHeader *const _hd);
 	~Table(void);
+	Table(const Table &other);
 	Table(Table &&other);
 
 	bool insert(Row &&row);
 	bool insert(Row &row);
-	list<Row> find(const string &key);
 };
+
+string serialise(const ColHeader &header,const RowItem &rowitem);
+string serialise(int32_t v);
+string serialise(uint32_t v);
+string serialise(unsigned char *v,int len);
+
+int riCompare(const ColHeader &header,const RowItem &ri1,const RowItem &ri2);
+int riCompare(int32_t v1,int32_t v2);
+int riCompare(uint32_t v1,uint32_t v2);
+int riCompare(unsigned char *v1,unsigned char *v2,int len);
diff --git a/query.cpp b/query.cpp
new file mode 100644
index 0000000..3f3d6ec
--- /dev/null
+++ b/query.cpp
@@ -0,0 +1,68 @@
+#include "query.h"
+#include <iostream>
+
+using namespace std;
+
+
+WhereClause::WhereClause(void):col(0){}
+WhereClause::WhereClause(const int _c,const RowItem &_v):col(_c),value(_v){}
+
+
+QueryResult::QueryResult(void):res(0){}
+QueryResult::QueryResult(int _res):res(_res){}
+QueryResult::QueryResult(int _res,const vector<Row> &_rows):res(_res),rows(_rows){}
+
+
+Query::Query(void):limit(-1){}
+
+QueryResult Query::execute(const map<string,Table> &tables){return QueryResult(-1);}
+
+
+FindQuery::FindQuery(void):sort(0){};
+
+QueryResult FindQuery::execute(const map<string,Table> &tables){
+	if(limit==0)return QueryResult(0);
+	int i,j;
+	/*for(i=0;i<(int)tables.size();i++){
+		if(tables[i].name==from)break;
+	}
+	if(i==(int)tables.size())return QueryResult(0);
+	const Table &table=tables[i];*/
+	const map<string,Table>::const_iterator tit=tables.find(from);
+	if(tit==tables.cend())return QueryResult(0);
+	const Table &table=tit->second;
+
+	for(i=0;i<(int)where.size();i++){
+		if(where[i].col==0)break;
+	}
+	if(i!=(int)where.size()){
+		const map<string,Row>::const_iterator rit=table.rows.find(serialise(table.header[0],where[i].value));
+		if(rit==table.rows.cend())return QueryResult(0);
+		const Row &row=rit->second;
+		for(j=0;j<(int)where.size();j++){
+			if(j==i)continue;
+			const int col=where[j].col;
+			if(riCompare(table.header[col],row.items[col],where[j].value)!=0)break;
+		}
+		if(j!=(int)where.size())return QueryResult(0);
+		else return QueryResult(1,{row});
+	}
+
+	typedef map<string,Row>::const_iterator cit_t;
+
+	cit_t end=table.rows.cend();
+	QueryResult ret;
+	for(cit_t it=table.rows.cbegin();it!=end;it++){
+		//if(serialise(it->second.table->header[0],it->second.items[0])==key)
+		//	ret.emplace_back(it->second);
+		for(i=0;i<(int)where.size();i++){
+			const int col=where[i].col;
+			if(riCompare(table.header[col],it->second.items[col],where[i].value)!=0)break;
+		}
+		if(i==(int)where.size()){
+			ret.res++;
+			ret.rows.emplace_back(it->second);
+		}
+	}
+	return ret;
+}
diff --git a/query.h b/query.h
new file mode 100644
index 0000000..d19494e
--- /dev/null
+++ b/query.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "enginedata.h"
+#include <vector>
+#include <string>
+#include <map>
+
+using namespace std;
+
+
+struct WhereClause{
+	int col;
+	RowItem value;
+	WhereClause(void);
+	WhereClause(const int _c,const RowItem &_v);
+};
+
+
+struct QueryResult{
+	int res;
+	vector<Row> rows;
+	QueryResult(void);
+	QueryResult(int);
+	QueryResult(int,const vector<Row>&);
+};
+
+
+struct Query{
+	string from;
+	int limit; //-1=unlimited
+	Query(void);
+	virtual QueryResult execute(const map<string,Table>&);
+};
+
+struct FindQuery : public Query{
+	int sort; //0=no sort, 1=sort, -1=reverse sort
+	vector<WhereClause> where;
+	FindQuery(void);
+	QueryResult execute(const map<string,Table>&);
+};
+