1271 lines
28 KiB
C++
1271 lines
28 KiB
C++
#include <string> // std::string
|
|
#include <iostream> // std::cout
|
|
#include <fstream> // std::ofstream
|
|
#include <sstream> // std::stringstream
|
|
#include <vector>
|
|
#include <string>
|
|
#include "Parser.h"
|
|
#include <tuple>
|
|
|
|
using namespace std;
|
|
|
|
vector<string> tokenize(string ss)
|
|
{
|
|
string tempString;
|
|
stringstream lineStream(ss);
|
|
vector<string> output;
|
|
|
|
while (lineStream >> tempString)
|
|
{
|
|
output.push_back(tempString);
|
|
}
|
|
|
|
//testing---------------
|
|
//cout<<"TokenList: ";
|
|
|
|
// for (int i = 0; i <output.size(); ++i)
|
|
// {
|
|
// cout<<output[i]<<" ";
|
|
// }
|
|
// cout << endl;
|
|
//----------------------
|
|
|
|
return output;
|
|
}
|
|
|
|
void displayTokenList(vector<string> input)
|
|
{
|
|
cout<<"TokenList: "<<endl;
|
|
for (int i = 0; i < input.size(); ++i)
|
|
{
|
|
cout<<input[i]<<endl;
|
|
}
|
|
}
|
|
|
|
Relation condition(vector<string> input, Relation &r)
|
|
{
|
|
Relation rfinal = r;
|
|
|
|
//UNTESTED
|
|
//testing to see if there is an && or || present
|
|
if (input.size() > 3) {
|
|
//test print
|
|
for (int i = 0; i < input.size(); ++i)
|
|
cout << "input[i]: " << input[i] << "\n";
|
|
|
|
|
|
//this is probably wrong, added a cout for testing
|
|
string bin_op = input[3];
|
|
cout << "bin_op, should be && or ||: " << bin_op << "\n";
|
|
|
|
//making each half a new vector, probably a better way to do this
|
|
vector<string> firsthalf;
|
|
vector<string> secondhalf;
|
|
|
|
//again, all untested. it's weird to not test this stuff
|
|
for (int i = 0; i < input.size(); ++i){
|
|
if (i < 3)
|
|
firsthalf.push_back(input[i]);
|
|
else
|
|
secondhalf.push_back(input[i]);
|
|
|
|
}
|
|
|
|
//calling condition again with each half
|
|
Relation r1 = condition(firsthalf, rfinal);
|
|
Relation r2 = condition(secondhalf, rfinal);
|
|
|
|
//NO IDEA IF THIS ACTUALLY WORKS
|
|
//HOORAY
|
|
//HOW THE FUCK DO PEOPLE CODE LIKE THIS
|
|
if (bin_op == "&&"){
|
|
//with engine as the DBEngine object that maybe exists
|
|
return engine.crossProduct(r1, r2);
|
|
}
|
|
|
|
else if (bin_op == "||"){
|
|
//with engine as the DBEngine object that maybe exists
|
|
return engine.setUnion(r1, r2);
|
|
}
|
|
|
|
else {
|
|
cout << "Something strange happened. bin_op: " << bin_op << "\n";
|
|
cout << "Returning the initial relation.";
|
|
return rfinal;
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Attribute a1 = r.getAttributeByName(input[0]);
|
|
input.erase(input.begin());
|
|
string op = input[0];
|
|
input.erase(input.begin());
|
|
Attribute a2;
|
|
string c;
|
|
//cout << input[0] << endl;
|
|
if(input[0].at(0) == '\"')
|
|
{
|
|
c = input[0].substr(1, input[0].find_last_of("\"") - 1);
|
|
//cout << c << endl;
|
|
}
|
|
if(r.isAttribute(input[0]))
|
|
{
|
|
a2 = r.getAttributeByName(input[0]);
|
|
input.erase(input.begin());
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
/*
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size; ++j)
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getValues()[j] == )
|
|
{
|
|
rfinal.insertTuple(r.getTuple(j));
|
|
}
|
|
}*/
|
|
if(op == "==")
|
|
{
|
|
for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x)
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getValues()[x] != r.getAttributeByName(a2.getName()).getValues()[x])
|
|
{
|
|
rfinal.removeTuple(x);
|
|
//rfinal.insertAttributes(a);
|
|
}
|
|
}
|
|
}
|
|
else if(op == "!=")
|
|
{
|
|
for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x)
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getValues()[x] == r.getAttributeByName(a2.getName()).getValues()[x])
|
|
{
|
|
rfinal.removeTuple(x);
|
|
//rfinal.insertAttributes(a);
|
|
}
|
|
}
|
|
}
|
|
else if(op == ">=")
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) < stoi(r.getAttributeByName(a2.getName()).getValues()[x]))
|
|
{
|
|
rfinal.removeTuple(x);
|
|
//rfinal.insertAttributes(a);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
else if(op == "<=")
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) > stoi(r.getAttributeByName(a2.getName()).getValues()[x]))
|
|
{
|
|
rfinal.removeTuple(x);
|
|
//rfinal.insertAttributes(a);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
else if(op == ">")
|
|
{
|
|
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) <= stoi(r.getAttributeByName(a2.getName()).getValues()[x]))
|
|
{
|
|
rfinal.removeTuple(x);
|
|
//rfinal.insertAttributes(a);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
else if(op == "<")
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER" && r.getAttributeByName(a2.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int x = 0; x < r.getAttributeByName(a1.getName()).getSize(); ++x)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[x]) >= stoi(r.getAttributeByName(a2.getName()).getValues()[x]))
|
|
{
|
|
rfinal.removeTuple(x);
|
|
//rfinal.insertAttributes(a);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
input.erase(input.begin());
|
|
if(op == "==")
|
|
{
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j)
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getValues()[j] != c)
|
|
{
|
|
rfinal.removeTuple(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(op == "!=")
|
|
{
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j)
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getValues()[j] == c)
|
|
{
|
|
rfinal.removeTuple(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(op == ">=")
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) < stoi(c))
|
|
{
|
|
rfinal.removeTuple(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
else if(op == "<=")
|
|
{
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) > stoi(c))
|
|
{
|
|
rfinal.removeTuple(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
else if(op == ">")
|
|
{
|
|
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) <= stoi(c))
|
|
{
|
|
rfinal.removeTuple(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
else if(op == "<")
|
|
{
|
|
|
|
if(r.getAttributeByName(a1.getName()).getType() == "INTEGER")
|
|
{
|
|
for(int i = 0; i < r.getAttributes().size(); ++i)
|
|
{
|
|
if(r.getAttributes()[i].getName() == a1.getName())
|
|
{
|
|
for(int j = 0; j < r.getAttributeByName(a1.getName()).getValues().size(); ++j)
|
|
{
|
|
if(stoi(r.getAttributeByName(a1.getName()).getValues()[j]) >= stoi(c))
|
|
{
|
|
rfinal.removeTuple(j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Attribute type is not an INTEGER." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
return rfinal;
|
|
}
|
|
}
|
|
|
|
tuple<vector<string>, Relation> expression(vector<string> input, DBEngine &engine)
|
|
{
|
|
Relation rfinal("TEMP");
|
|
tuple<vector<string>, Relation> t(input, rfinal);
|
|
if(input[0] == "select")
|
|
{
|
|
/*
|
|
cout << "Not yet implemented." << endl;
|
|
exit(1);
|
|
*/
|
|
input.erase(input.begin());
|
|
vector<string> s;
|
|
Relation r("TEMP");
|
|
if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
while(input[0] != ")")
|
|
{
|
|
s.push_back(input[0]);
|
|
input.erase(input.begin());
|
|
}
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
r = condition(s, engine.getTableFromName(input[0]));
|
|
input.erase(input.begin());
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
r = condition(s, get<1>(t));
|
|
input.erase(input.begin());
|
|
}
|
|
}
|
|
get<0>(t) = input;
|
|
get<1>(t) = r;
|
|
return t;
|
|
}
|
|
|
|
else if(input[0] == "project")
|
|
{
|
|
input.erase(input.begin());
|
|
if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
vector<string> temp;
|
|
while(input[0] != ")")
|
|
{
|
|
temp.push_back(input[0]);
|
|
input.erase(input.begin());
|
|
}
|
|
input.erase(input.begin());
|
|
Relation rfinal("TEMP");
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
rfinal = engine.projection(temp, engine.getTableFromName(input[0]));
|
|
input.erase(input.begin());
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
//cout << rfinal.getSize() << endl;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
t = expression(input, engine);
|
|
rfinal = engine.projection(temp, get<1>(t));
|
|
//get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
//cout << rfinal.getSize() << endl;
|
|
return t;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Projection syntax incorrect." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
else if(input[0] == "rename")
|
|
{
|
|
input.erase(input.begin());
|
|
if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
vector<string> temp;
|
|
while(input[0] != ")")
|
|
{
|
|
if(input[0] == ",")
|
|
{
|
|
input.erase(input.begin());
|
|
}
|
|
temp.push_back(input[0]);
|
|
input.erase(input.begin());
|
|
}
|
|
input.erase(input.begin());
|
|
Relation rfinal("TEMP");
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
rfinal = engine.rename(temp, engine.getTableFromName(input[0]));
|
|
input.erase(input.begin());
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
t = expression(input, engine);
|
|
input.erase(input.begin());
|
|
rfinal = engine.rename(temp, get<1>(t));
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cout << "Rename syntax incorrect." << endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
else if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r1(engine.getTableFromName(input[0]));
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "+")
|
|
{
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r2(engine.getTableFromName(input[0]));
|
|
rfinal = engine.setUnion(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r2 = get<1>(t);
|
|
rfinal = engine.setUnion(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
else if(input[0] == "-")
|
|
{
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r2(engine.getTableFromName(input[0]));
|
|
rfinal = engine.setDiff(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r2 = get<1>(t);
|
|
rfinal = engine.setDiff(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
else if(input[0] == "*")
|
|
{
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r2(engine.getTableFromName(input[0]));
|
|
rfinal = engine.crossProduct(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r2 = get<1>(t);
|
|
rfinal = engine.crossProduct(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
}
|
|
|
|
else if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
Relation r1(engine.getTableFromName(input[0]));
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "+")
|
|
{
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r2(engine.getTableFromName(input[0]));
|
|
rfinal = engine.setUnion(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r2 = get<1>(t);
|
|
rfinal = engine.setUnion(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
else if(input[0] == "-")
|
|
{
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r2(engine.getTableFromName(input[0]));
|
|
rfinal = engine.setDiff(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r2 = get<1>(t);
|
|
rfinal = engine.setDiff(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
else if(input[0] == "*")
|
|
{
|
|
input.erase(input.begin());
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
Relation r2(engine.getTableFromName(input[0]));
|
|
rfinal = engine.crossProduct(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
else if(input[0] == "(")
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r2 = get<1>(t);
|
|
rfinal = engine.crossProduct(r1, r2);
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
}
|
|
}
|
|
|
|
get<0>(t) = input;
|
|
get<1>(t) = rfinal;
|
|
return t;
|
|
}
|
|
|
|
vector<string> showCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
/*
|
|
if (input.size() > 3)
|
|
{
|
|
cout<<"Syntax error!"<<endl;
|
|
}
|
|
*/
|
|
|
|
if(engine.isRelation(input[0]))
|
|
{
|
|
engine.getTableFromName(input[0]).display();
|
|
input.erase(input.begin());
|
|
}
|
|
|
|
else
|
|
{
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
get<1>(t).display();
|
|
}
|
|
|
|
return input;
|
|
}
|
|
|
|
vector<string> saveCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
if (input.size() > 2)
|
|
{
|
|
cout<<"Syntax error!"<<endl;
|
|
}
|
|
|
|
//PRelation pr(input[0]);
|
|
|
|
// send save command to DBEngine
|
|
engine.save(input[0]);
|
|
/*
|
|
Relation r = engine.getTableFromName(input[0]);
|
|
ofstream output;
|
|
string name = r.getTableName() + ".txt";
|
|
output.open(name);
|
|
|
|
output << "--------------------------\n";
|
|
output << r.getTableName() << "\n\n";
|
|
vector <Attribute> att = r.getAttributes();
|
|
for (int i = 0; i < att.size(); ++i)
|
|
{
|
|
output << "-------------\n";
|
|
output << att[i].getName() << "\n" << att[i].getType();
|
|
if(att[i].getType() == "VARCHAR")
|
|
{
|
|
output << "(" << att[i].getSize() << ")";
|
|
}
|
|
output << "\n\n";
|
|
|
|
vector<string> values = att[i].getValues();
|
|
vector<string>::iterator it = values.begin();
|
|
while (it != values.end())
|
|
{
|
|
output << *it << "\n";
|
|
it++;
|
|
}
|
|
output << "-------------\n";
|
|
}
|
|
output << "\n--------------------------";
|
|
*/
|
|
input.erase(input.begin());
|
|
|
|
return input;
|
|
}
|
|
|
|
vector<string> closeCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
if (input.size() > 3)
|
|
{
|
|
cout<<"Syntax error!"<<endl;
|
|
}
|
|
|
|
//PRelation r(input[0]);
|
|
|
|
// send close command to DBEngine
|
|
engine.deleteRelation(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
return input;
|
|
}
|
|
|
|
vector<string> openCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
if (input.size() > 2)
|
|
{
|
|
cout<<"Syntax error!"<<endl;
|
|
}
|
|
|
|
//PRelation r(input[0]);
|
|
|
|
// send open command to DBEngine
|
|
string name = input[0] + ".txt";
|
|
ifstream file;
|
|
file.open(name);
|
|
string line;
|
|
while(getline(file, line))
|
|
{
|
|
parse(line, engine);
|
|
}
|
|
file.close();
|
|
|
|
return input;
|
|
}
|
|
|
|
vector<string> exitCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
|
|
exit(0);
|
|
|
|
return input;
|
|
}
|
|
|
|
|
|
vector<string> createCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
//relation name will be the first element of the vector of data returned by this function
|
|
|
|
if (input[0] == "TABLE")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
PRelation r;
|
|
r.setPRelation(input[0]);
|
|
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
//vector <PExpression> e1;
|
|
|
|
vector <PAttribute> a;
|
|
|
|
while(input[0] != ")") //inserting all values to relation
|
|
{
|
|
PAttribute temp;
|
|
|
|
if (input[0] == ",")
|
|
{
|
|
input.erase(input.begin());
|
|
}
|
|
|
|
temp.setPAttributeName(input[0]);
|
|
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "INTEGER")
|
|
{
|
|
temp.setPAttributeType(input[0]);
|
|
input.erase(input.begin());
|
|
}
|
|
else
|
|
{
|
|
temp.setPAttributeType(input[0].substr(0,input[0].find("(")));
|
|
temp.setPAttributeSize(stoi(input[0].substr(input[0].find("(") + 1, input[0].find(")"))));
|
|
input.erase(input.begin());
|
|
}
|
|
|
|
a.push_back(temp);
|
|
}
|
|
|
|
//vector <PAttribute> apk; //save primary keys temp storage
|
|
|
|
if(input[0] == "PRIMARY" && input[1] == "KEY")
|
|
{
|
|
input.erase(input.begin());
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "(")
|
|
{
|
|
|
|
while(input[0] != ")") //inserting all values to relation
|
|
{
|
|
//PAttribute temp;
|
|
|
|
if (input[0] == ",")
|
|
{
|
|
input.erase(input.begin());
|
|
}
|
|
|
|
//temp.setPAttributeName(input[0]);
|
|
|
|
//apk.push_back(temp);
|
|
|
|
for(int i = 0; i < a.size(); ++i)
|
|
{
|
|
if(input[0] == a[i].getPAttribute())
|
|
{
|
|
a[i].setPAttributeKey();
|
|
}
|
|
}
|
|
|
|
input.erase(input.begin());
|
|
}
|
|
}
|
|
}
|
|
|
|
vector <Attribute> dba;
|
|
|
|
for(int x = 0; x < a.size(); ++x)
|
|
{
|
|
Attribute temp(a[x].getPAttribute(), a[x].getPAttributeType(), a[x].getPAttributeKey(), a[x].getPAttributeSize());
|
|
dba.push_back(temp);
|
|
}
|
|
|
|
engine.createTable(r.getName(), dba);
|
|
|
|
return input;
|
|
}
|
|
|
|
else cout<<"Syntax error! 2"<<endl;
|
|
}
|
|
else cout<<"Syntax error! 1"<<endl;
|
|
|
|
}
|
|
|
|
vector<string> insertCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
//relation name will be the first element of the vector of data returned by this function
|
|
|
|
if (input[0] == "INTO")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
PRelation pr(input[0]);
|
|
Relation r = engine.getTableFromName(input[0]);
|
|
|
|
input.erase(input.begin());
|
|
|
|
vector <string> s;
|
|
|
|
if (input[0] == "VALUES" && input[1] == "FROM")
|
|
{
|
|
input.erase(input.begin());
|
|
input.erase(input.begin());
|
|
|
|
|
|
vector <Attribute> a = r.getAttributes();
|
|
|
|
if(input[0] == "(")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
for(int i = 0; i < a.size(); ++i)
|
|
{
|
|
if(a[i].getType() == "INTEGER")
|
|
{
|
|
if(input[0].at(0) == '\"')
|
|
{
|
|
cout << "Incorrect type matching. Tried to insert string." << endl;
|
|
cout << "The values should be: ";
|
|
for(int x = 0; x < a.size(); ++i)
|
|
{
|
|
cout << a[x].getType();
|
|
if(a[x].getType() == "VARCHAR")
|
|
{
|
|
cout << "(" << a[x].getSize() << ")";
|
|
}
|
|
cout << endl;
|
|
}
|
|
exit(1);
|
|
}
|
|
s.push_back(input[0]);
|
|
input.erase(input.begin());
|
|
}
|
|
|
|
else
|
|
{
|
|
if(input[0].at(0) == '\"')
|
|
{
|
|
s.push_back(input[0].substr(1,input[0].find_last_of("\"") - 1 ));
|
|
//engine.getTableFromName(pr.getName()).getAttributes()[i].display();
|
|
input.erase(input.begin());
|
|
}
|
|
else
|
|
{
|
|
cout << "Incorrect type matching. Tried to insert integer." << endl;
|
|
cout << "The values should be: ";
|
|
for(int x = 0; x < a.size(); ++x)
|
|
{
|
|
cout << a[x].getType();
|
|
if(a[x].getType() == "VARCHAR")
|
|
{
|
|
cout << "(" << a[x].getSize() << ")";
|
|
}
|
|
cout << endl;
|
|
}
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (input[0] == ",")
|
|
{
|
|
input.erase(input.begin());
|
|
}
|
|
}
|
|
if(input[0] != ")")
|
|
{
|
|
cout << "Too many values trying to be inserted. Only insert " << a.size() << " values.";
|
|
cout << "The values should be: ";
|
|
for(int x = 0; x < a.size(); ++x)
|
|
{
|
|
cout << a[x].getType();
|
|
if(a[x].getType() == "VARCHAR")
|
|
{
|
|
cout << "(" << a[x].getSize() << ")";
|
|
}
|
|
cout << endl;
|
|
}
|
|
exit(1);
|
|
}
|
|
engine.insertValues(r.getTableName(), s);
|
|
input.erase(input.begin());
|
|
return input;
|
|
}
|
|
|
|
else if (input[0] == "RELATION")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
vector<Attribute> a = get<1>(t).getAttributes();
|
|
for(int y = 0; y < a[0].getSize(); ++y)
|
|
{
|
|
for(int x = 0; x < a.size(); ++x)
|
|
{
|
|
s.push_back(a[x].getValues()[y]);
|
|
engine.insertValues(r.getTableName(), s);
|
|
s.clear();
|
|
}
|
|
}
|
|
|
|
input = get<0>(t);
|
|
|
|
return input;
|
|
}
|
|
|
|
else cout<<"Syntax error! 3"<<endl;
|
|
}
|
|
|
|
cout<<"Syntax error! 2"<<endl;
|
|
|
|
}
|
|
|
|
else cout<<"Syntax error! 1"<<endl;
|
|
|
|
}
|
|
|
|
vector<string> updateCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
PRelation r(input[0]);
|
|
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "SET")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
//parse out ( and send everything until ) into an Expression vector
|
|
if(input[0] == "(")
|
|
{
|
|
|
|
vector <PAttribute> a;
|
|
PAttribute temp;
|
|
|
|
vector <string> s;
|
|
|
|
//vector <PExpression> e;
|
|
|
|
input.erase(input.begin());
|
|
|
|
while(input[0] != ")")
|
|
{
|
|
temp.setPAttributeName(input[0]);
|
|
a.push_back(temp);
|
|
temp.setPAttributeName("~");
|
|
|
|
input.erase(input.begin());
|
|
|
|
if(input[0] == "=")
|
|
{
|
|
input.erase(input.begin());
|
|
|
|
s.push_back(input[0]);
|
|
}
|
|
|
|
else
|
|
{
|
|
cout<<"Syntax error! 2"<<endl;
|
|
}
|
|
|
|
if(input[0] == ",")
|
|
{
|
|
input.erase(input.begin());
|
|
}
|
|
}
|
|
}
|
|
|
|
if(input[0] == "WHERE")
|
|
{
|
|
if(input[0] == "(")
|
|
{
|
|
//PCondition c;
|
|
|
|
PComparison c;
|
|
POperand oops1;
|
|
POperand oops2;
|
|
POp op;
|
|
|
|
while(input[0] != ")")
|
|
{
|
|
oops1.setPOperand(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
oops2.setPOperand(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
op.setPOp(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
c.setPComparison(oops1.getPOperand(), op.getPOp(), oops2.getPOperand());
|
|
}
|
|
}
|
|
}
|
|
|
|
// send update command to DBEngine
|
|
}
|
|
|
|
else cout<<"Syntax error! 1"<<endl;
|
|
}
|
|
|
|
vector<string> deleteCMD(vector<string> input, DBEngine &engine)
|
|
{
|
|
if (input[0] == "DELETE" && input[1] == "FROM")
|
|
{
|
|
input.erase(input.begin());
|
|
input.erase(input.begin());
|
|
|
|
PRelation r(input[0]);
|
|
|
|
if(input[0] == "WHERE")
|
|
{
|
|
if(input[0] == "(")
|
|
{
|
|
//PCondition c;
|
|
|
|
PComparison c;
|
|
POperand oops1;
|
|
POperand oops2;
|
|
POp op;
|
|
|
|
while(input[0] != ")")
|
|
{
|
|
oops1.setPOperand(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
oops2.setPOperand(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
op.setPOp(input[0]);
|
|
input.erase(input.begin());
|
|
|
|
c.setPComparison(oops1.getPOperand(), op.getPOp(), oops2.getPOperand());
|
|
}
|
|
}
|
|
}
|
|
|
|
// send delete command to DBEngine
|
|
}
|
|
else cout<<"Syntax error!"<<endl;
|
|
}
|
|
|
|
vector<string> query(vector<string> input, DBEngine &engine)
|
|
{
|
|
PRelation pr(input[0]);
|
|
|
|
input.erase(input.begin());
|
|
input.erase(input.begin());
|
|
|
|
tuple<vector<string>, Relation> t = expression(input, engine);
|
|
Relation r = get<1>(t);
|
|
r.setTableName(pr.getName());
|
|
//r.display();
|
|
input = get<0>(t);
|
|
|
|
engine.createTable(r);
|
|
|
|
return input;
|
|
}
|
|
|
|
void par_line(vector<string> input, DBEngine &engine) //calls par_command() or par_query() depending on first item from token list
|
|
{
|
|
/*
|
|
• Match the first item in the token list and determine weather this is a command or a query.
|
|
• Call functions par_command() or par_query();
|
|
• After either par_command() or par_query() returns, make sure the line ends properly with “;” token
|
|
*/
|
|
string tempChar = input.back();
|
|
|
|
if (tempChar != ";")
|
|
{
|
|
cout<<"ERROR! missing semicolon "<<endl;
|
|
}
|
|
|
|
else
|
|
{
|
|
if ( input[0] == "INSERT")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
vector<string> insertInput = insertCMD(input, engine);
|
|
//cout<<"arguments: "<<endl;
|
|
//displayTokenList(insertInput);
|
|
|
|
}
|
|
|
|
else if ( input[0] == "CREATE")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
|
|
vector<string> insertInput = createCMD(input, engine);
|
|
//cout<<"arguments: "<<endl;
|
|
//displayTokenList(insertInput);
|
|
|
|
}
|
|
|
|
else if ( input[0] == "DELETE")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
|
|
vector<string> insertInput = deleteCMD(input, engine);
|
|
//cout<<"arguments: "<<endl;
|
|
//displayTokenList(insertInput);
|
|
|
|
}
|
|
|
|
else if ( input[0] == "UPDATE")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
|
|
vector<string> insertInput = updateCMD(input, engine);
|
|
//cout<<"arguments: "<<endl;
|
|
//displayTokenList(insertInput);
|
|
|
|
}
|
|
|
|
else if ( input[0] == "SHOW")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
showCMD(input, engine);
|
|
}
|
|
|
|
else if ( input[0] == "EXIT")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
exitCMD(input, engine);
|
|
}
|
|
|
|
else if ( input[0] == "OPEN")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
openCMD(input, engine);
|
|
}
|
|
|
|
else if ( input[0] == "SAVE")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
saveCMD(input, engine);
|
|
}
|
|
|
|
else if ( input[0] == "CLOSE")
|
|
{
|
|
cout<<"\nPassing the following arguments to dbEngine: \nCommand: "<<input[0]<<endl;
|
|
input.erase(input.begin());
|
|
closeCMD(input, engine);
|
|
}
|
|
|
|
else if( input[1] == "<-")
|
|
{
|
|
cout<<"Passing query to dbEngine."<<endl;
|
|
query(input, engine);
|
|
}
|
|
|
|
else
|
|
{
|
|
cout<<"Not a valid command or query."<<endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void parse(string input, DBEngine &engine)
|
|
{
|
|
engine.storeCommands(input);
|
|
vector<string> listOfTokens = tokenize(input);
|
|
par_line(listOfTokens, engine);
|
|
}
|
|
/*
|
|
int main () {
|
|
|
|
|
|
string ss = "INSERT INTO animals VALUES FROM ( Joe , cat , 4 ) ;";
|
|
string ss2 = "SHOW Dogs ;";
|
|
string ss3 = "EXIT ; ";
|
|
|
|
vector<string> listOfTokens = tokenize(ss);
|
|
vector<string> listOfTokens2 = tokenize(ss2);
|
|
vector<string> listOfTokens3 = tokenize(ss3);
|
|
|
|
par_line(listOfTokens);
|
|
par_line(listOfTokens2);
|
|
par_line(listOfTokens3);
|
|
|
|
|
|
}
|
|
*/
|