//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; }
//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; }
/* void addTupleToBlock(Tuple tuple, MainMemory &mem) { //===================Block============================= cout << "===================Block=============================" << endl; // Set up a block in the memory // cout << "Clear the memory block 0" << endl; // Block* block_ptr=mem.getBlock(0); //access to memory block 0 // block_ptr->clear(); //clear the block // A block stores at most 2 tuples in this case // -----------first tuple----------- cout << "Set the tuple at offset 0 of the memory block 0" << endl; block_ptr->setTuple(0,tuple); // You can also use appendTuple() cout << "Now the memory block 0 contains:" << endl; cout << *block_ptr << endl; cout << "The block is full? " << (block_ptr->isFull()==1?"true":"false") << endl; cout << "The block currently has " << block_ptr->getNumTuples() << " tuples" << endl; cout << "The tuple at offset 0 of the block is:" << endl; cout << block_ptr->getTuple(0) << endl << endl; return; } */ void processInsert(string line, vector<string> cmdStr, SchemaManager schema_manager, MainMemory &mem) { string tableName = cmdStr[2]; Relation* relation_ptr = schema_manager.getRelation(tableName); cout << "Inside the INSERT function" << endl; int memory_block_index=0; //====================Tuple============================= cout << "====================Tuple=============================" << endl; // Set up the first tuple Tuple tuple = relation_ptr->createTuple(); //The only way to create a tuple is to call "Relation" printRelation(relation_ptr); vector<string> insertStr = splitString(line, "\()"); vector<string> attr = splitString(insertStr[1], ", "); vector<string> val = splitString(insertStr[3], ", "); /* TODO commented unordered insert giving errors for (int i = 0; i < attr.size(); i++) { if (tuple.getSchema().getFieldType(i)==INT){ cout << "Errored?? " << endl; tuple.setField(attr[i], atoi(val[i].c_str())); } else{ tuple.setField(attr[i], val[i]); } } */ for (int i = 0; i < attr.size(); i++) { //cout << "HAHAHHAHHA " << tuple.getField(attr[i])[0] << endl << endl; if (tuple.getSchema().getFieldType(attr[i])==INT){ //if (tuple.getField(attr[i])==INT){ cout << "Errored?? " << endl; tuple.setField(attr[i], atoi(val[i].c_str())); } else{ tuple.setField(attr[i], val[i]); } } // TODO to send file //see that tuple was properly filled printTuple(tuple); cout << "My test function on blocks " << endl; memory_block_index = findBlockForTuple(mem); appendTupleToRelation(relation_ptr, mem, memory_block_index, tuple); //addTupleToBlock(tuple, mem); cout << "After insertion of tuble now the reation stuff is " << endl; printRelation(relation_ptr); // Now write the tuple in a Disk Block. /* vector<string>::iterator it; cout << "Printing new things" << endl; for(it=str.begin(); it!=str.end(); ++it) { cout << *it << endl; } */ return; }
bool Block::setTuple(int tuple_offset, const Tuple& tuple) { // sets new tuple value at tuple_index; returns false if tuple_index out of bound Schema s = tuple.getSchema(); if (!tuples.empty()) { if (tuple_offset>=tuples.front().getTuplesPerBlock()) { cerr << "setTuple ERROR: tuple offet " << tuple_offset << " out of bound of the block" << endl; return false; } for (int i=0;i<tuples.size();i++) { if (s!=tuples[i].getSchema()) { cerr << "setTuple ERROR: tuples' schemas do not match" << endl; return false; } } } if (tuple_offset<0 || tuple_offset>=s.getTuplesPerBlock()) { cerr << "setTuple ERROR: tuple offet " << tuple_offset << " out of bound" << endl; return false; } if (tuple_offset >= tuples.size()) { //If there is a gap before the offset, filled it with invalid tuples Tuple t(tuple.schema_manager,tuple.schema_index); t.null(); for (int i=tuples.size();i<tuple_offset;i++) { tuples.push_back(t); } tuples.push_back(tuple); } else tuples[tuple_offset]=tuple; return true; }
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; }
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; }
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); } }
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 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 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 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; }
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; } }
void processInsert(string line, vector<string> cmdStr, SchemaManager schema_manager, MainMemory &mem) { string tableName = cmdStr[2]; Relation* relation_ptr = schema_manager.getRelation(tableName); cout << "Inside the INSERT function" << endl; //====================Tuple============================= cout << "====================Tuple=============================" << endl; // Set up the first tuple Tuple tuple = relation_ptr->createTuple(); //The only way to create a tuple is to call "Relation" //printRelation(relation_ptr); vector<string> insertStr = splitString(line, "\()"); vector<string> attr = splitString(insertStr[1], ", "); vector<string> val = splitString(insertStr[3], ", "); for (int i = 0; i < attr.size(); i++) { if (tuple.getSchema().getFieldType(i)==INT){ tuple.setField(attr[i], atoi(val[i].c_str())); } else{ tuple.setField(attr[i], val[i]); } } //see that tuple was properly filled printTuple(tuple); // Now write the tuple in a Disk Block. /* vector<string>::iterator it; cout << "Printing new things" << endl; for(it=str.begin(); it!=str.end(); ++it) { cout << *it << endl; } */ return; }
Relation* Insert(vector<string> &words, string &line, SchemaManager &schema_manager, MainMemory &mem){ Relation* relation_ptr = schema_manager.getRelation(words[2]); vector<string>::iterator it = find(words.begin(), words.end(), "SELECT"); // no select if (it == words.end()){ // get insert vals vector<string> content = splitBy(line, "()"); vector<string> fields = splitBy(content[1], ", "); vector<string> vals = splitBy(content[3], ","); //preProcess(vector<string>(1, words[2]), fields, schema_manager); preProcess(vector<string>(1, words[2]), vals, schema_manager); assert(fields.size() == vals.size()); Tuple tuple = relation_ptr->createTuple(); // standard insert doesn't have table names vector<string> col_names = nakedFieldNames(relation_ptr); // comparing for (int i = 0; i < fields.size(); i++){ for (int j = 0; j < col_names.size(); j++){ // this is a match if (fields[i] == col_names[j]){ if (tuple.getSchema().getFieldType(j) == INT){ tuple.setField(j, atoi(vals[i].c_str())); } else{ tuple.setField(j, vals[i]); } break; } } } appendTupleToRelation(relation_ptr, mem, tuple); } // with SELECT else{ vector<string> SFW(it, words.end()); Relation* new_relation = Select(SFW, schema_manager, mem); assert(new_relation); vector<string> new_field_names = nakedFieldNames(new_relation); vector<string> field_names = nakedFieldNames(relation_ptr); // mapping: index of new_field_names to field_names vector<int> mapping(new_field_names.size(), -1); for (int i = 0; i < new_field_names.size(); i++){ for (int j = 0; j < field_names.size(); j++){ if (new_field_names[i] == field_names[j]){ mapping[i] = j; break; } } } int new_field_size = new_relation->getSchema().getNumOfFields(); // warning: new_relation and relation_ptr might be the same! // get all tuples from the new_relation in one run vector<Tuple> new_tuples; for (int i = 0; i < new_relation->getNumOfBlocks(); i++){ assert(!free_blocks.empty()); int memory_block_index = free_blocks.front(); free_blocks.pop(); // read the relation block by block new_relation->getBlock(i, memory_block_index); Block* block_ptr = mem.getBlock(memory_block_index); assert(block_ptr); vector<Tuple> block_tuples = block_ptr->getTuples(); new_tuples.insert(new_tuples.end(), block_tuples.begin(), block_tuples.end()); if(new_tuples.empty()){ cerr<<"Warning: Insert from SFW, No tuples in the current mem block!"<<endl; } free_blocks.push(memory_block_index); } for (int j = 0; j < new_tuples.size(); j++){ Tuple tuple = relation_ptr->createTuple(); for (int k = 0; k < new_field_size; k++){ if (mapping[k] != -1){ int idx = mapping[k]; assert(idx < relation_ptr->getSchema().getNumOfFields() && idx >= 0); if (tuple.getSchema().getFieldType(idx) == INT){ int val = new_tuples[j].getField(k).integer; tuple.setField(field_names[idx], val); } else{ string *str = new_tuples[j].getField(k).str; tuple.setField(field_names[idx], *str); } } } appendTupleToRelation(relation_ptr, mem, tuple); } cout<<*relation_ptr<<endl; } return relation_ptr; }
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; }