Further simplify test cases to use verified_stmt

Author: aharpervc

Diff for: tests/sqlparser_mssql.rs

@@ -246,160 +246,22 @@ fn parse_create_function() {
             RETURN @foo; \
         END\
     ";
-    assert_eq!(
-        ms().verified_stmt(multi_statement_function),
-        sqlparser::ast::Statement::CreateFunction(CreateFunction {
-            or_alter: false,
-            or_replace: false,
-            temporary: false,
-            if_not_exists: false,
-            name: ObjectName::from(vec![Ident::new("some_scalar_udf")]),
-            args: Some(vec![
-                OperateFunctionArg {
-                    mode: None,
-                    name: Some(Ident::new("@foo")),
-                    data_type: DataType::Int(None),
-                    default_expr: None,
-                },
-                OperateFunctionArg {
-                    mode: None,
-                    name: Some(Ident::new("@bar")),
-                    data_type: DataType::Varchar(Some(CharacterLength::IntegerLength {
-                        length: 256,
-                        unit: None
-                    })),
-                    default_expr: None,
-                },
-            ]),
-            return_type: Some(DataType::Int(None)),
-            function_body: Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements {
-                begin_token: AttachedToken::empty(),
-                statements: vec![
-                    Statement::Set(Set::SingleAssignment {
-                        scope: None,
-                        hivevar: false,
-                        variable: ObjectName::from(vec!["@foo".into()]),
-                        values: vec![sqlparser::ast::Expr::BinaryOp {
-                            left: Box::new(sqlparser::ast::Expr::Identifier(Ident::new("@foo"))),
-                            op: sqlparser::ast::BinaryOperator::Plus,
-                            right: Box::new(Expr::Value(number("1").with_empty_span())),
-                        }],
-                    }),
-                    Statement::Return(ReturnStatement {
-                        value: Some(ReturnStatementValue::Expr(Expr::Identifier(Ident::new(
-                            "@foo"
-                        )))),
-                    }),
-                ],
-                end_token: AttachedToken::empty(),
-            })),
-            behavior: None,
-            called_on_null: None,
-            parallel: None,
-            using: None,
-            language: None,
-            determinism_specifier: None,
-            options: None,
-            remote_connection: None,
-        }),
-    );
+    let _ = ms().verified_stmt(multi_statement_function);
 
-    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::new("some_scalar_udf")]),
-            args: Some(vec![]),
-            return_type: Some(DataType::Int(None)),
-            function_body: Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements {
-                begin_token: AttachedToken::empty(),
-                statements: 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(number("1").with_empty_span())),
-                                op: sqlparser::ast::BinaryOperator::Eq,
-                                right: Box::new(Expr::Value(number("2").with_empty_span())),
-                            }),
-                            then_token: None,
-                            conditional_statements: ConditionalStatements::BeginEnd(
-                                BeginEndStatements {
-                                    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()
-                        ))),
-                    }),
-                ],
-                end_token: AttachedToken::empty(),
-            })),
-            behavior: None,
-            called_on_null: None,
-            parallel: None,
-            using: None,
-            language: None,
-            determinism_specifier: None,
-            options: None,
-            remote_connection: None,
-        })
-    );
-}
+    let create_function_with_conditional = "\
+        CREATE FUNCTION some_scalar_udf() \
+        RETURNS INT \
+        AS \
+        BEGIN \
+            IF 1 = 2 \
+            BEGIN \
+                RETURN 1; \
+            END; \
+            RETURN 0; \
+        END\
+    ";
+    let _ = ms().verified_stmt(create_function_with_conditional);
 
-#[test]
-fn parse_mssql_create_function() {
     let create_or_alter_function = "\
         CREATE OR ALTER FUNCTION some_scalar_udf(@foo INT, @bar VARCHAR(256)) \
         RETURNS INT \
@@ -409,63 +271,7 @@ fn parse_mssql_create_function() {
             RETURN @foo; \
         END\
     ";
-    assert_eq!(
-        ms().verified_stmt(create_or_alter_function),
-        sqlparser::ast::Statement::CreateFunction(CreateFunction {
-            or_alter: true,
-            or_replace: false,
-            temporary: false,
-            if_not_exists: false,
-            name: ObjectName::from(vec![Ident::new("some_scalar_udf")]),
-            args: Some(vec![
-                OperateFunctionArg {
-                    mode: None,
-                    name: Some(Ident::new("@foo")),
-                    data_type: DataType::Int(None),
-                    default_expr: None,
-                },
-                OperateFunctionArg {
-                    mode: None,
-                    name: Some(Ident::new("@bar")),
-                    data_type: DataType::Varchar(Some(CharacterLength::IntegerLength {
-                        length: 256,
-                        unit: None
-                    })),
-                    default_expr: None,
-                },
-            ]),
-            return_type: Some(DataType::Int(None)),
-            function_body: Some(CreateFunctionBody::AsBeginEnd(BeginEndStatements {
-                begin_token: AttachedToken::empty(),
-                statements: vec![
-                    Statement::Set(Set::SingleAssignment {
-                        scope: None,
-                        hivevar: false,
-                        variable: ObjectName::from(vec!["@foo".into()]),
-                        values: vec![sqlparser::ast::Expr::BinaryOp {
-                            left: Box::new(sqlparser::ast::Expr::Identifier(Ident::new("@foo"))),
-                            op: sqlparser::ast::BinaryOperator::Plus,
-                            right: Box::new(Expr::Value(number("1").with_empty_span())),
-                        }],
-                    }),
-                    Statement::Return(ReturnStatement {
-                        value: Some(ReturnStatementValue::Expr(Expr::Identifier(Ident::new(
-                            "@foo"
-                        )))),
-                    }),
-                ],
-                end_token: AttachedToken::empty(),
-            })),
-            behavior: None,
-            called_on_null: None,
-            parallel: None,
-            using: None,
-            language: None,
-            determinism_specifier: None,
-            options: None,
-            remote_connection: None,
-        }),
-    );
+    let _ = ms().verified_stmt(create_or_alter_function);
 }
 
 #[test]