SGA-12672 changed enum to bool, removed the object structure in the test and moved it to another test

Author: etgarperets

src/ast/mod.rs

@@ -92,7 +92,7 @@ pub use self::query::{
     TableIndexType, TableSample, TableSampleBucket, TableSampleKind, TableSampleMethod,
     TableSampleModifier, TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier,
     TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity, UpdateTableFromKind,
-    ValueTableMode, Values, ValuesKeyword, WildcardAdditionalOptions, With, WithFill,
+    ValueTableMode, Values, WildcardAdditionalOptions, With, WithFill,
     XmlNamespaceDefinition, XmlPassingArgument, XmlPassingClause, XmlTableColumn,
     XmlTableColumnOption,
 };

src/ast/query.rs

@@ -3137,30 +3137,16 @@ pub struct Values {
     pub explicit_row: bool,
     // MySql supports both VALUES and VALUE keywords.
     // <https://dev.mysql.com/doc/refman/9.2/en/insert.html>
-    pub keyword: ValuesKeyword,
+    pub value_keyword: bool,
     pub rows: Vec<Vec<Expr>>,
 }
 
-#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub enum ValuesKeyword {
-    Values,
-    Value,
-}
-
-impl fmt::Display for ValuesKeyword {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ValuesKeyword::Values => write!(f, "VALUES"),
-            ValuesKeyword::Value => write!(f, "VALUE"),
-        }
-    }
-}
-
 impl fmt::Display for Values {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.keyword)?;
