//To check whether the tuple is valid for a Natural Join
bool isJoinTuple(Tuple t1, Tuple t2, vector<string> fields1, vector<string> fields2, vector<string> op)
{
if(op.size() == 0)
return true;
else for(int i=0; i<op.size(); i++)
{
//cout<<"Operator: "<<op[i]<<" "<<fields2[i]<<endl;
if(op[i] == "=")
{
if(t1.getSchema().getFieldType(fields1[i]) == INT && (t1.getField(fields1[i]).integer == t2.getField(fields2[i]).integer))
continue;
else if(t1.getSchema().getFieldType(fields1[i]) == STR20 && (*(t1.getField(fields1[i]).str) == *(t2.getField(fields2[i]).str)))
continue;
else return false;
}
else if(op[i] == ">")
{
if(t1.getSchema().getFieldType(fields1[i]) == INT && (t1.getField(fields1[i]).integer > t2.getField(fields2[i]).integer))
continue;
else return false;
}
else if(op[i] == "<")
{
if(t1.getSchema().getFieldType(fields1[i]) == INT && (t1.getField(fields1[i]).integer < t2.getField(fields2[0]).integer))
continue;
else return false;
}
else return false;
}
return true;
}
//Compare two tuples
//Return true if equals else returns false
bool IsEqual(Tuple t1, Tuple t2)
{
if(t1.isNull() || t2.isNull()) return false;
Schema st1 = t1.getSchema();
Schema st2 = t2.getSchema();
if(st1!=st2) return false;
vector<string> fieldNames = st1.getFieldNames();
vector<string>::iterator iter;
for(iter = fieldNames.begin(); iter!=fieldNames.end(); iter++)
{
if(st1.getFieldType(*iter) == INT)
{
if(t1.getField(*iter).integer != t2.getField(*iter).integer)
return false;
}
else
{
string val1 = *(t1.getField(*iter).str);
string val2 = *(t2.getField(*iter).str);
if(val1 != val2)
return false;
}
}
return true;
}
bool IsEqualTuples(Tuple tup1, Tuple tup2)
{
if(tup1.isNull() || tup2.isNull()) return false;
Schema schemat1 = tup1.getSchema();
Schema schemat2 = tup2.getSchema();
if(schemat1!=schemat2) return false;
vector<string> field_names = schemat1.getFieldNames();
vector<string>::iterator myiterator;
for(myiterator = field_names.begin(); myiterator!=field_names.end(); myiterator++)
{
if(schemat1.getFieldType(*myiterator) == INT)
{
if(tup1.getField(*myiterator).integer != tup2.getField(*myiterator).integer)
return false;
}
else
{
string val1 = *(tup1.getField(*myiterator).str);
string val2 = *(tup2.getField(*myiterator).str);
if(val1 != val2)
return false;
}
}
return true;
}
bool compare(Tuple tuple1, Tuple tuple2) {
Schema tupleSchema = tuple1.getSchema();
for(int i=0;i<tuple1.getNumOfFields();i++) {
if(tupleSchema.getFieldType(i) == INT) {
if(tuple1.getField(i).integer != tuple2.getField(i).integer)
return false;
}
else {
if(*(tuple1.getField(i).str) != *(tuple2.getField(i).str))
return false;
}
}
return true;
}
void printTuple(Tuple tuple){
// Print the information about the tuple
cout << "Created a tuple " << tuple << " through the relation" << endl;
cout << "The tuple is invalid? " << (tuple.isNull()?"TRUE":"FALSE") << endl;
Schema tuple_schema = tuple.getSchema();
cout << "The tuple has schema" << endl;
cout << tuple_schema << endl;
cout << "A block can allow at most " << tuple.getTuplesPerBlock() << " such tuples" << endl;
cout << "The tuple has fields: " << endl;
for (int i=0; i<tuple.getNumOfFields(); i++) {
if (tuple_schema.getFieldType(i)==INT)
cout << tuple.getField(i).integer << "\t";
else
cout << *(tuple.getField(i).str) << "\t";
}
cout << endl << endl;
}
bool Tuple_Comparison::operator()(Tuple& tuple1, Tuple& tuple2)
{
if(tuple1.isNull() && tuple2.isNull())
return false;
if((!tuple1.isNull()) && tuple2.isNull())
return true;
if(tuple1.isNull() && (!tuple2.isNull()))
return false;
vector<string>::iterator start = field_names.begin();
vector<string>::iterator stop = field_names.end();
vector<string>::iterator index;
Schema schema_tuple1 = tuple1.getSchema();
Schema schema_tuple2 = tuple2.getSchema();
// cout<< "comparing "<<tuple1<<" "<<tuple2<<endl;
if(schema_tuple1 != schema_tuple2)
throw string("Error!! Tuple comparison failed - Tuple_Comparison::operator()");
for(index = start; index!=stop; index++)
{
string column_name = *index;
FIELD_TYPE field_type = schema_tuple1.getFieldType(column_name);
if(field_type == INT)
{
int value1, value2;
value1 = tuple1.getField(column_name).integer;
value2 = tuple2.getField(column_name).integer;
if(value1 != value2)
return value1<value2;
}
else //FIELD_TYPE == STR20
{
string value1, value2;
value1 = *(tuple1.getField(column_name).str);
value2 = *(tuple2.getField(column_name).str);
if(value1.compare(value2) < 0) return true;
else if(value1.compare(value2) > 0) return false;
}
}
return false;
}
string getColumnValues(string expression, Tuple tuple) {
stringstream ss(expression);
char c;
string internal;
string str;
while(ss.get(c)) {
if(c=='(' || c==')' || c=='*' || c=='/' || c=='+' || c=='-' || isdigit(c) || c==' ') {
if(!str.empty())
internal.append(to_string(tuple.getField(str).integer));
internal.push_back(c);
str = "";
}
else
str.push_back(c);
}
if(!str.empty()) internal.append(to_string(tuple.getField(str).integer));
return internal;
}
bool CompareTuple::operator()(Tuple& first, Tuple& second)
{
if(first.isNull() && second.isNull())
return false;
if((!first.isNull()) && second.isNull())
return true;
if(first.isNull() && (!second.isNull()))
return false;
vector<string>::iterator beg = fieldNames.begin();
vector<string>::iterator end = fieldNames.end();
vector<string>::iterator i;
Schema tupleSchemaOne = first.getSchema();
Schema tupleSchemaTwo = second.getSchema();
// cout<< "comparing "<<first<<" "<<second<<endl;
if(tupleSchemaOne != tupleSchemaTwo)
throw string("Tuple Schema Comparision Error!!!! - In PUtility::ComapreTuple::Opeartor()");
for(i = beg; i!=end; i++)
{
string colName = *i;
FIELD_TYPE ftype = tupleSchemaOne.getFieldType(colName);
if(ftype == INT)
{
int firstVal, secVal;
firstVal = first.getField(colName).integer;
secVal = second.getField(colName).integer;
if(firstVal != secVal)
return firstVal<secVal;
}
else //FIELD_TYPE == STR20
{
string firstVal, secVal;
firstVal = *(first.getField(colName).str);
secVal = *(second.getField(colName).str);
if(firstVal.compare(secVal) < 0) return true;
else if(firstVal.compare(secVal) > 0) return false;
//else == 0, continue comparing next tuple
}
}
return false;
}
void Mapping_Tuple(Tuple map_tuple, string table_name)
{
Schema schema_tuple = map_tuple.getSchema();
vector<string> map_column_names = schema_tuple.getFieldNames();
vector<string>::iterator myiterator;
for(myiterator = map_column_names.begin(); myiterator!=map_column_names.end(); myiterator++)
{
FIELD_TYPE field_typ = schema_tuple.getFieldType(*myiterator);
Field value = map_tuple.getField(*myiterator);
TColPair tcolpair1 = TColPair(table_name, *myiterator);
TColPair tcolpair2 = TColPair(NOT_A_TABLE, *myiterator);
FValue values = FValue(field_typ, value);
Column_Value_Mapping[tcolpair1] = values;
Column_Value_Mapping[tcolpair2] = values;
}
}
void MapTupleValues(Tuple t, string tableName)
{
Schema tupleSchema = t.getSchema();
vector<string> columnNames = tupleSchema.getFieldNames();
vector<string>::iterator iter;
for(iter = columnNames.begin(); iter!=columnNames.end(); iter++)
{
FIELD_TYPE ft = tupleSchema.getFieldType(*iter);
Field value = t.getField(*iter);
TableColumnPair tcpair = TableColumnPair(tableName, *iter);
TableColumnPair tcpair2 = TableColumnPair(NO_TABLE, *iter);
Value val = Value(ft, value);
ColumnValueMap[tcpair] = val;
ColumnValueMap[tcpair2] = val;
}
}
void join(Tuple tuple1, Tuple tuple2, string tableName1, string tableName2, string whereCondition, bool multi, vector<string> attributes) {
Relation *relation = schemaManager.getRelation(tableName2+"_join");
Tuple tuple =relation->createTuple();
if(!multi) {
for(int i=0;i<tuple1.getNumOfFields();i++) {
if(tuple1.getSchema().getFieldType(i) == INT)
tuple.setField(tableName1+"."+tuple1.getSchema().getFieldName(i), tuple1.getField(i).integer);
else
tuple.setField(tableName1+"."+tuple1.getSchema().getFieldName(i), *(tuple1.getField(i).str) );
}
}
else {
for(int i=0;i<tuple1.getNumOfFields();i++) {
if(tuple1.getSchema().getFieldType(i) == INT)
tuple.setField(tuple1.getSchema().getFieldName(i), tuple1.getField(i).integer);
else
tuple.setField(tuple1.getSchema().getFieldName(i), *(tuple1.getField(i).str) );
}
}
for(int i=0;i<tuple2.getNumOfFields();i++) {
if(tuple2.getSchema().getFieldType(i) == INT)
tuple.setField(tableName2+"."+tuple2.getSchema().getFieldName(i), tuple2.getField(i).integer);
else
tuple.setField(tableName2+"."+tuple2.getSchema().getFieldName(i), *(tuple2.getField(i).str) );
}
if((attributes.size()==1 && attributes[0]=="*") || multi) {
if(whereConditionEvaluator(whereCondition, tuple))
insertTuple(tableName2+"_join", tuple);
}
else {
Relation *relation1 = schemaManager.getRelation(tableName2+"_joinp");
Tuple tuplep = relation1->createTuple();
for(int i=0;i<attributes.size();i++) {
if(tuplep.getSchema().getFieldType(attributes[i]) == INT)
tuplep.setField(attributes[i], tuple.getField(attributes[i]).integer);
else
tuplep.setField(attributes[i], *(tuple.getField(attributes[i]).str));
}
if(whereConditionEvaluator(whereCondition, tuple))
insertTuple(tableName2+"_joinp", tuplep);
}
}
void Mapping_Tuple(Tuple map_tuple)
{
Schema schema_tuple = map_tuple.getSchema();
vector<string> myColmNames = schema_tuple.getFieldNames();
vector<string>::iterator myiterator;
for(myiterator = myColmNames.begin(); myiterator!=myColmNames.end(); myiterator++)
{
int period_position = (*myiterator).find_first_of('.');
int len = (*myiterator).length();
if(period_position == string::npos) throw string("Error in column Mapping");
string tbl_name = (*myiterator).substr(0, period_position);
string col_name = (*myiterator).substr(period_position+1, len - period_position - 1);
FIELD_TYPE fieldtype = schema_tuple.getFieldType(*myiterator);
Field myvalue = map_tuple.getField(*myiterator);
TColPair tcolpair = TColPair(tbl_name, col_name);
FValue value = FValue(fieldtype, myvalue);
Column_Value_Mapping[tcolpair] = value;
}
}
void MapTupleValues(Tuple t)
{
Schema tupleSchema = t.getSchema();
vector<string> columnNames = tupleSchema.getFieldNames();
vector<string>::iterator iter;
for(iter = columnNames.begin(); iter!=columnNames.end(); iter++)
{
int dotPos = (*iter).find_first_of('.');
int len = (*iter).length();
if(dotPos == string::npos) throw string("Error in column Mapping");
string tableName = (*iter).substr(0, dotPos);
string colName = (*iter).substr(dotPos+1, len - dotPos - 1);
FIELD_TYPE ft = tupleSchema.getFieldType(*iter);
Field value = t.getField(*iter);
TableColumnPair tcpair = TableColumnPair(tableName, colName);
Value val = Value(ft, value);
ColumnValueMap[tcpair] = val;
}
}
int conditionMatches(Tuple tuple, vector<string> tokens, int op) {
Schema schema = tuple.getSchema();
bool flag1=false, flag2=false;
if(ifExists(tokens[1], "\\+|\\/|\\-|\\/|\\(|\\)|\\*") || ifExists(tokens[0], "\\+|\\/|\\-|\\/|\\(|\\)|\\*")) {
return eval(tuple, tokens, op);
}
for(int i=0;i<schema.getNumOfFields();i++) {
if(schema.getFieldName(i) == tokens[0])
flag1=true;
if(schema.getFieldName(i) == tokens[1])
flag2=true;
}
if(flag1 && flag2) {
if(tuple.getSchema().getFieldType(tokens[0]) == INT) {
switch(op) {
case 0:
if(tuple.getField(tokens[0]).integer == tuple.getField(tokens[1]).integer)
return 0;
else return 1;
case 1:
if(tuple.getField(tokens[0]).integer > tuple.getField(tokens[1]).integer)
return 0;
else return 1;
case 2:
if(tuple.getField(tokens[0]).integer < tuple.getField(tokens[1]).integer)
return 0;
else return 1;
}
}
else {
if(*(tuple.getField(tokens[1]).str) == *(tuple.getField(tokens[1]).str)) return 0;
else return 1;
}
}
if(flag1)
{
if(tuple.getSchema().getFieldType(tokens[0]) == INT) {
int fieldValue = tuple.getField(tokens[0]).integer;
if(isNumber(tokens[1])){
switch (op) {
case 0:
if(fieldValue == stoi(tokens[1]))
return 0;
else
return 1;
case 1:
if(fieldValue > stoi(tokens[1]))
return 0;
else
return 1;
case 2:
if(fieldValue < stoi(tokens[1]))
return 0;
else
return 1;
}
}
}
else {
regex exp("\\ *\"(.*)\"");
cmatch match;
if(regex_match(tokens[1].c_str(),match,exp))
{
string* fieldValue = tuple.getField(tokens[0]).str;
if(*fieldValue == match[1])
return 0;
else
return 1;
}
}
}
return 0;
}
