Add SET configuration_parameter parsing for PostgreSQL functions.

Author: fmguerreiro

src/parser/mod.rs

@@ -5260,6 +5260,7 @@ impl<'a> Parser<'a> {
             function_body: Option<CreateFunctionBody>,
             called_on_null: Option<FunctionCalledOnNull>,
             parallel: Option<FunctionParallel>,
+            options: Vec<SqlOption>,
         }
         let mut body = Body::default();
         loop {
@@ -5326,6 +5327,18 @@ impl<'a> Parser<'a> {
                 } else {
                     return self.expected("one of UNSAFE | RESTRICTED | SAFE", self.peek_token());
                 }
+            } else if self.parse_keyword(Keyword::SET) {
+                let name = self.parse_identifier()?;
+                self.expect_token(&Token::Eq)?;
+                let first_value = self.parse_expr()?;
+                let value = if self.consume_token(&Token::Comma) {
+                    let mut values = vec![first_value];
+                    values.extend(self.parse_comma_separated(Parser::parse_expr)?);
+                    Expr::Tuple(values)
+                } else {
+                    first_value
+                };
+                body.options.push(SqlOption::KeyValue { key: name, value });
             } else if self.parse_keyword(Keyword::RETURN) {
                 ensure_not_set(&body.function_body, "RETURN")?;
                 body.function_body = Some(CreateFunctionBody::Return(self.parse_expr()?));
@@ -5349,7 +5362,11 @@ impl<'a> Parser<'a> {
             if_not_exists: false,
             using: None,
             determinism_specifier: None,
-            options: None,
+            options: if body.options.is_empty() {
+                None
+            } else {
+                Some(body.options)
+            },
             remote_connection: None,
         }))
     }

tests/sqlparser_postgres.rs

@@ -4586,6 +4586,94 @@ fn parse_create_function_c_with_module_pathname() {
     );
 }
 
+#[test]
+fn parse_create_function_with_set_config() {
+    let sql = r#"CREATE FUNCTION auth.hook(event jsonb)
+RETURNS jsonb
+LANGUAGE plpgsql
+SET search_path = auth, pg_temp, public
+AS $$ BEGIN RETURN event; END; $$"#;
+
+    let statements = pg().parse_sql_statements(sql).unwrap();
+    assert_eq!(statements.len(), 1);
+    match &statements[0] {
+        Statement::CreateFunction(CreateFunction { name, options, .. }) => {
+            assert_eq!(name.to_string(), "auth.hook");
+            let opts = options.as_ref().expect("should have options");
+            assert_eq!(opts.len(), 1, "Should have one SET option");
+
+            // Verify the SET option was captured
+            match &opts[0] {
+                SqlOption::KeyValue { key, value } => {
+                    assert_eq!(key.to_string(), "search_path");
+                    // Value should be a comma-separated list of identifiers
+                    match value {
+                        Expr::Tuple(tuple) => {
+                            assert_eq!(tuple.len(), 3);
+                            // Verify tuple contains expected identifiers
+                            for (i, expected) in ["auth", "pg_temp", "public"].iter().enumerate() {
+                                match &tuple[i] {
+                                    Expr::Identifier(ident) => {
+                                        assert_eq!(ident.to_string(), *expected);
+                                    }
+                                    _ => panic!("Expected identifier in tuple position {}", i),
+                                }
+                            }
+                        }
+                        _ => panic!("Expected Tuple expression for comma-separated values, got: {:?}", value),
+                    }
+                }
+                _ => panic!("Expected KeyValue option"),
+            }
+        }
+        _ => panic!("Expected CreateFunction"),
+    }
+
+    // Test with quoted string value
+    let sql2 = r#"CREATE FUNCTION test_func() RETURNS void LANGUAGE plpgsql SET work_mem = '64MB' AS $$ BEGIN END; $$"#;
+    let statements2 = pg().parse_sql_statements(sql2).unwrap();
+    match &statements2[0] {
+        Statement::CreateFunction(CreateFunction { options, .. }) => {
+            let opts = options.as_ref().expect("should have options");
+            match &opts[0] {
+                SqlOption::KeyValue { key, value } => {
+                    assert_eq!(key.to_string(), "work_mem");
+                    match value {
+                        Expr::Value(ValueWithSpan { value: Value::SingleQuotedString(s), .. }) => {
+                            assert_eq!(s, "64MB");
+                        }
+                        _ => panic!("Expected SingleQuotedString, got: {:?}", value),
+                    }
+                }
+                _ => panic!("Expected KeyValue option"),
+            }
+        }
+        _ => panic!("Expected CreateFunction"),
+    }
+
+    // Test with boolean value
+    let sql3 = r#"CREATE FUNCTION test_func2() RETURNS void LANGUAGE plpgsql SET enable_seqscan = false AS $$ BEGIN END; $$"#;
+    let statements3 = pg().parse_sql_statements(sql3).unwrap();
+    match &statements3[0] {
+        Statement::CreateFunction(CreateFunction { options, .. }) => {
+            let opts = options.as_ref().expect("should have options");
+            match &opts[0] {
+                SqlOption::KeyValue { key, value } => {
+                    assert_eq!(key.to_string(), "enable_seqscan");
+                    match value {
+                        Expr::Value(ValueWithSpan { value: Value::Boolean(b), .. }) => {
+                            assert_eq!(*b, false);
+                        }
+                        _ => panic!("Expected Boolean, got: {:?}", value),
+                    }
+                }
+                _ => panic!("Expected KeyValue option"),
+            }
+        }
+        _ => panic!("Expected CreateFunction"),
+    }
+}
+
 #[test]
 fn parse_drop_function() {
     let sql = "DROP FUNCTION IF EXISTS test_func";