basic skeletons of update and delete added

parser.cpp

@@ -15,8 +15,12 @@ std::unique_ptr<Node> Parser::parse(const std::string &code) {
 		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_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();
 	}
 
 	std::cout << "ERROR, token:" << lexer.currentToken().token_string << std::endl;
@@ -120,24 +124,18 @@ std::unique_ptr<Node> Parser::parse_insert_into_table() {
 
 std::unique_ptr<Node> Parser::parse_select_from_table() {
     std::vector<ColNameNode> cols_names {};
-    std::unique_ptr<Node> where_node;
 
     lexer.skipToken(TokenType::keyword_select);
-    // TODO support also numbers and expressions
     while (lexer.tokenType() != TokenType::keyword_from) {
-	// TODO add consumeToken() which returns token and advances to next token
         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;
 
-    if (lexer.tokenType() == TokenType::keyword_where) {
-        lexer.skipToken(TokenType::keyword_where);
-        where_node = parse_where_clause();
-    } else {
-        where_node = std::make_unique<TrueNode>();
-    }
+    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) {}
@@ -145,12 +143,77 @@ std::unique_ptr<Node> Parser::parse_select_from_table() {
 	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_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_operator();
+    auto operation = parse_relational_operator();
     auto right = parse_operand_node();
 
     return std::make_unique<RelationalOperatorNode>(operation, std::move(left), std::move(right));
@@ -174,7 +237,7 @@ std::unique_ptr<Node> Parser::parse_operand_node() {
     }
 }
 
-RelationalOperatorType Parser::parse_operator() {
+RelationalOperatorType Parser::parse_relational_operator() {
     auto op = lexer.consumeCurrentToken();
     switch (op.type) {
         case TokenType::equal:
@@ -189,7 +252,28 @@ RelationalOperatorType Parser::parse_operator() {
             return RelationalOperatorType::lesser;
         case TokenType::lesser_equal:
             return RelationalOperatorType::lesser_equal;
-        default: ;
+        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;
+        default:
+            throw Exception("Unknown arithmetical operator");
+    }
 }