feat: support "use" stmt part 1 (#672)

* feat: a bare sketch of session; support "use" in MySQL server; modify insertion and selection related codes in Datanode

src/sql/src/parser.rs

@@ -102,6 +102,21 @@ impl<'a> ParserContext<'a> {
 
                     Keyword::DROP => self.parse_drop(),
 
+                    // TODO(LFC): Use "Keyword::USE" when we can upgrade to newer version of crate sqlparser.
+                    Keyword::NoKeyword if w.value.to_lowercase() == "use" => {
+                        self.parser.next_token();
+
+                        let database_name =
+                            self.parser
+                                .parse_identifier()
+                                .context(error::UnexpectedSnafu {
+                                    sql: self.sql,
+                                    expected: "a database name",
+                                    actual: self.peek_token_as_string(),
+                                })?;
+                        Ok(Statement::Use(database_name.value))
+                    }
+
                     // todo(hl) support more statements.
                     _ => self.unsupported(self.peek_token_as_string()),
                 }

src/sql/src/statements.rs

@@ -42,6 +42,8 @@ use crate::error::{
     SerializeColumnDefaultConstraintSnafu, UnsupportedDefaultValueSnafu,
 };
 
+// TODO(LFC): Get rid of this function, use session context aware version of "table_idents_to_full_name" instead.
+// Current obstacles remain in some usage in Frontend, and other SQLs like "describe", "drop" etc.
 /// Converts maybe fully-qualified table name (`<catalog>.<schema>.<table>` or `<table>` when
 /// catalog and schema are default) to tuple.
 pub fn table_idents_to_full_name(obj_name: &ObjectName) -> Result<(String, String, String)> {

src/sql/src/statements/insert.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use sqlparser::ast::{SetExpr, Statement, UnaryOperator, Values};
+use sqlparser::ast::{ObjectName, SetExpr, Statement, UnaryOperator, Values};
 use sqlparser::parser::ParserError;
 
 use crate::ast::{Expr, Value};
@@ -33,6 +33,13 @@ impl Insert {
         }
     }
 
+    pub fn table_name(&self) -> &ObjectName {
+        match &self.inner {
+            Statement::Insert { table_name, .. } => table_name,
+            _ => unreachable!(),
+        }
+    }
+
     pub fn columns(&self) -> Vec<&String> {
         match &self.inner {
             Statement::Insert { columns, .. } => columns.iter().map(|ident| &ident.value).collect(),
@@ -110,15 +117,6 @@ mod tests {
     use super::*;
     use crate::parser::ParserContext;
 
-    #[test]
-    pub fn test_insert_convert() {
-        let sql = r"INSERT INTO tables_0 VALUES ( 'field_0', 0) ";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GenericDialect {}).unwrap();
-        assert_eq!(1, stmts.len());
-        let insert = stmts.pop().unwrap();
-        let _stmt: Statement = insert.try_into().unwrap();
-    }
-
     #[test]
     fn test_insert_value_with_unary_op() {
         use crate::statements::statement::Statement;

src/sql/src/statements/statement.rs

@@ -12,9 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use sqlparser::ast::Statement as SpStatement;
-use sqlparser::parser::ParserError;
-
 use crate::statements::alter::AlterTable;
 use crate::statements::create::{CreateDatabase, CreateTable};
 use crate::statements::describe::DescribeTable;
@@ -50,37 +47,7 @@ pub enum Statement {
     DescribeTable(DescribeTable),
     // EXPLAIN QUERY
     Explain(Explain),
-}
-
-/// Converts Statement to sqlparser statement
-impl TryFrom<Statement> for SpStatement {
-    type Error = sqlparser::parser::ParserError;
-
-    fn try_from(value: Statement) -> Result<Self, Self::Error> {
-        match value {
-            Statement::ShowDatabases(_) => Err(ParserError::ParserError(
-                "sqlparser does not support SHOW DATABASE query.".to_string(),
-            )),
-            Statement::ShowTables(_) => Err(ParserError::ParserError(
-                "sqlparser does not support SHOW TABLES query.".to_string(),
-            )),
-            Statement::ShowCreateTable(_) => Err(ParserError::ParserError(
-                "sqlparser does not support SHOW CREATE TABLE query.".to_string(),
-            )),
-            Statement::DescribeTable(_) => Err(ParserError::ParserError(
-                "sqlparser does not support DESCRIBE TABLE query.".to_string(),
-            )),
-            Statement::DropTable(_) => Err(ParserError::ParserError(
-                "sqlparser does not support DROP TABLE query.".to_string(),
-            )),
-            Statement::Query(s) => Ok(SpStatement::Query(Box::new(s.inner))),
-            Statement::Insert(i) => Ok(i.inner),
-            Statement::CreateDatabase(_) | Statement::CreateTable(_) | Statement::Alter(_) => {
-                unimplemented!()
-            }
-            Statement::Explain(e) => Ok(e.inner),
-        }
-    }
+    Use(String),
 }
 
 /// Comment hints from SQL.
@@ -92,24 +59,3 @@ pub struct Hint {
     pub comment: String,
     pub prefix: String,
 }
-
-#[cfg(test)]
-mod tests {
-    use std::assert_matches::assert_matches;
-
-    use sqlparser::dialect::GenericDialect;
-
-    use super::*;
-    use crate::parser::ParserContext;
-
-    #[test]
-    pub fn test_statement_convert() {
-        let sql = "SELECT * FROM table_0";
-        let mut stmts = ParserContext::create_with_dialect(sql, &GenericDialect {}).unwrap();
-        assert_eq!(1, stmts.len());
-        let x = stmts.remove(0);
-        let statement = SpStatement::try_from(x).unwrap();
-
-        assert_matches!(statement, SpStatement::Query { .. });
-    }
-}