Add spaceship operator

Author: hntd187

src/ast/operator.rs

@@ -47,6 +47,7 @@ pub enum BinaryOperator {
     Lt,
     GtEq,
     LtEq,
+    Spaceship,
     Eq,
     NotEq,
     And,
@@ -71,6 +72,7 @@ impl fmt::Display for BinaryOperator {
             BinaryOperator::Lt => "<",
             BinaryOperator::GtEq => ">=",
             BinaryOperator::LtEq => "<=",
+            BinaryOperator::Spaceship => "<=>",
             BinaryOperator::Eq => "=",
             BinaryOperator::NotEq => "<>",
             BinaryOperator::And => "AND",

src/parser.rs

@@ -57,7 +57,7 @@ pub enum IsLateral {
 }
 use crate::ast::Statement::CreateVirtualTable;
 use IsLateral::*;
-use crate::ast::Expr::BinaryOp;
+
 
 impl From<TokenizerError> for ParserError {
     fn from(e: TokenizerError) -> Self {
@@ -382,15 +382,7 @@ impl Parser {
                 self.expect_token(&Token::RParen)?;
                 Ok(expr)
             }
-            unexpected => {
-                self.prev_token();
-                self.prev_token();
-                self.prev_token();
-                let t1 = self.next_token().to_string();
-                let t2 = self.next_token().to_string();
-                let t3 = self.next_token().to_string();
-                self.expected(format!("an expression: {} - {} {} {}", self.index, &t1, &t2, &t3).as_str(), unexpected)
-            },
+            unexpected => self.expected("an expression:", unexpected),
         }?;
 
         if self.parse_keyword(Keyword::COLLATE) {
@@ -721,6 +713,7 @@ impl Parser {
     pub fn parse_infix(&mut self, expr: Expr, precedence: u8) -> Result<Expr, ParserError> {
         let tok = self.next_token();
         let regular_binary_operator = match &tok {
+            Token::Spaceship => Some(BinaryOperator::Spaceship),
             Token::DoubleEq => Some(BinaryOperator::Eq),
             Token::Eq => Some(BinaryOperator::Eq),
             Token::Neq => Some(BinaryOperator::NotEq),
@@ -862,7 +855,7 @@ impl Parser {
             Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),
-            Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq | Token::DoubleEq => Ok(20),
+            Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq | Token::DoubleEq | Token::Spaceship => Ok(20),
             Token::Pipe => Ok(21),
             Token::Caret => Ok(22),
             Token::Ampersand => Ok(23),

src/tokenizer.rs

@@ -58,6 +58,8 @@ pub enum Token {
     LtEq,
     /// Greater Than Or Equals operator `>=`
     GtEq,
+    /// Spaceship operator <=>
+    Spaceship,
     /// Plus operator `+`
     Plus,
     /// Minus operator `-`
@@ -113,6 +115,7 @@ impl fmt::Display for Token {
             Token::Comma => f.write_str(","),
             Token::Whitespace(ws) => write!(f, "{}", ws),
             Token::DoubleEq => f.write_str("=="),
+            Token::Spaceship => f.write_str("<=>"),
             Token::Eq => f.write_str("="),
             Token::Neq => f.write_str("<>"),
             Token::Lt => f.write_str("<"),
@@ -416,7 +419,13 @@ impl<'a> Tokenizer<'a> {
                 '<' => {
                     chars.next(); // consume
                     match chars.peek() {
-                        Some('=') => self.consume_and_return(chars, Token::LtEq),
+                        Some('=') => {
+                            chars.next();
+                            match chars.peek() {
+                                Some('>') => self.consume_and_return(chars, Token::Spaceship),
+                                _ => Ok(Some(Token::LtEq))
+                            }
+                        },
                         Some('>') => self.consume_and_return(chars, Token::Neq),
                         _ => Ok(Some(Token::Lt)),
                     }

tests/sqlparser_hive.rs

@@ -15,10 +15,10 @@
 //! Test SQL syntax specific to Hive. The parser based on the generic dialect
 //! is also tested (on the inputs it can handle).
 
-use sqlparser::ast::*;
+
 use sqlparser::dialect::{GenericDialect, HiveDialect};
 use sqlparser::test_utils::*;
-use sqlparser::parser::ParserError;
+
 
 #[test]
 fn parse_table_create() {
@@ -59,6 +59,12 @@ fn parse_set() {
     hive().verified_stmt(set);
 }
 
+#[test]
+fn test_spaceship() {
+    let spaceship = "SELECT * FROM db.table WHERE a <=> b";
+    hive().verified_stmt(spaceship);
+}
+
 #[test]
 fn parse_with_cte() {
     let with = "WITH a AS (SELECT * FROM table) INSERT INTO TABLE db.table_table PARTITION (a) SELECT * FROM a";