code changes in load

parser.cpp

@@ -318,12 +318,10 @@ namespace usql {
 			    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)));
+			    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,
+			    values.push_back(std::make_unique<ArithmeticalOperatorNode>(ArithmeticalOperatorType::copy_value,
 										   std::move(left), std::move(right)));
 		    }
 		    m_lexer.skipTokenOptional(TokenType::comma);
@@ -335,26 +333,6 @@ namespace usql {
 	    return std::make_unique<UpdateTableNode>(table_name, cols_names, std::move(values), std::move(where_node));
     }
 
-    std::unique_ptr<Node> Parser::parse_where_clause() {
-	if (m_lexer.tokenType() != TokenType::keyword_where) {
-		return std::make_unique<TrueNode>();
-	}
-
-	std::unique_ptr<Node> node;
-	m_lexer.skipToken(TokenType::keyword_where);
-	do {
-		node = parse_relational_expression();
-
-		if (Lexer::isLogicalOperator(m_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 (m_lexer.tokenType() != TokenType::eof && m_lexer.tokenType() != TokenType::keyword_order);
-
-	return node;
-    }
-
 
     std::vector<ColOrderNode>  Parser::parse_order_by_clause() {
 	std::vector<ColOrderNode> order_cols;
@@ -419,17 +397,64 @@ namespace usql {
 	return OffsetLimitNode{offset, limit};
     }
 
-    std::unique_ptr<Node> Parser::parse_relational_expression() {
-	    auto left = parse_operand_node();
-	    auto operation = parse_relational_operator();
-	    auto right = parse_operand_node();
+    
+    std::unique_ptr<Node> Parser::parse_where_clause() {
+	if (m_lexer.tokenType() != TokenType::keyword_where) {
+		return std::make_unique<TrueNode>();
+	}
 
-	    return std::make_unique<RelationalOperatorNode>(operation, std::move(left), std::move(right));
+	m_lexer.skipToken(TokenType::keyword_where);
+
+	std::unique_ptr<Node> left = parse_expression();
+	do {
+		left = parse_expression(std::move(left));
+
+	} while (m_lexer.tokenType() != TokenType::eof && m_lexer.tokenType() != TokenType::keyword_order && m_lexer.tokenType() != TokenType::keyword_offset && m_lexer.tokenType() != TokenType::keyword_limit);
+	
+	return left;
+    }
+
+    std::unique_ptr<Node> Parser::parse_expression() {
+	    std::unique_ptr<Node> left = parse_operand_node();
+
+	    return parse_expression(std::move(left));
+    }
+
+    std::unique_ptr<Node> Parser::parse_expression(std::unique_ptr<Node> left) {
+	    if (Lexer::isRelationalOperator(m_lexer.tokenType())) {
+		    auto operation = parse_relational_operator();
+		    auto right = parse_operand_node();
+		    return std::make_unique<RelationalOperatorNode>(operation, std::move(left), std::move(right));
+	    } else if (Lexer::isLogicalOperator(m_lexer.tokenType())) {
+		    auto operation = parse_logical_operator();
+		    auto right = parse_expression();
+		    return std::make_unique<LogicalOperatorNode>(operation, std::move(left), std::move(right));
+	    } else if (Lexer::isArithmeticalOperator(m_lexer.tokenType())) {
+		    auto operation = parse_arithmetical_operator();
+		    auto right = parse_operand_node();
+
+		    return std::make_unique<ArithmeticalOperatorNode>(operation, std::move(left), std::move(right));
+	    } else if (m_lexer.tokenType() == TokenType::int_number || m_lexer.tokenType() == TokenType::double_number ||m_lexer.tokenType() == TokenType::string_literal ||m_lexer.tokenType() == TokenType::identifier || m_lexer.tokenType() == TokenType::keyword_null || m_lexer.tokenType() == TokenType::open_paren) {
+	    	return parse_operand_node();
+	    }
+	    
+	    return left;
     }
 
     std::unique_ptr<Node> Parser::parse_operand_node() {
-	    // while not end or order or limit
 	    auto token_type = m_lexer.tokenType();
+
+	    if (token_type == TokenType::open_paren) {
+		    m_lexer.skipToken(TokenType::open_paren);
+		    auto left = parse_expression();
+		    do {
+			left = parse_expression(std::move(left));
+		    } while (m_lexer.tokenType() != TokenType::close_paren && m_lexer.tokenType() != TokenType::eof);
+
+		    m_lexer.skipToken(TokenType::close_paren);
+		    return left;
+	    }
+
 	    std::string tokenString = m_lexer.consumeCurrentToken().token_string;
 	    switch (token_type) {
 		    case TokenType::int_number:
@@ -441,9 +466,9 @@ namespace usql {
 		    case TokenType::identifier:
 			    return std::make_unique<DatabaseValueNode>(tokenString);
 		    case TokenType::keyword_null:
-		    	return std::make_unique<NullValueNode>();
+		   	    return std::make_unique<NullValueNode>();
 		    default:
-			    throw Exception("Unknown operand node");
+			    throw Exception("Unknown operand node " + tokenString);
 	    }
     }
 
@@ -463,7 +488,7 @@ namespace usql {
 		    case TokenType::lesser_equal:
 			    return RelationalOperatorType::lesser_equal;
 		    default:
-			    throw Exception("Unknown relational operator");
+			    throw Exception("Unknown relational operator " + op.token_string);
 	    }
     }
 
@@ -495,4 +520,22 @@ namespace usql {
 	    }
     }
 
-}
+std::unique_ptr<Node> Parser::parse_relational_expression() {
+	auto left = parse_operand_node();
+
+	if (!Lexer::isRelationalOperator(m_lexer.tokenType()))
+	{
+		if (left->node_type != NodeType::relational_operator)
+			throw Exception("syntax error in relational operation");
+
+		return left;
+	}
+
+	auto operation = parse_relational_operator();
+	auto right = parse_operand_node();
+
+	return std::make_unique<RelationalOperatorNode>(operation, std::move(left), std::move(right));
+}
+
+}	// namespace
+