Add support for procedure parameter default values

Author: aharpervc

src/ast/ddl.rs

@@ -1458,14 +1458,23 @@ pub struct ProcedureParam {
     pub name: Ident,
     pub data_type: DataType,
     pub mode: Option<ArgMode>,
+    pub default: Option<Expr>,
 }
 
 impl fmt::Display for ProcedureParam {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(mode) = &self.mode {
-            write!(f, "{mode} {} {}", self.name, self.data_type)
+            if let Some(default) = &self.default {
+                write!(f, "{mode} {} {} = {}", self.name, self.data_type, default)
+            } else {
+                write!(f, "{mode} {} {}", self.name, self.data_type)
+            }
         } else {
-            write!(f, "{} {}", self.name, self.data_type)
+            if let Some(default) = &self.default {
+                write!(f, "{} {} = {}", self.name, self.data_type, default)
+            } else {
+                write!(f, "{} {}", self.name, self.data_type)
+            }
         }
     }
 }

src/parser/mod.rs

@@ -7897,10 +7897,17 @@ impl<'a> Parser<'a> {
         };
         let name = self.parse_identifier()?;
         let data_type = self.parse_data_type()?;
+        let default = if self.consume_token(&Token::Eq) {
+            Some(self.parse_expr()?)
+        } else {
+            None
+        };
+
         Ok(ProcedureParam {
             name,
             data_type,
             mode,
+            default,
         })
     }
 

tests/sqlparser_common.rs

@@ -16497,7 +16497,8 @@ fn parse_create_procedure_with_parameter_modes() {
                             span: fake_span,
                         },
                         data_type: DataType::Integer(None),
-                        mode: Some(ArgMode::In)
+                        mode: Some(ArgMode::In),
+                        default: None,
                     },
                     ProcedureParam {
                         name: Ident {
@@ -16506,7 +16507,8 @@ fn parse_create_procedure_with_parameter_modes() {
                             span: fake_span,
                         },
                         data_type: DataType::Text,
-                        mode: Some(ArgMode::Out)
+                        mode: Some(ArgMode::Out),
+                        default: None,
                     },
                     ProcedureParam {
                         name: Ident {
@@ -16515,7 +16517,8 @@ fn parse_create_procedure_with_parameter_modes() {
                             span: fake_span,
                         },
                         data_type: DataType::Timestamp(None, TimezoneInfo::None),
-                        mode: Some(ArgMode::InOut)
+                        mode: Some(ArgMode::InOut),
+                        default: None,
                     },
                     ProcedureParam {
                         name: Ident {
@@ -16524,7 +16527,8 @@ fn parse_create_procedure_with_parameter_modes() {
                             span: fake_span,
                         },
                         data_type: DataType::Bool,
-                        mode: None
+                        mode: None,
+                        default: None,
                     },
                 ])
             );
@@ -16533,6 +16537,40 @@ fn parse_create_procedure_with_parameter_modes() {
     }
 }
 
+#[test]
+fn create_procedure_with_parameter_default_value() {
+    let sql = r#"CREATE PROCEDURE test_proc (a INT = 42) AS BEGIN SELECT 1; END"#;
+    match verified_stmt(sql) {
+        Statement::CreateProcedure {
+            or_alter,
+            name,
+            params,
+            ..
+        } => {
+            assert_eq!(or_alter, false);
+            assert_eq!(name.to_string(), "test_proc");
+            let fake_span = Span {
+                start: Location { line: 0, column: 0 },
+                end: Location { line: 0, column: 0 },
+            };
+            assert_eq!(
+                params,
+                Some(vec![ProcedureParam {
+                    name: Ident {
+                        value: "a".into(),
+                        quote_style: None,
+                        span: fake_span,
+                    },
+                    data_type: DataType::Int(None),
+                    mode: None,
+                    default: Some(Expr::Value((number("42")).with_empty_span())),
+                },])
+            );
+        }
+        _ => unreachable!(),
+    }
+}
+
 #[test]
 fn parse_not_null() {
     let _ = all_dialects().expr_parses_to("x NOT NULL", "x IS NOT NULL");

tests/sqlparser_mssql.rs

@@ -156,6 +156,7 @@ fn parse_create_procedure() {
                     },
                     data_type: DataType::Int(None),
                     mode: None,
+                    default: None,
                 },
                 ProcedureParam {
                     name: Ident {
@@ -168,6 +169,7 @@ fn parse_create_procedure() {
                         unit: None
                     })),
                     mode: None,
+                    default: None,
                 }
             ]),
             name: ObjectName::from(vec![Ident {