Fix conditionals in multi statement functions

- when a multi statement block concludes (eg, `BEGIN`..`END`), that last `END` means we should *not* be expecting a statement delimiter

Author: aharpervc

src/parser/mod.rs

@@ -484,8 +484,14 @@ impl<'a> Parser<'a> {
             }
 
             let statement = self.parse_statement()?;
+            expecting_statement_delimiter = match &statement {
+                Statement::If(s) => match s.if_block.conditional_statements {
+                    ConditionalStatements::BeginEnd { .. } => false,
+                   _ => true,
+                },
+                _ => true
+            };
             stmts.push(statement);
-            expecting_statement_delimiter = true;
         }
         Ok(stmts)
     }
@@ -5170,8 +5176,14 @@ impl<'a> Parser<'a> {
 
         self.expect_keyword_is(Keyword::AS)?;
         self.expect_keyword_is(Keyword::BEGIN)?;
-        let function_body = Some(CreateFunctionBody::MultiStatement(self.parse_statements()?));
-        self.expect_keyword_is(Keyword::END)?;
+        let mut result = self.parse_statements()?;
+        // note: `parse_statements` will consume the `END` token & produce a Commit statement...
+        if let Some(Statement::Commit{ chain, end, modifier }) = result.last() {
+            if *chain == false && *end == true && *modifier == None {
+                result = result[..result.len() - 1].to_vec();
+            }
+        }
+        let function_body = Some(CreateFunctionBody::MultiStatement(result));
 
         Ok(Statement::CreateFunction(CreateFunction {
             or_alter,

tests/sqlparser_mssql.rs

@@ -23,7 +23,8 @@
 mod test_utils;
 
 use helpers::attached_token::AttachedToken;
-use sqlparser::tokenizer::{Location, Span};
+use sqlparser::keywords::Keyword;
+use sqlparser::tokenizer::{Location, Span, TokenWithSpan};
 use test_utils::*;
 
 use sqlparser::ast::DataType::{Int, Text, Varbinary};
@@ -326,6 +327,83 @@ fn parse_create_function() {
             remote_connection: None,
         }),
     );
+
+    let create_function_with_conditional = r#"
+        CREATE FUNCTION some_scalar_udf()
+        RETURNS INT
+        AS
+        BEGIN
+            IF 1=2
+            BEGIN
+                RETURN 1;
+            END
+
+            RETURN 0;
+        END
+    "#;
+    let create_stmt = ms().one_statement_parses_to(create_function_with_conditional, "");
+    assert_eq!(
+        create_stmt,
+        Statement::CreateFunction(CreateFunction {
+            or_alter: false,
+            or_replace: false,
+            temporary: false,
+            if_not_exists: false,
+            name: ObjectName::from(vec![Ident {
+                value: "some_scalar_udf".into(),
+                quote_style: None,
+                span: Span::empty(),
+            }]),
+            args: Some(vec![]),
+            return_type: Some(DataType::Int(None)),
+            function_body: Some(CreateFunctionBody::MultiStatement(vec![
+                Statement::If(IfStatement {
+                    if_block: ConditionalStatementBlock {
+                        start_token: AttachedToken(TokenWithSpan::wrap(sqlparser::tokenizer::Token::Word(sqlparser::tokenizer::Word {
+                            value: "IF".to_string(),
+                            quote_style: None,
+                            keyword: Keyword::IF
+                        }))),
+                        condition: Some(Expr::BinaryOp {
+                            left: Box::new(Expr::Value(Value::Number("1".to_string(), false).with_empty_span())),
+                            op: sqlparser::ast::BinaryOperator::Eq,
+                            right: Box::new(Expr::Value(Value::Number("2".to_string(), false).with_empty_span())),
+                        }),
+                           then_token: None,
+                           conditional_statements: ConditionalStatements::BeginEnd {
+                            begin_token: AttachedToken(TokenWithSpan::wrap(sqlparser::tokenizer::Token::Word(sqlparser::tokenizer::Word {
+                                value: "BEGIN".to_string(),
+                                quote_style: None,
+                                keyword: Keyword::BEGIN
+                            }))),
+                            statements: vec![Statement::Return(ReturnStatement {
+                                value: Some(ReturnStatementValue::Expr(Expr::Value((number("1")).with_empty_span()))),
+                            })],
+                            end_token: AttachedToken(TokenWithSpan::wrap(sqlparser::tokenizer::Token::Word(sqlparser::tokenizer::Word {
+                                value: "END".to_string(),
+                                quote_style: None,
+                                keyword: Keyword::END
+                            }))),
+                        },
+                    },
+                    elseif_blocks: vec![],
+                    else_block: None,
+                    end_token: None,
+                }),
+                Statement::Return(ReturnStatement {
+                    value: Some(ReturnStatementValue::Expr(Expr::Value((number("0")).with_empty_span()))),
+                }),
+            ])),
+            behavior: None,
+            called_on_null: None,
+            parallel: None,
+            using: None,
+            language: None,
+            determinism_specifier: None,
+            options: None,
+            remote_connection: None,
+        })
+    );
 }
 
 #[test]