347 lines
12 KiB
C++
347 lines
12 KiB
C++
#include "parser.h"
|
|
#include "exception.h"
|
|
|
|
namespace usql {
|
|
|
|
// TOOD handle premature eof
|
|
|
|
Parser::Parser() {
|
|
lexer = Lexer{};
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse(const std::string &code) {
|
|
lexer.parse(code);
|
|
// lexer.debugTokens();
|
|
|
|
if (lexer.tokenType() == TokenType::keyword_create && lexer.nextTokenType() == TokenType::keyword_table) {
|
|
return parse_create_table();
|
|
}
|
|
if (lexer.tokenType() == TokenType::keyword_insert) {
|
|
return parse_insert_into_table();
|
|
}
|
|
if (lexer.tokenType() == TokenType::keyword_select) {
|
|
return parse_select_from_table();
|
|
}
|
|
if (lexer.tokenType() == TokenType::keyword_delete) {
|
|
return parse_delete_from_table();
|
|
}
|
|
if (lexer.tokenType() == TokenType::keyword_update) {
|
|
return parse_update_table();
|
|
}
|
|
if (lexer.tokenType() == TokenType::keyword_load) {
|
|
return parse_load_table();
|
|
}
|
|
|
|
std::cout << "ERROR, token:" << lexer.currentToken().token_string << std::endl;
|
|
return std::make_unique<Node>(NodeType::error);
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_create_table() {
|
|
std::vector<ColDefNode> cols_def{};
|
|
|
|
lexer.skipToken(TokenType::keyword_create);
|
|
lexer.skipToken(TokenType::keyword_table);
|
|
|
|
if (lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ }
|
|
std::string table_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
// create as select
|
|
if (lexer.tokenType() == TokenType::keyword_as) {
|
|
lexer.skipToken(TokenType::keyword_as);
|
|
|
|
std::unique_ptr<Node> select = parse_select_from_table();
|
|
|
|
return std::make_unique<CreateTableAsSelectNode>(table_name, std::move(select));
|
|
} else {
|
|
lexer.skipToken(TokenType::open_paren);
|
|
int column_order = 0;
|
|
do {
|
|
std::string column_name;
|
|
ColumnType column_type;
|
|
int column_len{1};
|
|
bool column_nullable{true};
|
|
|
|
// column name
|
|
if (lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ }
|
|
column_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
// column type and optionally len
|
|
if (lexer.tokenType() == TokenType::keyword_int) {
|
|
column_type = ColumnType::integer_type;
|
|
lexer.nextToken();
|
|
} else if (lexer.tokenType() == TokenType::keyword_float) {
|
|
column_type = ColumnType::float_type;
|
|
lexer.nextToken();
|
|
} else if (lexer.tokenType() == TokenType::keyword_varchar) {
|
|
column_type = ColumnType::varchar_type;
|
|
lexer.nextToken();
|
|
lexer.skipToken(TokenType::open_paren);
|
|
if (lexer.tokenType() == TokenType::int_number) {
|
|
column_len = std::stoi(lexer.consumeCurrentToken().token_string);
|
|
} else { /* TODO handle error */ }
|
|
lexer.skipToken(TokenType::close_paren);
|
|
} else { /* TODO handle error */ }
|
|
|
|
if (lexer.tokenType() == TokenType::keyword_not) {
|
|
lexer.nextToken();
|
|
lexer.skipToken(TokenType::keyword_null);
|
|
column_nullable = false;
|
|
} else if (lexer.tokenType() == TokenType::keyword_null) {
|
|
lexer.nextToken();
|
|
}
|
|
|
|
cols_def.push_back( ColDefNode(column_name, column_type, column_order++, column_len, column_nullable));
|
|
|
|
lexer.skipTokenOptional(TokenType::comma);
|
|
|
|
// TODO in future constraints
|
|
} while (lexer.tokenType() != TokenType::close_paren);
|
|
|
|
return std::make_unique<CreateTableNode>(table_name, cols_def);
|
|
}
|
|
}
|
|
|
|
|
|
std::unique_ptr<Node> Parser::parse_insert_into_table() {
|
|
std::vector<Node> exec_code{};
|
|
std::vector<ColNameNode> cols_names{};
|
|
std::vector<std::unique_ptr<Node>> cols_values{};
|
|
|
|
lexer.skipToken(TokenType::keyword_insert);
|
|
lexer.skipToken(TokenType::keyword_into);
|
|
|
|
// table name
|
|
if (lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ }
|
|
std::string table_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
// column names
|
|
lexer.skipToken(TokenType::open_paren);
|
|
do {
|
|
if (lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ }
|
|
cols_names.push_back(lexer.consumeCurrentToken().token_string);
|
|
|
|
lexer.skipTokenOptional(TokenType::comma);
|
|
} while (lexer.tokenType() != TokenType::close_paren);
|
|
lexer.skipToken(TokenType::close_paren);
|
|
|
|
lexer.skipToken(TokenType::keyword_values);
|
|
|
|
// column values
|
|
lexer.skipToken(TokenType::open_paren);
|
|
do {
|
|
// cols_values.push_back(lexer.consumeCurrentToken().token_string);
|
|
auto col_value = parse_value();
|
|
cols_values.push_back(std::move(col_value));
|
|
|
|
lexer.skipTokenOptional(TokenType::comma);
|
|
} while (lexer.tokenType() != TokenType::close_paren);
|
|
lexer.skipToken(TokenType::close_paren);
|
|
|
|
return std::make_unique<InsertIntoTableNode>(table_name, cols_names, std::move(cols_values));
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_value() {
|
|
if (lexer.tokenType() == TokenType::int_number) {
|
|
return std::make_unique<IntValueNode>(std::stoi(lexer.consumeCurrentToken().token_string));
|
|
}
|
|
if (lexer.tokenType() == TokenType::double_number) {
|
|
return std::make_unique<FloatValueNode>(std::stof(lexer.consumeCurrentToken().token_string));
|
|
}
|
|
if (lexer.tokenType() == TokenType::string_literal) {
|
|
return std::make_unique<StringValueNode>(lexer.consumeCurrentToken().token_string);
|
|
}
|
|
if (lexer.tokenType() == TokenType::identifier) {
|
|
std::string func_name = lexer.consumeCurrentToken().token_string;
|
|
std::vector<std::unique_ptr<Node>> pars;
|
|
|
|
lexer.skipToken(TokenType::open_paren);
|
|
while (lexer.tokenType() != TokenType::close_paren) { // TODO handle errors
|
|
pars.push_back(parse_value());
|
|
lexer.skipTokenOptional(TokenType::comma);
|
|
}
|
|
lexer.skipToken(TokenType::close_paren);
|
|
return std::make_unique<FunctionNode>(func_name, std::move(pars));
|
|
}
|
|
throw Exception("Syntax error");
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_select_from_table() {
|
|
std::vector<ColNameNode> cols_names{};
|
|
|
|
lexer.skipToken(TokenType::keyword_select);
|
|
while (lexer.tokenType() != TokenType::keyword_from) {
|
|
cols_names.push_back(lexer.consumeCurrentToken().token_string);
|
|
lexer.skipTokenOptional(TokenType::comma);
|
|
}
|
|
|
|
lexer.skipToken(TokenType::keyword_from);
|
|
std::string table_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
std::unique_ptr<Node> where_node = parse_where_clause();
|
|
|
|
// if (lexer.tokenType() == TokenType::keyword_order_by) {}
|
|
// if (lexer.tokenType() == TokenType::keyword_offset) {}
|
|
// if (lexer.tokenType() == TokenType::keyword_limit) {}
|
|
|
|
return std::make_unique<SelectFromTableNode>(table_name, cols_names, std::move(where_node));
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_delete_from_table() {
|
|
lexer.skipToken(TokenType::keyword_delete);
|
|
lexer.skipToken(TokenType::keyword_from);
|
|
|
|
std::string table_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
std::unique_ptr<Node> where_node = parse_where_clause();
|
|
|
|
return std::make_unique<DeleteFromTableNode>(table_name, std::move(where_node));
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_update_table() {
|
|
lexer.skipToken(TokenType::keyword_update);
|
|
lexer.skipTokenOptional(TokenType::keyword_table);
|
|
|
|
std::string table_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
lexer.skipToken(TokenType::keyword_set);
|
|
|
|
std::vector<ColNameNode> cols_names;
|
|
std::vector<std::unique_ptr<Node>> values;
|
|
|
|
do {
|
|
cols_names.push_back(lexer.consumeCurrentToken().token_string);
|
|
lexer.skipToken(TokenType::equal);
|
|
|
|
std::unique_ptr<Node> left = Parser::parse_operand_node();
|
|
if (Lexer::isArithmeticalOperator(lexer.tokenType())) {
|
|
ArithmeticalOperatorType op = parse_arithmetical_operator();
|
|
std::unique_ptr<Node> right = Parser::parse_operand_node();
|
|
|
|
values.push_back(std::make_unique<ArithmeticalOperatorNode>(op, std::move(left),
|
|
std::move(right)));
|
|
} else {
|
|
std::unique_ptr<Node> right = std::make_unique<IntValueNode>(0);
|
|
values.push_back(
|
|
std::make_unique<ArithmeticalOperatorNode>(ArithmeticalOperatorType::copy_value,
|
|
std::move(left), std::move(right)));
|
|
}
|
|
lexer.skipTokenOptional(TokenType::comma);
|
|
|
|
} while (lexer.tokenType() != TokenType::keyword_where && lexer.tokenType() != TokenType::eof);
|
|
|
|
std::unique_ptr<Node> where_node = parse_where_clause();
|
|
|
|
return std::make_unique<UpdateTableNode>(table_name, cols_names, std::move(values), std::move(where_node));
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_load_table() {
|
|
lexer.skipToken(TokenType::keyword_load);
|
|
lexer.skipTokenOptional(TokenType::keyword_into);
|
|
|
|
std::string table_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
lexer.skipTokenOptional(TokenType::keyword_from);
|
|
|
|
std::string file_name = lexer.consumeCurrentToken().token_string;
|
|
|
|
return std::make_unique<LoadIntoTableNode>(table_name, file_name);
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_where_clause() {
|
|
// TODO add support for multiple filters
|
|
// TODO add support for parenthesis
|
|
|
|
if (lexer.tokenType() != TokenType::keyword_where) {
|
|
return std::make_unique<TrueNode>();
|
|
}
|
|
|
|
std::unique_ptr<Node> node;
|
|
lexer.skipToken(TokenType::keyword_where);
|
|
do {
|
|
node = parse_relational_expression();
|
|
|
|
if (Lexer::isLogicalOperator(lexer.tokenType())) {
|
|
auto operation = parse_logical_operator();
|
|
std::unique_ptr<Node> node2 = parse_relational_expression();
|
|
node = std::make_unique<LogicalOperatorNode>(operation, std::move(node), std::move(node2));
|
|
}
|
|
} while (lexer.tokenType() != TokenType::eof); // until whole where clause parsed
|
|
|
|
return node;
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_relational_expression() {
|
|
auto left = parse_operand_node();
|
|
auto operation = parse_relational_operator();
|
|
auto right = parse_operand_node();
|
|
|
|
return std::make_unique<RelationalOperatorNode>(operation, std::move(left), std::move(right));
|
|
}
|
|
|
|
std::unique_ptr<Node> Parser::parse_operand_node() {
|
|
// while not end or order or limit
|
|
auto token_type = lexer.tokenType();
|
|
std::string tokenString = lexer.consumeCurrentToken().token_string;
|
|
switch (token_type) {
|
|
case TokenType::int_number:
|
|
return std::make_unique<IntValueNode>(std::stoi(tokenString));
|
|
case TokenType::double_number:
|
|
return std::make_unique<FloatValueNode>(std::stod(tokenString));
|
|
case TokenType::string_literal:
|
|
return std::make_unique<StringValueNode>(tokenString);
|
|
case TokenType::identifier:
|
|
return std::make_unique<DatabaseValueNode>(tokenString);
|
|
default:;
|
|
throw Exception("Unknown operand node");
|
|
}
|
|
}
|
|
|
|
RelationalOperatorType Parser::parse_relational_operator() {
|
|
auto op = lexer.consumeCurrentToken();
|
|
switch (op.type) {
|
|
case TokenType::equal:
|
|
return RelationalOperatorType::equal;
|
|
case TokenType::not_equal:
|
|
return RelationalOperatorType::not_equal;
|
|
case TokenType::greater:
|
|
return RelationalOperatorType::greater;
|
|
case TokenType::greater_equal:
|
|
return RelationalOperatorType::greater_equal;
|
|
case TokenType::lesser:
|
|
return RelationalOperatorType::lesser;
|
|
case TokenType::lesser_equal:
|
|
return RelationalOperatorType::lesser_equal;
|
|
default:
|
|
throw Exception("Unknown relational operator");
|
|
}
|
|
}
|
|
|
|
LogicalOperatorType Parser::parse_logical_operator() {
|
|
auto op = lexer.consumeCurrentToken();
|
|
switch (op.type) {
|
|
case TokenType::logical_and:
|
|
return LogicalOperatorType::and_operator;
|
|
case TokenType::logical_or:
|
|
return LogicalOperatorType::or_operator;
|
|
default:
|
|
throw Exception("Unknown logical operator");
|
|
}
|
|
}
|
|
|
|
ArithmeticalOperatorType Parser::parse_arithmetical_operator() {
|
|
auto op = lexer.consumeCurrentToken();
|
|
switch (op.type) {
|
|
case TokenType::plus:
|
|
return ArithmeticalOperatorType::plus_operator;
|
|
case TokenType::minus:
|
|
return ArithmeticalOperatorType::minus_operator;
|
|
case TokenType::multiply:
|
|
return ArithmeticalOperatorType::multiply_operator;
|
|
case TokenType::divide:
|
|
return ArithmeticalOperatorType::divide_operator;
|
|
default:
|
|
throw Exception("Unknown arithmetical operator");
|
|
}
|
|
}
|
|
|
|
} |