review: collapse duplicate parse arms, real spans, honest doc comments

- Collapse the four near-identical parse arms in
  parse_create_text_search; parse the subtype keyword once, then
  parse name and options once, then map the subtype to the
  Statement variant.
- Spanned impls now return the name's span instead of Span::empty(),
  matching sibling Create* statements.
- Doc comments on each `options: Vec<SqlOption>` no longer claim
  the parser enforces required keys; they note PostgreSQL's
  requirements and clarify that enforcement is left to the engine.
- Add a test exercising schema-qualified option values
  (e.g. PARSER = pg_catalog.default) to guard the round-trip.

Author: fmguerreiro

src/ast/ddl.rs

@@ -5768,7 +5768,9 @@ impl From<AlterPolicy> for crate::ast::Statement {
 pub struct CreateTextSearchConfiguration {
     /// Name of the text search configuration being created.
     pub name: ObjectName,
-    /// Options list — must include `PARSER = parser_name`.
+    /// Options list. PostgreSQL requires `PARSER = parser_name`; the
+    /// parser does not enforce required keys (matching other options-list
+    /// handling in this crate).
     pub options: Vec<SqlOption>,
 }
 
@@ -5799,7 +5801,8 @@ impl From<CreateTextSearchConfiguration> for crate::ast::Statement {
 pub struct CreateTextSearchDictionary {
     /// Name of the text search dictionary being created.
     pub name: ObjectName,
-    /// Options list — must include `TEMPLATE = template_name`.
+    /// Options list. PostgreSQL requires `TEMPLATE = template_name`; the
+    /// parser does not enforce required keys.
     pub options: Vec<SqlOption>,
 }
 
@@ -5830,7 +5833,9 @@ impl From<CreateTextSearchDictionary> for crate::ast::Statement {
 pub struct CreateTextSearchParser {
     /// Name of the text search parser being created.
     pub name: ObjectName,
-    /// Options list — must include `START`, `GETTOKEN`, `END`, `LEXTYPES` (and optionally `HEADLINE`).
+    /// Options list. PostgreSQL requires `START`, `GETTOKEN`, `END`, and
+    /// `LEXTYPES` (with `HEADLINE` optional); the parser does not enforce
+    /// required keys.
     pub options: Vec<SqlOption>,
 }
 
@@ -5861,7 +5866,8 @@ impl From<CreateTextSearchParser> for crate::ast::Statement {
 pub struct CreateTextSearchTemplate {
     /// Name of the text search template being created.
     pub name: ObjectName,
-    /// Options list — must include `LEXIZE` (and optionally `INIT`).
+    /// Options list. PostgreSQL requires `LEXIZE` (with `INIT` optional);
+    /// the parser does not enforce required keys.
     pub options: Vec<SqlOption>,
 }
 

src/ast/spans.rs

@@ -391,10 +391,10 @@ impl Spanned for Statement {
             Statement::CreateRole(create_role) => create_role.span(),
             Statement::CreateExtension(create_extension) => create_extension.span(),
             Statement::CreateCollation(create_collation) => create_collation.span(),
-            Statement::CreateTextSearchConfiguration(_) => Span::empty(),
-            Statement::CreateTextSearchDictionary(_) => Span::empty(),
-            Statement::CreateTextSearchParser(_) => Span::empty(),
-            Statement::CreateTextSearchTemplate(_) => Span::empty(),
+            Statement::CreateTextSearchConfiguration(stmt) => stmt.name.span(),
+            Statement::CreateTextSearchDictionary(stmt) => stmt.name.span(),
+            Statement::CreateTextSearchParser(stmt) => stmt.name.span(),
+            Statement::CreateTextSearchTemplate(stmt) => stmt.name.span(),
             Statement::DropExtension(drop_extension) => drop_extension.span(),
             Statement::DropOperator(drop_operator) => drop_operator.span(),
             Statement::DropOperatorFamily(drop_operator_family) => drop_operator_family.span(),

src/parser/mod.rs

@@ -8180,45 +8180,45 @@ impl<'a> Parser<'a> {
 
     /// Parse a PostgreSQL-specific `CREATE TEXT SEARCH CONFIGURATION | DICTIONARY | PARSER | TEMPLATE` statement.
     pub fn parse_create_text_search(&mut self) -> Result<Statement, ParserError> {
-        if self.parse_keyword(Keyword::CONFIGURATION) {
-            let name = self.parse_object_name(false)?;
-            self.expect_token(&Token::LParen)?;
-            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
-            self.expect_token(&Token::RParen)?;
-            Ok(Statement::CreateTextSearchConfiguration(
-                CreateTextSearchConfiguration { name, options },
-            ))
+        let subtype = if self.parse_keyword(Keyword::CONFIGURATION) {
+            Keyword::CONFIGURATION
         } else if self.parse_keyword(Keyword::DICTIONARY) {
-            let name = self.parse_object_name(false)?;
-            self.expect_token(&Token::LParen)?;
-            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
-            self.expect_token(&Token::RParen)?;
-            Ok(Statement::CreateTextSearchDictionary(
-                CreateTextSearchDictionary { name, options },
-            ))
+            Keyword::DICTIONARY
         } else if self.parse_keyword(Keyword::PARSER) {
-            let name = self.parse_object_name(false)?;
-            self.expect_token(&Token::LParen)?;
-            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
-            self.expect_token(&Token::RParen)?;
-            Ok(Statement::CreateTextSearchParser(CreateTextSearchParser {
-                name,
-                options,
-            }))
+            Keyword::PARSER
         } else if self.parse_keyword(Keyword::TEMPLATE) {
-            let name = self.parse_object_name(false)?;
-            self.expect_token(&Token::LParen)?;
-            let options = self.parse_comma_separated(Parser::parse_sql_option)?;
-            self.expect_token(&Token::RParen)?;
-            Ok(Statement::CreateTextSearchTemplate(
-                CreateTextSearchTemplate { name, options },
-            ))
+            Keyword::TEMPLATE
         } else {
-            self.expected_ref(
+            return self.expected_ref(
                 "CONFIGURATION, DICTIONARY, PARSER, or TEMPLATE after CREATE TEXT SEARCH",
                 self.peek_token_ref(),
-            )
-        }
+            );
+        };
+
+        let name = self.parse_object_name(false)?;
+        self.expect_token(&Token::LParen)?;
+        let options = self.parse_comma_separated(Parser::parse_sql_option)?;
+        self.expect_token(&Token::RParen)?;
+
+        Ok(match subtype {
+            Keyword::CONFIGURATION => Statement::CreateTextSearchConfiguration(
+                CreateTextSearchConfiguration { name, options },
+            ),
+            Keyword::DICTIONARY => {
+                Statement::CreateTextSearchDictionary(CreateTextSearchDictionary { name, options })
+            }
+            Keyword::PARSER => {
+                Statement::CreateTextSearchParser(CreateTextSearchParser { name, options })
+            }
+            Keyword::TEMPLATE => {
+                Statement::CreateTextSearchTemplate(CreateTextSearchTemplate { name, options })
+            }
+            unexpected => {
+                return Err(ParserError::ParserError(format!(
+                    "Internal parser error: unexpected CREATE TEXT SEARCH subtype `{unexpected}`"
+                )))
+            }
+        })
     }
 
     /// Parse a PostgreSQL-specific [Statement::DropExtension] statement.

tests/sqlparser_postgres.rs

@@ -1069,6 +1069,16 @@ fn parse_create_text_search_template() {
     );
 }
 
+#[test]
+fn parse_create_text_search_schema_qualified_option_value() {
+    // PostgreSQL's TEXT SEARCH options accept schema-qualified names as
+    // values (e.g. `PARSER = pg_catalog.default`). Ensure they round-trip.
+    pg().verified_stmt(
+        "CREATE TEXT SEARCH CONFIGURATION public.myconfig (PARSER = pg_catalog.default)",
+    );
+    pg().verified_stmt("CREATE TEXT SEARCH DICTIONARY public.d (TEMPLATE = pg_catalog.simple)");
+}
+
 #[test]
 fn parse_create_text_search_invalid_subtype() {
     assert_eq!(