+        match self.value_keyword {
+            true => f.write_str("VALUE")?,
+            false => f.write_str("VALUES")?,
+        };
         let prefix = if self.explicit_row { "ROW" } else { "" };
         let mut delim = "";
         for row in &self.rows {

src/ast/spans.rs

@@ -223,7 +223,7 @@ impl Spanned for Values {
     fn span(&self) -> Span {
         let Values {
             explicit_row: _, // bool,
-            keyword: _,
+            value_keyword: _,
             rows,
         } = self;
 

src/parser/mod.rs

@@ -39,7 +39,6 @@ use crate::ast::helpers::{
     stmt_create_table::{CreateTableBuilder, CreateTableConfiguration},
 };
 use crate::ast::Statement::CreatePolicy;
-use crate::ast::ValuesKeyword;
 use crate::ast::*;
 use crate::dialect::*;
 use crate::keywords::{Keyword, ALL_KEYWORDS};
@@ -12529,10 +12528,10 @@ impl<'a> Parser<'a> {
             SetExpr::Query(subquery)
         } else if self.parse_keyword(Keyword::VALUES) {
             let is_mysql = dialect_of!(self is MySqlDialect);
-            SetExpr::Values(self.parse_values(is_mysql, ValuesKeyword::Values)?)
+            SetExpr::Values(self.parse_values(is_mysql, false)?)
         } else if self.parse_keyword(Keyword::VALUE) {
             let is_mysql = dialect_of!(self is MySqlDialect);
-            SetExpr::Values(self.parse_values(is_mysql, ValuesKeyword::Value)?)
+            SetExpr::Values(self.parse_values(is_mysql, true)?)
         } else if self.parse_keyword(Keyword::TABLE) {
             SetExpr::Table(Box::new(self.parse_as_table()?))
         } else {
@@ -13836,7 +13835,7 @@ impl<'a> Parser<'a> {
             // Snowflake and Databricks allow syntax like below:
             // SELECT * FROM VALUES (1, 'a'), (2, 'b') AS t (col1, col2)
             // where there are no parentheses around the VALUES clause.
-            let values = SetExpr::Values(self.parse_values(false, ValuesKeyword::Values)?);
+            let values = SetExpr::Values(self.parse_values(false, false)?);
             let alias = self.maybe_parse_table_alias()?;
             Ok(TableFactor::Derived {
                 lateral: false,
@@ -16506,7 +16505,7 @@ impl<'a> Parser<'a> {
     pub fn parse_values(
         &mut self,
         allow_empty: bool,
-        keyword: ValuesKeyword,
+        value_keyword: bool,
     ) -> Result<Values, ParserError> {
         let mut explicit_row = false;
 
@@ -16528,7 +16527,7 @@ impl<'a> Parser<'a> {
         Ok(Values {
             explicit_row,
             rows,
-            keyword,
+            value_keyword,
         })
     }
 
@@ -16944,7 +16943,7 @@ impl<'a> Parser<'a> {
                         MergeInsertKind::Row
                     } else {
                         self.expect_keyword_is(Keyword::VALUES)?;
-                        let values = self.parse_values(is_mysql, ValuesKeyword::Values)?;
+                        let values = self.parse_values(is_mysql, false)?;
                         MergeInsertKind::Values(values)
                     };
                     MergeAction::Insert(MergeInsertExpr { columns, kind })

tests/sqlparser_bigquery.rs

@@ -1807,7 +1807,7 @@ fn parse_merge() {
     let insert_action = MergeAction::Insert(MergeInsertExpr {
         columns: vec![Ident::new("product"), Ident::new("quantity")],
         kind: MergeInsertKind::Values(Values {
-            keyword: ValuesKeyword::Values,
+            value_keyword: false,
             explicit_row: false,
             rows: vec![vec![Expr::value(number("1")), Expr::value(number("2"))]],
         }),
@@ -1952,7 +1952,7 @@ fn parse_merge() {
                         action: MergeAction::Insert(MergeInsertExpr {
                             columns: vec![Ident::new("a"), Ident::new("b"),],
                             kind: MergeInsertKind::Values(Values {
-                                keyword: ValuesKeyword::Values,
+                                value_keyword: false,
                                 explicit_row: false,
                                 rows: vec![vec![
                                     Expr::value(number("1")),
@@ -1967,7 +1967,7 @@ fn parse_merge() {
                         action: MergeAction::Insert(MergeInsertExpr {
                             columns: vec![],
                             kind: MergeInsertKind::Values(Values {
-                                keyword: ValuesKeyword::Values,
+                                value_keyword: false,
                                 explicit_row: false,
                                 rows: vec![vec![
                                     Expr::value(number("1")),

tests/sqlparser_common.rs

@@ -106,33 +106,44 @@ fn parse_insert_values() {
     let rows2 = vec![row.clone(), row];
 
     let sql = "INSERT customer VALUES (1, 2, 3)";
-    check_one(sql, "customer", &[], &rows1);
+    check_one(sql, "customer", &[], &rows1, false);
 
     let sql = "INSERT INTO customer VALUES (1, 2, 3)";
-    check_one(sql, "customer", &[], &rows1);
+    check_one(sql, "customer", &[], &rows1, false);
 
     let sql = "INSERT INTO customer VALUES (1, 2, 3), (1, 2, 3)";
-    check_one(sql, "customer", &[], &rows2);
+    check_one(sql, "customer", &[], &rows2, false);
 
     let sql = "INSERT INTO public.customer VALUES (1, 2, 3)";
-    check_one(sql, "public.customer", &[], &rows1);
+    check_one(sql, "public.customer", &[], &rows1, false);
 
     let sql = "INSERT INTO db.public.customer VALUES (1, 2, 3)";
-    check_one(sql, "db.public.customer", &[], &rows1);
+    check_one(sql, "db.public.customer", &[], &rows1, false);
 
     let sql = "INSERT INTO public.customer (id, name, active) VALUES (1, 2, 3)";
     check_one(
         sql,
         "public.customer",
         &["id".to_string(), "name".to_string(), "active".to_string()],
         &rows1,
+        false,
+    );
+
+    let sql = r"INSERT INTO t (id, name, active) VALUE (1, 2, 3)";
+    check_one(
+        sql,
+        "t",
+        &["id".to_string(), "name".to_string(), "active".to_string()],
+        &rows1,
+        true,
     );
 
     fn check_one(
         sql: &str,
         expected_table_name: &str,
         expected_columns: &[String],
         expected_rows: &[Vec<Expr>],
+        expected_value_keyword: bool,
     ) {
         match verified_stmt(sql) {
             Statement::Insert(Insert {
@@ -147,8 +158,9 @@ fn parse_insert_values() {
                     assert_eq!(column, &Ident::new(expected_columns[index].clone()));
                 }
                 match *source.body {
-                    SetExpr::Values(Values { rows, .. }) => {
-                        assert_eq!(rows.as_slice(), expected_rows)
+                    SetExpr::Values(Values { rows, value_keyword, .. }) => {
+                        assert_eq!(rows.as_slice(), expected_rows);
+                        assert!(value_keyword == expected_value_keyword);
                     }
                     _ => unreachable!(),
                 }
@@ -9908,7 +9920,7 @@ fn parse_merge() {
                         action: MergeAction::Insert(MergeInsertExpr {
                             columns: vec![Ident::new("A"), Ident::new("B"), Ident::new("C")],
                             kind: MergeInsertKind::Values(Values {
-                                keyword: ValuesKeyword::Values,
+                                value_keyword: false,
                                 explicit_row: false,
                                 rows: vec![vec![
                                     Expr::CompoundIdentifier(vec![

tests/sqlparser_databricks.rs

@@ -157,7 +157,7 @@ fn test_databricks_lambdas() {
 #[test]
 fn test_values_clause() {
     let values = Values {
-        keyword: ValuesKeyword::Values,
+        value_keyword: false,
         explicit_row: false,
         rows: vec![
             vec![

tests/sqlparser_mysql.rs

@@ -1885,7 +1885,7 @@ fn parse_simple_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![
                             vec![
@@ -1951,7 +1951,7 @@ fn parse_ignore_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2001,7 +2001,7 @@ fn parse_priority_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2048,7 +2048,7 @@ fn parse_priority_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2101,7 +2101,7 @@ fn parse_insert_as() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![Expr::Value(
                             (Value::SingleQuotedString("2024-01-01".to_string())).with_empty_span()
@@ -2161,7 +2161,7 @@ fn parse_insert_as() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::value(number("1")),
@@ -2212,7 +2212,7 @@ fn parse_replace_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2260,7 +2260,7 @@ fn parse_empty_row_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![], vec![]]
                     })),
@@ -2311,7 +2311,7 @@ fn parse_insert_with_on_duplicate_update() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Values,
+                        value_keyword: false,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -4362,41 +4362,3 @@ fn test_create_index_options() {
         "CREATE INDEX idx_name ON t(c1, c2) USING BTREE LOCK = EXCLUSIVE ALGORITHM = DEFAULT",
     );
 }
-
-#[test]
-fn test_insert_into_value() {
-    let sql = r"INSERT INTO t (id, name) VALUE ('AAA', 'BBB')";
-    match mysql_and_generic().verified_stmt(sql) {
-        Statement::Insert(Insert { source, .. }) => {
-            assert_eq!(
-                Some(Box::new(Query {
-                    with: None,
-                    body: Box::new(SetExpr::Values(Values {
-                        keyword: ValuesKeyword::Value,
-                        explicit_row: false,
-                        rows: vec![vec![
-                            Expr::Value(ValueWithSpan {
-                                value: Value::SingleQuotedString("AAA".to_string()),
-                                span: Span::empty(),
-                            }),
-                            Expr::Value(ValueWithSpan {
-                                value: Value::SingleQuotedString("BBB".to_string()),
-                                span: Span::empty(),
-                            }),
-                        ]],
-                    })),
-                    order_by: None,
-                    limit_clause: None,
-                    fetch: None,
-                    locks: vec![],
-                    for_clause: None,
-                    settings: None,
-                    format_clause: None,
-                    pipe_operators: vec![],
-                })),
-                source
-            );
-        }
-        _ => unreachable!(),
-    }
-}

tests/sqlparser_postgres.rs

@@ -5169,7 +5169,7 @@ fn test_simple_postgres_insert_with_alias() {
             source: Some(Box::new(Query {
                 with: None,
                 body: Box::new(SetExpr::Values(Values {
-                    keyword: ValuesKeyword::Values,
+                    value_keyword: false,
                     explicit_row: false,
                     rows: vec![vec![
                         Expr::Identifier(Ident::new("DEFAULT")),
@@ -5239,7 +5239,7 @@ fn test_simple_postgres_insert_with_alias() {
             source: Some(Box::new(Query {
                 with: None,
                 body: Box::new(SetExpr::Values(Values {
-                    keyword: ValuesKeyword::Values,
+                    value_keyword: false,
                     explicit_row: false,
                     rows: vec![vec![
                         Expr::Identifier(Ident::new("DEFAULT")),
@@ -5311,7 +5311,7 @@ fn test_simple_insert_with_quoted_alias() {
             source: Some(Box::new(Query {
                 with: None,
                 body: Box::new(SetExpr::Values(Values {
-                    keyword: ValuesKeyword::Values,
+                    value_keyword: false,
                     explicit_row: false,
                     rows: vec![vec![
                         Expr::Identifier(Ident::new("DEFAULT")),