Cleanup CREATE FUNCTION tests (apache#1203)

Author: alamb

tests/sqlparser_postgres.rs

@@ -804,9 +804,7 @@ Kwara & Kogi
 PHP	₱ USD $
 \N  Some other value
 \\."#;
-    let ast = pg_and_generic().one_statement_parses_to(sql, "");
-    println!("{ast:#?}");
-    //assert_eq!(sql, ast.to_string());
+    pg_and_generic().one_statement_parses_to(sql, "");
 }
 
 #[test]
@@ -3304,98 +3302,16 @@ fn parse_create_function() {
             },
         }
     );
-
-    let sql = "CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT PARALLEL RESTRICTED RETURN a + b";
-    assert_eq!(
-        pg_and_generic().verified_stmt(sql),
-        Statement::CreateFunction {
-            or_replace: true,
-            temporary: false,
-            name: ObjectName(vec![Ident::new("add")]),
-            args: Some(vec![
-                OperateFunctionArg::with_name("a", DataType::Integer(None)),
-                OperateFunctionArg {
-                    mode: Some(ArgMode::In),
-                    name: Some("b".into()),
-                    data_type: DataType::Integer(None),
-                    default_expr: Some(Expr::Value(Value::Number("1".parse().unwrap(), false))),
-                }
-            ]),
-            return_type: Some(DataType::Integer(None)),
-            params: CreateFunctionBody {
-                language: Some("SQL".into()),
-                behavior: Some(FunctionBehavior::Immutable),
-                called_on_null: Some(FunctionCalledOnNull::ReturnsNullOnNullInput),
-                parallel: Some(FunctionParallel::Restricted),
-                return_: Some(Expr::BinaryOp {
-                    left: Box::new(Expr::Identifier("a".into())),
-                    op: BinaryOperator::Plus,
-                    right: Box::new(Expr::Identifier("b".into())),
-                }),
-                ..Default::default()
-            },
-        }
-    );
-
-    let sql = "CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL STABLE CALLED ON NULL INPUT PARALLEL UNSAFE RETURN a + b";
-    assert_eq!(
-        pg_and_generic().verified_stmt(sql),
-        Statement::CreateFunction {
-            or_replace: true,
-            temporary: false,
-            name: ObjectName(vec![Ident::new("add")]),
-            args: Some(vec![
-                OperateFunctionArg::with_name("a", DataType::Integer(None)),
-                OperateFunctionArg {
-                    mode: Some(ArgMode::In),
-                    name: Some("b".into()),
-                    data_type: DataType::Integer(None),
-                    default_expr: Some(Expr::Value(Value::Number("1".parse().unwrap(), false))),
-                }
-            ]),
-            return_type: Some(DataType::Integer(None)),
-            params: CreateFunctionBody {
-                language: Some("SQL".into()),
-                behavior: Some(FunctionBehavior::Stable),
-                called_on_null: Some(FunctionCalledOnNull::CalledOnNullInput),
-                parallel: Some(FunctionParallel::Unsafe),
-                return_: Some(Expr::BinaryOp {
-                    left: Box::new(Expr::Identifier("a".into())),
-                    op: BinaryOperator::Plus,
-                    right: Box::new(Expr::Identifier("b".into())),
-                }),
-                ..Default::default()
-            },
-        }
-    );
-
-    let sql = r#"CREATE OR REPLACE FUNCTION increment(i INTEGER) RETURNS INTEGER LANGUAGE plpgsql AS $$ BEGIN RETURN i + 1; END; $$"#;
-    assert_eq!(
-        pg().verified_stmt(sql),
-        Statement::CreateFunction {
-            or_replace: true,
-            temporary: false,
-            name: ObjectName(vec![Ident::new("increment")]),
-            args: Some(vec![OperateFunctionArg::with_name(
-                "i",
-                DataType::Integer(None)
-            )]),
-            return_type: Some(DataType::Integer(None)),
-            params: CreateFunctionBody {
-                language: Some("plpgsql".into()),
-                behavior: None,
-                called_on_null: None,
-                parallel: None,
-                return_: None,
-                as_: Some(FunctionDefinition::DoubleDollarDef(
-                    " BEGIN RETURN i + 1; END; ".into()
-                )),
-                using: None
-            },
-        }
-    );
 }
 
+#[test]
+fn parse_create_function_detailed() {
+    pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL IMMUTABLE PARALLEL RESTRICTED RETURN a + b");
+    pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT PARALLEL RESTRICTED RETURN a + b");
+    pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL STABLE PARALLEL UNSAFE RETURN a + b");
+    pg_and_generic().verified_stmt("CREATE OR REPLACE FUNCTION add(a INTEGER, IN b INTEGER = 1) RETURNS INTEGER LANGUAGE SQL STABLE CALLED ON NULL INPUT PARALLEL UNSAFE RETURN a + b");
+    pg_and_generic().verified_stmt(r#"CREATE OR REPLACE FUNCTION increment(i INTEGER) RETURNS INTEGER LANGUAGE plpgsql AS $$ BEGIN RETURN i + 1; END; $$"#);
+}
 #[test]
 fn parse_incorrect_create_function_parallel() {
     let sql = "CREATE FUNCTION add(INTEGER, INTEGER) RETURNS INTEGER LANGUAGE SQL PARALLEL BLAH AS 'select $1 + $2;'";