vaclavt/usql
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fixes and improvements

Browse Source 
exceptions related code needs work
This commit is contained in:
VaclavT
2021-07-22 23:57:42 +02:00
parent 977a9cd198
commit 6d4fe43a3b
15 changed files with 174 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
usql.cpp
View File

@@ -9,8 +9,14 @@
namespace usql {
std::unique_ptr<Table> USql::execute(const std::string &command) {
std::unique_ptr<Node> node = m_parser.parse(command);
return execute(*node);
try {
std::unique_ptr<Node> node = m_parser.parse(command);
return execute(*node);
} catch (std::exception &e) {
return create_stmt_result_table(-1, e.what());
}
}
std::unique_ptr<Table> USql::execute(Node &node) {
@@ -39,7 +45,8 @@ std::unique_ptr<Table> USql::execute(Node &node) {
std::unique_ptr<Table> USql::execute_create_table(CreateTableNode &node) {
// TODO check table does not exists
check_table_not_exists(node.table_name);
Table table{node.table_name, node.cols_defs};
m_tables.push_back(table);
@@ -48,7 +55,7 @@ std::unique_ptr<Table> USql::execute_create_table(CreateTableNode &node) {
std::unique_ptr<Table> USql::execute_create_table_as_table(CreateTableAsSelectNode &node) {
// TODO check table does not exists
check_table_not_exists(node.table_name);
auto select = execute_select((SelectFromTableNode &) *node.select_table);
@@ -60,7 +67,7 @@ std::unique_ptr<Table> USql::execute_create_table_as_table(CreateTableAsSelectNo
// must be here, if rows are put into new_table, they are lost during m_tables.push_table
Table *table = find_table(node.table_name);
for( Row& orig_row : select->m_rows) {
table->addCopyOfRow(orig_row);
table->add_copy_of_row(orig_row);
}
select.release(); // is it correct? hoping not to release select table here and then when releasing CreateTableAsSelectNode
@@ -76,7 +83,7 @@ std::unique_ptr<Table> USql::execute_insert_into_table(InsertIntoTableNode &node
Table *table_def = find_table(node.table_name);
// prepare empty new_row
Row new_row = table_def->createEmptyRow();
Row new_row = table_def->create_empty_row();
// copy values
for (size_t i = 0; i < node.cols_names.size(); i++) {
@@ -87,7 +94,7 @@ std::unique_ptr<Table> USql::execute_insert_into_table(InsertIntoTableNode &node
}
// append new_row
table_def->addRow(new_row);
table_def->add_row(new_row);
return create_stmt_result_table(0, "insert succeeded");
}
@@ -103,7 +110,8 @@ std::unique_ptr<Table> USql::execute_select(SelectFromTableNode &node) {
std::vector<int> source_table_col_index{};
for (int i = 0; i < node.cols_names->size(); i++) {
auto [ src_tbl_col_index, rst_tbl_col_def ] = getColumnDefinition(table, &node.cols_names->operator[](i), i);
auto [ src_tbl_col_index, rst_tbl_col_def ] = get_column_definition(table,
&node.cols_names->operator[](i), i);
source_table_col_index.push_back(src_tbl_col_index);
result_tbl_col_defs.push_back(rst_tbl_col_def);
@@ -116,7 +124,7 @@ std::unique_ptr<Table> USql::execute_select(SelectFromTableNode &node) {
// eval where for row
if (evalWhere(node.where.get(), table, *row)) {
// prepare empty row
Row new_row = result->createEmptyRow();
Row new_row = result->create_empty_row();
// copy column values
for (auto idx = 0; idx < result->columns_count(); idx++) {
@@ -128,7 +136,7 @@ std::unique_ptr<Table> USql::execute_select(SelectFromTableNode &node) {
new_row.setColumnValue(&result_tbl_col_defs[idx], col_value);
} else {
ColValue *col_value = row->ithColumn(row_col_index);
ColValue *col_value = row->ith_column(row_col_index);
new_row.setColumnValue(&result_tbl_col_defs[idx], col_value);
}
}
@@ -141,7 +149,7 @@ std::unique_ptr<Table> USql::execute_select(SelectFromTableNode &node) {
return std::move(result);
}
std::tuple<int, ColDefNode> USql::getColumnDefinition(Table *table, SelectColNode *select_col_node, int col_order ) {
std::tuple<int, ColDefNode> USql::get_column_definition(Table *table, SelectColNode *select_col_node, int col_order ) {
std::string new_col_name = select_col_node->name;
if (select_col_node->value->node_type == NodeType::column_name) {
@@ -173,7 +181,6 @@ std::unique_ptr<Table> USql::execute_delete(DeleteFromTableNode &node) {
auto it = table->m_rows.begin();
for (; it != table->m_rows.end();) {
if (evalWhere(node.where.get(), table, *it)) {
// TODO this can be really expensive operation
it = table->m_rows.erase(it);
} else {
++it;
@@ -194,24 +201,15 @@ std::unique_ptr<Table> USql::execute_update(UpdateTableNode &node) {
if (evalWhere(node.where.get(), table, *row)) {
int i = 0;
for (const auto& col : node.cols_names) {
// TODO cache it like in select
ColDefNode cdef = table->get_column_def(col.name);
ColDefNode col_def = table->get_column_def(col.name); // TODO cache it like in select
std::unique_ptr<ValueNode> new_val = evalArithmeticOperator(col_def.type,
static_cast<ArithmeticalOperatorNode &>(*node.values[i]), table, *row);
std::unique_ptr<ValueNode> new_val = evalArithmeticOperator(cdef.type,
static_cast<ArithmeticalOperatorNode &>(*node.values[i]),
table, *row);
if (cdef.type == ColumnType::integer_type) {
row->setColumnValue(cdef.order, new_val->getIntValue());
} else if (cdef.type == ColumnType::float_type) {
row->setColumnValue(cdef.order, new_val->getDoubleValue());
} else if (cdef.type == ColumnType::varchar_type) {
row->setColumnValue(cdef.order, new_val->getStringValue());
} else {
throw Exception("Implement me!");
}
table->validate_column(&col_def, new_val.get());
row->setColumnValue(&col_def, new_val.get());
i++;
}
// TODO tady je problem, ze kdyz to zfajluje na jednom radku ostatni by se nemely provest
}
}
@@ -237,7 +235,7 @@ std::unique_ptr<Table> USql::execute_load(LoadIntoTableNode &node) {
std::vector<std::string> csv_line = *it;
// prepare empty new_row
Row new_row = table_def->createEmptyRow();
Row new_row = table_def->create_empty_row();
// copy values
for (size_t i = 0; i < table_def->columns_count(); i++) {
@@ -254,7 +252,7 @@ std::unique_ptr<Table> USql::execute_load(LoadIntoTableNode &node) {
}
// append new_row
table_def->addRow(new_row);
table_def->add_row(new_row);
}
return create_stmt_result_table(0, "load succeeded");
@@ -265,31 +263,11 @@ std::unique_ptr<Table> USql::execute_save(SaveTableNode &node) {
// find source table
Table *table_def = find_table(node.table_name);
// header
std::string out_string;
for(int i = 0; i < table_def->m_col_defs.size(); i++) {
if (i > 0) out_string += ",";
out_string += table_def->m_col_defs[i].name;
}
// rows
for (auto it = table_def->m_rows.begin() + 1; it != table_def->m_rows.end(); ++it) {
std::string csv_line;
for(int i = 0; i < table_def->m_col_defs.size(); i++) {
if (i > 0) csv_line += ",";
auto col = it->ithColumn(i);
if (!col->isNull()) {
csv_line += col->getStringValue(); // TODO handle enclosing commas etc
}
}
out_string += "\n";
out_string += csv_line;
}
std::string csv_string = table_def->csv_string();
// save data
std::ofstream file(node.filename);
file << out_string;
file << csv_string;
file.close();
return create_stmt_result_table(0, "save succeeded");
@@ -358,6 +336,8 @@ std::unique_ptr<ValueNode> USql::evalValueNode(Table *table, Row &row, Node *nod
} else if (node->node_type == NodeType::function) {
return evalFunctionValueNode(table, row, node);
} else if (node->node_type == NodeType::null_value) {
return std::make_unique<NullValueNode>();
}
throw Exception("unsupported node type");
}
@@ -366,16 +346,16 @@ std::unique_ptr<ValueNode> USql::evalValueNode(Table *table, Row &row, Node *nod
std::unique_ptr<ValueNode> USql::evalDatabaseValueNode(Table *table, Row &row, Node *node) {
auto *dvl = static_cast<DatabaseValueNode *>(node);
ColDefNode col_def = table->get_column_def( dvl->col_name); // TODO optimize it to just get this def once
auto db_value = row.ithColumn(col_def.order);
auto db_value = row.ith_column(col_def.order);
if (col_def.type == ColumnType::integer_type) {
return std::__1::make_unique<IntValueNode>(db_value->getIntValue());
return std::make_unique<IntValueNode>(db_value->getIntValue());
}
if (col_def.type == ColumnType::float_type) {
return std::__1::make_unique<DoubleValueNode>(db_value->getDoubleValue());
return std::make_unique<DoubleValueNode>(db_value->getDoubleValue());
}
if (col_def.type == ColumnType::varchar_type) {
return std::__1::make_unique<StringValueNode>(db_value->getStringValue());
return std::make_unique<StringValueNode>(db_value->getStringValue());
}
throw Exception("unknown database value type");
}
@@ -471,6 +451,7 @@ std::unique_ptr<ValueNode> USql::evalArithmeticOperator(ColumnType outType, Arit
default:
throw Exception("implement me!!");
}
} else if (outType == ColumnType::integer_type) {
long l = ((ValueNode *) left.get())->getIntValue();
long r = ((ValueNode *) right.get())->getIntValue();
@@ -509,10 +490,10 @@ std::unique_ptr<Table> USql::create_stmt_result_table(long code, const std::stri
auto table_def = std::make_unique<Table>("result", result_tbl_col_defs);
Row new_row = table_def->createEmptyRow();
Row new_row = table_def->create_empty_row();
new_row.setColumnValue(0, code);
new_row.setColumnValue(1, text);
table_def->addRow(new_row);
table_def->add_row(new_row);
return std::move(table_def);
}
@@ -529,4 +510,12 @@ Table *USql::find_table(const std::string &name) {
}
}
void USql::check_table_not_exists(const std::string &name) {
auto name_cmp = [name](const Table& t) { return t.m_name == name; };
auto table_def = std::find_if(begin(m_tables), end(m_tables), name_cmp);
if (table_def != std::end(m_tables)) {
throw Exception("table already exists");
}
}
} // namespace