enhance: explicitly destructur tableconstraints

Signed-off-by: StandingMan <jmtangcs@gmail.com>

Author: Standing-Man

datafusion/expr/src/expr.rs

@@ -1268,7 +1268,6 @@ impl Display for ExceptSelectItem {
     }
 }
 
-#[cfg(not(feature = "sql"))]
 pub fn display_comma_separated<T>(slice: &[T]) -> String
 where
     T: Display,
@@ -1402,14 +1401,8 @@ pub struct PlannedReplaceSelectItem {
 
 impl Display for PlannedReplaceSelectItem {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "REPLACE (")?;
-        for (i, item) in self.items.iter().enumerate() {
-            if i > 0 {
-                write!(f, ", ")?;
-            }
-            write!(f, "{item}")?;
-        }
-        write!(f, ")")?;
+        write!(f, "REPLACE")?;
+        write!(f, " ({})", display_comma_separated(&self.items))?;
         Ok(())
     }
 }

datafusion/sql/src/statement.rs

@@ -108,7 +108,14 @@ fn calc_inline_constraints_from_columns(columns: &[ColumnDef]) -> Vec<TableConst
         for ast::ColumnOptionDef { name, option } in &column.options {
             match option {
                 ast::ColumnOption::Unique(UniqueConstraint {
-                    characteristics, ..
+                    characteristics,
+                    name,
+                    index_name: _index_name,
+                    index_type_display: _index_type_display,
+                    index_type: _index_type,
+                    columns: _column,
+                    index_options: _index_options,
+                    nulls_distinct: _nulls_distinct,
                 }) => constraints.push(TableConstraint::Unique(UniqueConstraint {
                     name: name.clone(),
                     index_name: None,
@@ -131,7 +138,11 @@ fn calc_inline_constraints_from_columns(columns: &[ColumnDef]) -> Vec<TableConst
                 })),
                 ast::ColumnOption::PrimaryKey(PrimaryKeyConstraint {
                     characteristics,
-                    ..
+                    name: _name,
+                    index_name: _index_name,
+                    index_type: _index_type,
+                    columns: _columns,
+                    index_options: _index_options,
                 }) => {
                     constraints.push(TableConstraint::PrimaryKey(PrimaryKeyConstraint {
                         name: name.clone(),
@@ -158,27 +169,32 @@ fn calc_inline_constraints_from_columns(columns: &[ColumnDef]) -> Vec<TableConst
                     on_delete,
                     on_update,
                     characteristics,
-                    ..
+                    name: _name,
+                    index_name: _index_name,
+                    columns: _columns,
+                    match_kind: _match_kind,
                 }) => {
                     constraints.push(TableConstraint::ForeignKey(ForeignKeyConstraint {
                         name: name.clone(),
                         index_name: None,
                         columns: vec![],
                         foreign_table: foreign_table.clone(),
                         referred_columns: referred_columns.clone(),
-                        on_delete: on_delete.clone(),
-                        on_update: on_update.clone(),
+                        on_delete: *on_delete,
+                        on_update: *on_update,
                         match_kind: None,
                         characteristics: *characteristics,
                     }))
                 }
-                ast::ColumnOption::Check(CheckConstraint { name, expr, .. }) => {
-                    constraints.push(TableConstraint::Check(CheckConstraint {
-                        name: name.clone(),
-                        expr: expr.clone(),
-                        enforced: None,
-                    }))
-                }
+                ast::ColumnOption::Check(CheckConstraint {
+                    name,
+                    expr,
+                    enforced: _enforced,
+                }) => constraints.push(TableConstraint::Check(CheckConstraint {
+                    name: name.clone(),
+                    expr: expr.clone(),
+                    enforced: None,
+                })),
                 ast::ColumnOption::Default(_)
                 | ast::ColumnOption::Null
                 | ast::ColumnOption::NotNull
@@ -1042,7 +1058,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
                 returning,
                 or,
                 limit,
-                ..
+                update_token: _,
             }) => {
                 let from_clauses =
                     from.map(|update_table_from_kind| match update_table_from_kind {
@@ -1074,7 +1090,7 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
                 from,
                 order_by,
                 limit,
-                ..
+                delete_token: _,
             }) => {
                 if !tables.is_empty() {
                     plan_err!("DELETE <TABLE> not supported")?;
@@ -1350,18 +1366,22 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
 
                 Ok(LogicalPlan::Ddl(statement))
             }
-            Statement::DropFunction(func) => {
+            Statement::DropFunction(ast::DropFunction {
+                if_exists,
+                func_desc,
+                drop_behavior: _,
+            }) => {
                 // According to postgresql documentation it can be only one function
                 // specified in drop statement
-                if let Some(desc) = func.func_desc.first() {
+                if let Some(desc) = func_desc.first() {
                     // At the moment functions can't be qualified `schema.name`
                     let name = match &desc.name.0[..] {
                         [] => exec_err!("Function should have name")?,
                         [n] => n.as_ident().unwrap().value.clone(),
                         [..] => not_impl_err!("Qualified functions are not supported")?,
                     };
                     let statement = DdlStatement::DropFunction(DropFunction {
-                        if_exists: func.if_exists,
+                        if_exists,
                         name,
                         schema: DFSchemaRef::new(DFSchema::empty()),
                     });

datafusion/sql/src/values.rs

@@ -18,7 +18,7 @@
 use std::sync::Arc;
 
 use crate::planner::{ContextProvider, PlannerContext, SqlToRel};
-use datafusion_common::{DFSchema, Result};
+use datafusion_common::{DFSchema, Result, not_impl_err};
 use datafusion_expr::{LogicalPlan, LogicalPlanBuilder};
 use sqlparser::ast::Values as SQLValues;
 
@@ -31,8 +31,13 @@ impl<S: ContextProvider> SqlToRel<'_, S> {
         let SQLValues {
             explicit_row: _,
             rows,
-            value_keyword: _,
+            value_keyword,
         } = values;
+        if value_keyword {
+            return not_impl_err!(
+                "`VALUE` keyword does not support inserting multiple values."
+            )?;
+        }
 
         let empty_schema = Arc::new(DFSchema::empty());
         let values = rows