tinySQL  0.1
A self-contained database management system
interface.cpp
1 //
2 // Created by luke on 22-6-3.
3 //
4 
5 #include "API/interface.h"
6 #include "share/data_t.h"
7 #include "share/timer.h"
8 #include <ios>
9 #include <iostream>
10 #include <fstream>
11 #include <strstream>
12 #include <cassert>
13 #include <iomanip>
14 
21 void sortAttrNames(std::vector<std::string> &attr_names, Attribute& attr){
22  if (attr_names.empty()) return;
23  std::vector<std::string> sorted;
24  for (int i = 0; i < attr.num; ++i){
25  int j;
26  for (j = 0; j < attr_names.size(); ++j){
27  if (attr_names.at(j) == attr.name[i]){
28  sorted.emplace_back(attr_names.at(j));
29  break;
30  }
31  }
32  if (j == attr_names.size()){
33  throw DB_COLUMN_NAME_NOT_EXIST; // Don't allow attr_names not in the correct range
34  }
35  }
36  attr_names = sorted;
37 }
38 
39 void Interface::parseWhere(hsql::Expr *Clause, std::vector<Where> &where_vec){
40  // For where clause, if one side is kExprOperator, then the other side has to be kExprOperator
41  if (Clause == nullptr) return;
42  if (Clause->expr->type == hsql::kExprOperator){
43  assert(Clause->expr2->type == hsql::kExprOperator);
44  parseWhere(Clause->expr, where_vec);
45  parseWhere(Clause->expr2, where_vec);
46  }
47  else{
48  assert(Clause->expr->type == hsql::kExprColumnRef);
49 
50  Where w;
51  w.attr_name = Clause->expr->name;
52  w.relation_operator = op_map.at(Clause->opType);
53  w.data = Data(Clause->expr2);
54 
55  where_vec.push_back(w);
56  }
57 }
58 
59 void Interface::showErrMsg(db_err_t &dbErr) {
60  switch (dbErr) {
61  case DB_KEY_NOT_FOUND:{
62  _os << "Table doesn't have the given attribute or value\n";
63  break;
64  }
65  case DB_FILE_NOT_FOUND:{
66  _os << "File doesn't exist\n";
67  break;
68  }
69  case DB_TABLE_ALREADY_EXIST:{
70  _os << "Table already exist\n";
71  break;
72 
73  }
74  case DB_COLUMN_NAME_NOT_EXIST:{
75  _os << "Table attribute not exist\n";
76  break;
77 
78  }
79  case DB_INDEX_ALREADY_EXIST:{
80  _os << "Index already exist on given attribute or has_index name already exist\n";
81  break;
82 
83  }
84  case DB_INDEX_NOT_FOUND:{
85  _os << "Index doesn't exist\n" ;
86  break;
87 
88  }
89  case DB_PRIMARY_KEY_CONFLICT:{
90  _os << "DB PRIMARY CONFLICT!\n";
91  break;
92  }
93  case DB_TABLE_NOT_EXIST:{
94  _os << "Table doesn't exist!\n";
95  }
96  default:{
97  _os << "DB ERROR: " << ERR_STR_MAP.at(dbErr) << std::endl;
98  }
99  }
100 }
101 
102 void Interface::readFromFile(std::string &query) {
103  std::string file_path;
104  _os << "Input file name(relative path, end with ENTER): > ";
105  _os.flush();
106 
107  _is.clear();
108  _is >> file_path;
109 // std::getline(_is, file_path);
110 
111  std::ifstream ifs;
112  ifs.open(file_path, std::fstream::in);
113  if (!ifs.is_open()){
114  _os << "File doesn't exist." << std::endl;
115  _os.flush();
116  return;
117  }
118 
119  std::ostrstream str_buf;
120  char ch;
121  while(str_buf && ifs.get(ch)){
122  str_buf.put(ch);
123  }
124  query = str_buf.str();
125 }
126 
127 
128 void Interface::run() {
129  std::string query;
130  hsql::SQLParserResult result;
131  const hsql::SQLStatement* statement;
132 
133  _os << "TinySQL started.\nInput below.\n";
134  _os.flush();
135 
136  TimerClock timer;
137 
138  int loop_counter = 0;
139  while(true){
140  query.clear();
141  std::getline(_is, query, ';');
142 
143  if (query.front() == '\n') query.erase(0, 1);
144  if (query.back() == '\n') query.erase(query.size() - 1, 1);
145 
146  if (query == "READ FILE"){
147  readFromFile(query);
148  }
149  else if (_is.eof()){
150  break;
151  }
152 
153  hsql::SQLParser::parse(query, &result);
154 
155  if (result.isValid() && result.size() > 0){
156 
157  timer.update();
158 
159  for (size_t k = 0; k < result.size(); ++k){
160  ++loop_counter;
161  statement = result.getStatement(k);
162  switch (statement->type()) {
163  case hsql::kStmtSelect:{
164  const auto* select = dynamic_cast<const hsql::SelectStatement*>(statement);
165 
166  std::string tableName = select->fromTable->getName();
167 
168  std::vector<std::string> attr_names;
169  for (auto sel : *(select->selectList)){
170  if (sel->isType(hsql::kExprStar)) continue;
171  attr_names.emplace_back(sel->name);
172  }
173 
174  std::vector<Where> where_clauses;
175  parseWhere(select->whereClause, where_clauses);
176 
177  Attribute tableAttr;
178  try{
179  tableAttr = executor->getTableAttributes(tableName);
180  sortAttrNames(attr_names, tableAttr);
181  }
182  catch(db_err_t &db_err){ // Table may not exist
183  showErrMsg(db_err);
184  }
185 
186  std::vector<MemoryTuple> res; // Result container
187  // TODO: Call executor
188  try{
189  executor->selectRecord(tableName, attr_names, where_clauses, res);
190  }
191  catch (db_err_t &db_err){
192  showErrMsg(db_err);
193  }
194 // executor->selectRecord(tableName, attr_names, where_clauses, res);
195 
196  if (attr_names.empty()) {
197  for(int i = 0; i < tableAttr.num; ++i){
198  attr_names.emplace_back(tableAttr.name[i]);
199  }
200  }
201  serialOutput(res, attr_names);
202  break;
203  }
204  case hsql::kStmtCreate :{
205  const auto* create = dynamic_cast<const hsql::CreateStatement*>(statement);
206  if (create->type == hsql::kCreateTable){ // Only handle create table
207  std::string tableName = create->tableName;
208  Attribute attr;
209  int i = 0;
210  for (auto stmt : *(create->columns)){
211  attr.name[i] = stmt->name;
212  attr.type[i] = type_map.at(stmt->type.data_type);
213  ++i;
214  }
215  attr.num = i;
216  attr.primary_Key = -1;
217  int j;
218  for (auto cons : *(create->tableConstraints)){
219  for (j = 0; j < i; ++j){
220  if (cons->type == hsql::ConstraintType::PrimaryKey){
221  if (attr.name[j] == std::string(cons->columnNames->at(0))){
222  attr.primary_Key = j;
223  attr.is_unique[j] = true;
224  break;
225  }
226  }
227  }
228  }
229 // executor->createTable(tableName, attr);
230  try{
231  executor->createTable(tableName, attr);
232  }
233  catch (db_err_t &db_err){
234  showErrMsg(db_err);
235  }
236  break;
237  }
238  else if(create->type == hsql::kCreateIndex){
239  std::string tableName = create->tableName;
240  std::string indexName = create->indexName;
241  std::string attrName;
242  for(auto col : *(create->indexColumns)){
243  attrName = col;
244 // executor->createIndex(tableName, indexName, attrName);
245 
246  try{
247  executor->createIndex(tableName, indexName, attrName);
248  }
249  catch (db_err_t &db_err){
250  showErrMsg(db_err);
251  }
252  }
253  }
254  else{
255  _os << "Invalid operation" << std::endl;
256  }
257  break;
258 
259  }
260  case hsql::kStmtInsert :{
261  const auto* insert = dynamic_cast<const hsql::InsertStatement*>(statement);
262  // TODO : Add feature that a insert can specify the attribute
263  if (insert->select == nullptr){
264  std::string tableName = insert->tableName;
265  MemoryTuple row;
266  for(auto val : *(insert->values)){
267  row.emplace_back(val);
268  }
269 // executor->insertRecord(tableName, row);
270  try{
271  executor->insertRecord(tableName, row);
272  }
273  catch (db_err_t &db_err){
274  showErrMsg(db_err);
275  }
276 // executor->insertRecord(tableName, row);
277  }
278  else{
279  //TODO : Add select
280  throw DB_FAILED;
281  }
282  break;
283 
284  }
285  case hsql::kStmtDelete :{
286  const auto* del = dynamic_cast<const hsql::DeleteStatement*>(statement);
287  std::string tableName = del->tableName;
288  //Assume the most simple delete, that the expr represents the common where.
289  std::vector<Where> where_clause_dat;
290  parseWhere(del->expr, where_clause_dat);
291  try{
292  executor->deleteRecord(tableName, where_clause_dat);
293  }
294  catch (db_err_t &db_err){
295  showErrMsg(db_err);
296  }
297 // executor->deleteRecord(tableName, where_clause_dat);
298  break;
299 
300  }
301  case hsql::kStmtDrop :{
302  const auto* drop = dynamic_cast<const hsql::DropStatement*>(statement);
303  if (drop->type == hsql::kDropTable){
304  std::string tableName(drop->name);
305  executor->dropTable(tableName);
306  }
307  else if(drop->type == hsql::kDropIndex){
308  std::string indexName(drop->indexName);
309  try{
310  executor->dropIndex(indexName);
311 
312  }
313  catch (db_err_t &db_err){
314  showErrMsg(db_err);
315  }
316  }
317  break;
318  }
319 // case hsql::kStmtUpdate :{
320 // const auto* update = dynamic_cast<const hsql::UpdateStatement*>(statement);
321 // std::string tableName = update->table->name;
322 //
323 // std::vector<Where> where_dat;
324 // parseWhere(update->where, where_dat);
325 // //TODO : Add update content
327 // break;
328 // }
329  case hsql::kStmtShow :{
330  const auto* show = dynamic_cast<const hsql::ShowStatement*>(statement);
331  executor->showTables();
332  break;
333  }
334  default :{
335  _os << ">> Unsupported valid SQL command. May support later. \n";
336  }
337  }
338  _os << ">>> Success." << std::endl;
339  }
340  if (result.size() > 1){
341  _os << "---------------------------------------------\n";
342  _os << ">>> File query successfully executed!\n";
343  }
344  _os << "Executed " << result.size() << " queries in " << timer.getTimerMilliSec() << " ms.\n";
345  }
346  else {
347  for (auto character : query){
348  if (character != ' '){
349  _os <<">>" << result.errorMsg() << std::endl;
350  break;
351  }
352  }
353  }
354  result.reset();
355  }
356  _os << ">>Execute: " << loop_counter << " queries." << std::endl;
357  _os << ">>Goodbye." << std::endl;
358 }
359 
360 
361 void Interface::serialOutput(std::vector<MemoryTuple> &tuples) {
362  for (const auto& tuple : tuples){
363  for (auto dat : tuple){
364  _os << ">> " << dat;
365  }
366  _os << std::endl;
367  }
368  _os.flush();
369 }
370 
371 void Interface::serialOutput(std::vector<MemoryTuple> &tuples, std::vector<std::string> &attr_names){
372  for(const auto& i : attr_names){
373  _os << std::setw(6) <<"|" << std::setw(12) << i;
374  }
375  _os<< std::endl;
376 // for(auto i: attr_names){
377 // }
378 
379  _os <<"------------------";
380 
381  _os<<std::endl;
382  //
383  for(const auto& tuple : tuples){
384  for(auto dat : tuple){
385  if(dat.type==(BASE_SQL_ValType::INT)){
386  _os <<std::setw(6)<<"|"<<std::setw(12)<<dat.data_meta.i_data;
387  }
388  else if(dat.type==BASE_SQL_ValType::FLOAT){
389  _os <<std::setw(6)<<"|"<<std::setw(12)<<dat.data_meta.f_data;
390  }
391  else
392  _os <<std::setw(6)<<"|"<<std::setw(12)<<dat.data_meta.s_data;
393  }
394  _os<<std::endl;
395  }
396  _os << " Output " << tuples.size() << " records." << std::endl;
397 }
Attribute::name
std::string name[32]
property name
Definition: data_t.h:175
Where
Definition: data_t.h:161
Where::attr_name
std::string attr_name
The attribute to perform select on.
Definition: data_t.h:164
Interface::showErrMsg
void showErrMsg(db_err_t &dbErr)
Display the error message thrown.
Definition: interface.cpp:59
Exec_Engine::deleteRecord
void deleteRecord(std::string &table_name, std::vector< Where > &data)
Delete records by conditions.
Definition: exec_engine.cpp:27
Exec_Engine::showTables
void showTables()
display the information of all the tables
Definition: exec_engine.h:104
Attribute::is_unique
bool is_unique[32]
uniqure or not
Definition: data_t.h:176
Attribute::primary_Key
int primary_Key
-1 not exist, 1-32 exist and the place where the primary key are
Definition: data_t.h:178
Exec_Engine::createTable
void createTable(std::string &table_name, Attribute &attr)
Create a Table.
Definition: exec_engine.cpp:4
Exec_Engine::selectRecord
void selectRecord(std::string &table_name, std::vector< std::string > &attr_names, std::vector< Where > &wheres, std::vector< MemoryTuple > &result)
Select records by conditions.
Definition: exec_engine.cpp:31
Exec_Engine::getTableAttributes
Attribute getTableAttributes(const std::string &table_name)
Get the Table Attributes.
Definition: exec_engine.cpp:51
TimerClock
A simple clock wrapper in chrono library.
Definition: timer.h:17
Interface::serialOutput
void serialOutput(std::vector< MemoryTuple > &tuples)
Serialize the records to a standard output.
Definition: interface.cpp:361
Exec_Engine::createIndex
void createIndex(std::string &table_name, std::string &index_name, std::string &attr_name)
Create Index on a table's attribute.
Definition: exec_engine.cpp:14
Exec_Engine::dropTable
void dropTable(std::string &table_name)
Delete a Table.
Definition: exec_engine.cpp:9
Attribute::num
int num
number of property
Definition: data_t.h:173
Interface::run
void run()
Should be called after initialized.
Definition: interface.cpp:128
Exec_Engine::dropIndex
void dropIndex(std::string &index_name)
Delete the index of a certain index on a table.
Definition: exec_engine.cpp:20
Attribute
The attributes for a schema.
Definition: data_t.h:172
Data
Basic cell element in a tuples.
Definition: data_t.h:44
Exec_Engine::insertRecord
void insertRecord(std::string &table_name, MemoryTuple &row)
Insert a piece of record.
Definition: exec_engine.cpp:55
Generated by   doxygen 1.8.17