fix: remove direct unwraps (#23)

src/sql/src/error.rs

@@ -2,6 +2,7 @@ use std::any::Any;
 
 use common_error::prelude::*;
 use sqlparser::parser::ParserError;
+use sqlparser::tokenizer::TokenizerError;
 
 /// SQL parser errors.
 // Now the error in parser does not contains backtrace to avoid generating backtrace
@@ -29,6 +30,9 @@ pub enum Error {
     // Syntax error from sql parser.
     #[snafu(display("Syntax error, sql: {}, source: {}", sql, source))]
     Syntax { sql: String, source: ParserError },
+
+    #[snafu(display("Tokenizer error, sql: {}, source: {}", sql, source))]
+    Tokenizer { sql: String, source: TokenizerError },
 }
 
 impl ErrorExt for Error {
@@ -37,7 +41,7 @@ impl ErrorExt for Error {
 
         match self {
             Unsupported { .. } => StatusCode::Unsupported,
-            Unexpected { .. } | Syntax { .. } => StatusCode::InvalidSyntax,
+            Unexpected { .. } | Syntax { .. } | Tokenizer { .. } => StatusCode::InvalidSyntax,
         }
     }
 
@@ -94,4 +98,18 @@ mod tests {
         };
         assert_eq!(StatusCode::Unsupported, err.status_code());
     }
+
+    #[test]
+    pub fn test_tokenizer_error() {
+        let err = Error::Tokenizer {
+            sql: "".to_string(),
+            source: sqlparser::tokenizer::TokenizerError {
+                message: "tokenizer error".to_string(),
+                col: 1,
+                line: 1,
+            },
+        };
+
+        assert_eq!(StatusCode::InvalidSyntax, err.status_code());
+    }
 }

src/sql/src/parser.rs

@@ -4,7 +4,7 @@ use sqlparser::keywords::Keyword;
 use sqlparser::parser::Parser;
 use sqlparser::tokenizer::{Token, Tokenizer};
 
-use crate::error::{self, Error};
+use crate::error::{self, Error, TokenizerSnafu};
 use crate::statements::show_database::SqlShowDatabase;
 use crate::statements::show_kind::ShowKind;
 use crate::statements::statement::Statement;
@@ -23,7 +23,7 @@ impl<'a> ParserContext<'a> {
         let mut stmts: Vec<Statement> = Vec::new();
         let mut tokenizer = Tokenizer::new(dialect, sql);
 
-        let tokens: Vec<Token> = tokenizer.tokenize().unwrap();
+        let tokens: Vec<Token> = tokenizer.tokenize().context(TokenizerSnafu { sql })?;
 
         let mut parser_ctx = ParserContext {
             sql,
@@ -135,22 +135,21 @@ impl<'a> ParserContext<'a> {
             ))),
             Token::Word(w) => match w.keyword {
                 Keyword::LIKE => Ok(Statement::ShowDatabases(SqlShowDatabase::new(
-                    ShowKind::Like(
-                        self.parser
-                            .parse_identifier()
-                            .context(error::UnexpectedSnafu {
-                                sql: self.sql,
-                                expected: "LIKE",
-                                actual: tok.to_string(),
-                            })
-                            .unwrap(),
-                    ),
+                    ShowKind::Like(self.parser.parse_identifier().with_context(|_| {
+                        error::UnexpectedSnafu {
+                            sql: self.sql,
+                            expected: "LIKE",
+                            actual: tok.to_string(),
+                        }
+                    })?),
                 ))),
                 Keyword::WHERE => Ok(Statement::ShowDatabases(SqlShowDatabase::new(
-                    ShowKind::Where(self.parser.parse_expr().context(error::UnexpectedSnafu {
-                        sql: self.sql.to_string(),
-                        expected: "some valid expression".to_string(),
-                        actual: self.peek_token_as_string(),
+                    ShowKind::Where(self.parser.parse_expr().with_context(|_| {
+                        error::UnexpectedSnafu {
+                            sql: self.sql,
+                            expected: "some valid expression",
+                            actual: self.peek_token_as_string(),
+                        }
                     })?),
                 ))),
                 _ => self.unsupported(self.peek_token_as_string()),