Add support for INSERT INTO VALUE

src/ast/mod.rs

@@ -92,8 +92,9 @@ pub use self::query::{
     TableIndexType, TableSample, TableSampleBucket, TableSampleKind, TableSampleMethod,
     TableSampleModifier, TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier,
     TableSampleUnit, TableVersion, TableWithJoins, Top, TopQuantity, UpdateTableFromKind,
-    ValueTableMode, Values, WildcardAdditionalOptions, With, WithFill, XmlNamespaceDefinition,
-    XmlPassingArgument, XmlPassingClause, XmlTableColumn, XmlTableColumnOption,
+    ValueTableMode, Values, ValuesKeyword, WildcardAdditionalOptions, With, WithFill,
+    XmlNamespaceDefinition, XmlPassingArgument, XmlPassingClause, XmlTableColumn,
+    XmlTableColumnOption,
 };
 
 pub use self::trigger::{
@@ -2787,10 +2788,11 @@ impl fmt::Display for Declare {
 }
 
 /// Sql options of a `CREATE TABLE` statement.
-#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum CreateTableOptions {
+    #[default]
     None,
     /// Options specified using the `WITH` keyword.
     /// e.g. `WITH (description = "123")`
@@ -2819,12 +2821,6 @@ pub enum CreateTableOptions {
     TableProperties(Vec<SqlOption>),
 }
 
-impl Default for CreateTableOptions {
-    fn default() -> Self {
-        Self::None
-    }
-}
-
 impl fmt::Display for CreateTableOptions {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {

src/ast/query.rs

@@ -3135,12 +3135,32 @@ pub struct Values {
     /// Was there an explicit ROWs keyword (MySQL)?
     /// <https://dev.mysql.com/doc/refman/8.0/en/values.html>
     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 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 {
-        f.write_str("VALUES")?;
+        write!(f, "{}", self.keyword)?;
         let prefix = if self.explicit_row { "ROW" } else { "" };
         let mut delim = "";
         for row in &self.rows {

src/ast/spans.rs

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

src/parser/mod.rs

@@ -39,6 +39,7 @@ 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};
@@ -12528,7 +12529,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)?)
+            SetExpr::Values(self.parse_values(is_mysql, ValuesKeyword::Values)?)
+        } else if self.parse_keyword(Keyword::VALUE) {
+            let is_mysql = dialect_of!(self is MySqlDialect);
+            SetExpr::Values(self.parse_values(is_mysql, ValuesKeyword::Value)?)
         } else if self.parse_keyword(Keyword::TABLE) {
             SetExpr::Table(Box::new(self.parse_as_table()?))
         } else {
@@ -13832,7 +13836,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)?);
+            let values = SetExpr::Values(self.parse_values(false, ValuesKeyword::Values)?);
             let alias = self.maybe_parse_table_alias()?;
             Ok(TableFactor::Derived {
                 lateral: false,
@@ -16499,7 +16503,11 @@ impl<'a> Parser<'a> {
         })
     }
 
-    pub fn parse_values(&mut self, allow_empty: bool) -> Result<Values, ParserError> {
+    pub fn parse_values(
+        &mut self,
+        allow_empty: bool,
+        keyword: ValuesKeyword,
+    ) -> Result<Values, ParserError> {
         let mut explicit_row = false;
 
         let rows = self.parse_comma_separated(|parser| {
@@ -16517,7 +16525,11 @@ impl<'a> Parser<'a> {
                 Ok(exprs)
             }
         })?;
-        Ok(Values { explicit_row, rows })
+        Ok(Values {
+            explicit_row,
+            rows,
+            keyword,
+        })
     }
 
     pub fn parse_start_transaction(&mut self) -> Result<Statement, ParserError> {
@@ -16932,7 +16944,7 @@ impl<'a> Parser<'a> {
                         MergeInsertKind::Row
                     } else {
                         self.expect_keyword_is(Keyword::VALUES)?;
-                        let values = self.parse_values(is_mysql)?;
+                        let values = self.parse_values(is_mysql, ValuesKeyword::Values)?;
                         MergeInsertKind::Values(values)
                     };
                     MergeAction::Insert(MergeInsertExpr { columns, kind })

tests/sqlparser_bigquery.rs

@@ -1807,6 +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,
             explicit_row: false,
             rows: vec![vec![Expr::value(number("1")), Expr::value(number("2"))]],
         }),
@@ -1951,6 +1952,7 @@ fn parse_merge() {
                         action: MergeAction::Insert(MergeInsertExpr {
                             columns: vec![Ident::new("a"), Ident::new("b"),],
                             kind: MergeInsertKind::Values(Values {
+                                keyword: ValuesKeyword::Values,
                                 explicit_row: false,
                                 rows: vec![vec![
                                     Expr::value(number("1")),
@@ -1965,6 +1967,7 @@ fn parse_merge() {
                         action: MergeAction::Insert(MergeInsertExpr {
                             columns: vec![],
                             kind: MergeInsertKind::Values(Values {
+                                keyword: ValuesKeyword::Values,
                                 explicit_row: false,
                                 rows: vec![vec![
                                     Expr::value(number("1")),

tests/sqlparser_common.rs

@@ -9908,6 +9908,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,
                                 explicit_row: false,
                                 rows: vec![vec![
                                     Expr::CompoundIdentifier(vec![

tests/sqlparser_databricks.rs

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

tests/sqlparser_mysql.rs

@@ -1885,6 +1885,7 @@ fn parse_simple_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![
                             vec![
@@ -1950,6 +1951,7 @@ fn parse_ignore_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -1999,6 +2001,7 @@ fn parse_priority_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2045,6 +2048,7 @@ fn parse_priority_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2097,6 +2101,7 @@ fn parse_insert_as() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![Expr::Value(
                             (Value::SingleQuotedString("2024-01-01".to_string())).with_empty_span()
@@ -2156,6 +2161,7 @@ fn parse_insert_as() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::value(number("1")),
@@ -2206,6 +2212,7 @@ fn parse_replace_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -2253,6 +2260,7 @@ fn parse_empty_row_insert() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![], vec![]]
                     })),
@@ -2303,6 +2311,7 @@ fn parse_insert_with_on_duplicate_update() {
                 Some(Box::new(Query {
                     with: None,
                     body: Box::new(SetExpr::Values(Values {
+                        keyword: ValuesKeyword::Values,
                         explicit_row: false,
                         rows: vec![vec![
                             Expr::Value(
@@ -4353,3 +4362,41 @@ 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,6 +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,
                     explicit_row: false,
                     rows: vec![vec![
                         Expr::Identifier(Ident::new("DEFAULT")),
@@ -5238,6 +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,
                     explicit_row: false,
                     rows: vec![vec![
                         Expr::Identifier(Ident::new("DEFAULT")),
@@ -5309,6 +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,
                     explicit_row: false,
                     rows: vec![vec![
                         Expr::Identifier(Ident::new("DEFAULT")),