myyrakle · myyrakle · Jul 18, 2022 · Jul 18, 2022 · Jul 18, 2022
diff --git a/src/lib/ast/dml/expressions/binary.rs b/src/lib/ast/dml/expressions/binary.rs
@@ -7,3 +7,9 @@ pub struct BinaryOperatorExpression {
     pub lhs: SQLExpression,
     pub rhs: SQLExpression,
 }
+
+impl Into<SQLExpression> for BinaryOperatorExpression {
+    fn into(self) -> SQLExpression {
+        SQLExpression::Binary(Box::new(self))
+    }
+}
diff --git a/src/lib/lexer/operator_token.rs b/src/lib/lexer/operator_token.rs
@@ -1,7 +1,54 @@
+use std::{convert::TryInto, error::Error};
+
+use crate::lib::ast::predule::BinaryOperator;
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum OperatorToken {
     Plus,     // +
     Minus,    // -
     Asterisk, // *
     Slash,    // /
+    Lt,       // A < B
+    Gt,       // A > B
+    Lte,      // A <= B
+    Gte,      // A >= B
+    Eq,       // A = B
+    Neq,      // A != B, A <> B
+}
+
+impl OperatorToken {
+    pub fn is_binary_operator(&self) -> bool {
+        [
+            Self::Plus,
+            Self::Minus,
+            Self::Asterisk,
+            Self::Slash,
+            Self::Lt,
+            Self::Gt,
+            Self::Lte,
+            Self::Gte,
+            Self::Eq,
+            Self::Neq,
+        ]
+        .contains(self)
+    }
+}
+
+impl TryInto<BinaryOperator> for OperatorToken {
+    type Error = Box<dyn Error>;
+
+    fn try_into(self) -> Result<BinaryOperator, Self::Error> {
+        match self {
+            Self::Plus => Ok(BinaryOperator::Add),
+            Self::Minus => Ok(BinaryOperator::Sub),
+            Self::Asterisk => Ok(BinaryOperator::Mul),
+            Self::Slash => Ok(BinaryOperator::Div),
+            Self::Lt => Ok(BinaryOperator::Lt),
+            Self::Gt => Ok(BinaryOperator::Gt),
+            Self::Lte => Ok(BinaryOperator::Lte),
+            Self::Gte => Ok(BinaryOperator::Gte),
+            Self::Eq => Ok(BinaryOperator::Eq),
+            Self::Neq => Ok(BinaryOperator::Neq),
+        }
+    }
 }
diff --git a/src/lib/parser/implements/dml/expression.rs b/src/lib/parser/implements/dml/expression.rs
@@ -1,6 +1,8 @@
+use std::convert::TryInto;
 use std::error::Error;
 
-use crate::lib::ast::predule::SQLExpression;
+use crate::lib::ast::predule::{BinaryOperatorExpression, SQLExpression};
+use crate::lib::dml::BinaryOperator;
 use crate::lib::errors::predule::ParsingError;
 use crate::lib::lexer::predule::Token;
 use crate::lib::parser::predule::Parser;
@@ -23,50 +25,51 @@ impl Parser {
                 }
             },
             Token::Integer(integer) => {
-                let lhs = integer;
+                let lhs = SQLExpression::Integer(integer);
 
                 if self.next_token_is_binary_operator() {
-                    // TODO: 2항 표현식 파싱 진입
+                    return self.parse_binary_expression(lhs);
                 } else {
-                    return Ok(SQLExpression::Integer(lhs));
+                    return Ok(lhs);
                 }
             }
             Token::Float(float) => {
-                let lhs = float;
+                let lhs = SQLExpression::Float(float);
 
                 if self.next_token_is_binary_operator() {
-                    // TODO: 2항 표현식 파싱 진입
+                    return self.parse_binary_expression(lhs);
                 } else {
-                    return Ok(SQLExpression::Float(lhs));
+                    return Ok(lhs);
                 }
             }
             Token::Identifier(identifier) => {
                 self.unget_next_token(Token::Identifier(identifier));
-
                 let select_column = self.parse_select_column()?;
 
+                let lhs = SQLExpression::SelectColumn(select_column);
+
                 if self.next_token_is_binary_operator() {
-                    // TODO: 2항 표현식 파싱 진입
+                    return self.parse_binary_expression(lhs);
                 } else {
-                    return Ok(SQLExpression::SelectColumn(select_column));
+                    return Ok(lhs);
                 }
             }
             Token::String(string) => {
-                let lhs = string;
+                let lhs = SQLExpression::String(string);
 
                 if self.next_token_is_binary_operator() {
-                    // TODO: 2항 표현식 파싱 진입
+                    return self.parse_binary_expression(lhs);
                 } else {
-                    return Ok(SQLExpression::String(lhs));
+                    return Ok(lhs);
                 }
             }
             Token::Boolean(boolean) => {
-                let lhs = boolean;
+                let lhs = SQLExpression::Boolean(boolean);
 
                 if self.next_token_is_binary_operator() {
-                    // TODO: 2항 표현식 파싱 진입
+                    return self.parse_binary_expression(lhs);
                 } else {
-                    return Ok(SQLExpression::Boolean(lhs));
+                    return Ok(lhs);
                 }
             }
             Token::LeftParentheses => {
@@ -131,4 +134,40 @@ impl Parser {
 
         expression
     }
+
+    /**
+     * 2항 연산식 파싱
+     */
+    pub(crate) fn parse_binary_expression(
+        &mut self,
+        lhs: SQLExpression,
+    ) -> Result<SQLExpression, Box<dyn Error>> {
+        if !self.has_next_token() {
+            return Err(ParsingError::boxed("need more tokens"));
+        }
+
+        // 연산자 획득
+        let current_token = self.get_next_token();
+
+        match current_token {
+            Token::Operator(operator) => {
+                if operator.is_binary_operator() {
+                    let rhs = self.parse_expression()?;
+                    let operator: BinaryOperator = operator.try_into()?;
+                    return Ok(BinaryOperatorExpression { lhs, rhs, operator }.into());
+                } else {
+                    return Err(ParsingError::boxed(format!(
+                        "binary operator expected, but your input is {:?}",
+                        operator
+                    )));
+                }
+            }
+            _ => {
+                return Err(ParsingError::boxed(format!(
+                    "operator is expected, but your input is {:?}",
+                    current_token
+                )));
+            }
+        }
+    }
 }