Relax text search parser validation

Author: LucaCappelletti94

src/ast/ddl.rs

@@ -5223,7 +5223,7 @@ impl Spanned for AlterOperatorClass {
 }
 
 /// PostgreSQL text search object kind.
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum TextSearchObjectType {
@@ -5235,6 +5235,8 @@ pub enum TextSearchObjectType {
     Template,
     /// `PARSER`
     Parser,
+    /// Preserves custom or quoted object kinds for downstream validation.
+    Custom(Ident),
 }
 
 impl fmt::Display for TextSearchObjectType {
@@ -5244,6 +5246,7 @@ impl fmt::Display for TextSearchObjectType {
             TextSearchObjectType::Configuration => write!(f, "CONFIGURATION"),
             TextSearchObjectType::Template => write!(f, "TEMPLATE"),
             TextSearchObjectType::Parser => write!(f, "PARSER"),
+            TextSearchObjectType::Custom(name) => write!(f, "{name}"),
         }
     }
 }
@@ -5279,18 +5282,18 @@ impl Spanned for CreateTextSearch {
     }
 }
 
-/// Option assignment used by `ALTER TEXT SEARCH DICTIONARY ... ( ... )`.
+/// Option assignment used by `ALTER TEXT SEARCH ... ( ... )`.
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct AlterTextSearchDictionaryOption {
+pub struct AlterTextSearchOption {
     /// Option name.
     pub key: Ident,
     /// Optional value (`option [= value]`).
     pub value: Option<Expr>,
 }
 
-impl fmt::Display for AlterTextSearchDictionaryOption {
+impl fmt::Display for AlterTextSearchOption {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self.value {
             Some(value) => write!(f, "{} = {}", self.key, value),
@@ -5318,8 +5321,8 @@ pub enum AlterTextSearchOperation {
     },
     /// `( option [= value] [, ...] )`
     SetOptions {
-        /// Dictionary options to apply.
-        options: Vec<AlterTextSearchDictionaryOption>,
+        /// Options to apply.
+        options: Vec<AlterTextSearchOption>,
     },
 }
 

src/ast/mod.rs

@@ -64,8 +64,8 @@ pub use self::ddl::{
     AlterOperatorClass, AlterOperatorClassOperation, AlterOperatorFamily,
     AlterOperatorFamilyOperation, AlterOperatorOperation, AlterPolicy, AlterPolicyOperation,
     AlterSchema, AlterSchemaOperation, AlterTable, AlterTableAlgorithm, AlterTableLock,
-    AlterTableOperation, AlterTableType, AlterTextSearch, AlterTextSearchDictionaryOption,
-    AlterTextSearchOperation, AlterType, AlterTypeAddValue, AlterTypeAddValuePosition,
+    AlterTableOperation, AlterTableType, AlterTextSearch, AlterTextSearchOperation,
+    AlterTextSearchOption, AlterType, AlterTypeAddValue, AlterTypeAddValuePosition,
     AlterTypeOperation, AlterTypeRename, AlterTypeRenameValue, ClusteredBy, ColumnDef,
     ColumnOption, ColumnOptionDef, ColumnOptions, ColumnPolicy, ColumnPolicyProperty,
     ConstraintCharacteristics, CreateConnector, CreateDomain, CreateExtension, CreateFunction,

src/parser/mod.rs

@@ -5189,131 +5189,74 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_text_search_object_type(&mut self) -> Result<TextSearchObjectType, ParserError> {
-        match self.expect_one_of_keywords(&[
-            Keyword::DICTIONARY,
-            Keyword::CONFIGURATION,
-            Keyword::TEMPLATE,
-            Keyword::PARSER,
-        ])? {
-            Keyword::DICTIONARY => Ok(TextSearchObjectType::Dictionary),
-            Keyword::CONFIGURATION => Ok(TextSearchObjectType::Configuration),
-            Keyword::TEMPLATE => Ok(TextSearchObjectType::Template),
-            Keyword::PARSER => Ok(TextSearchObjectType::Parser),
-            // unreachable because expect_one_of_keywords used above
-            unexpected_keyword => Err(ParserError::ParserError(format!(
-                "Internal parser error: expected any of {{DICTIONARY, CONFIGURATION, TEMPLATE, PARSER}}, got {unexpected_keyword:?}"
-            ))),
-        }
+        Ok(if self.parse_keyword(Keyword::DICTIONARY) {
+            TextSearchObjectType::Dictionary
+        } else if self.parse_keyword(Keyword::CONFIGURATION) {
+            TextSearchObjectType::Configuration
+        } else if self.parse_keyword(Keyword::TEMPLATE) {
+            TextSearchObjectType::Template
+        } else if self.parse_keyword(Keyword::PARSER) {
+            TextSearchObjectType::Parser
+        } else {
+            TextSearchObjectType::Custom(self.parse_identifier()?)
+        })
     }
 
     /// Parse a PostgreSQL `CREATE TEXT SEARCH ...` statement.
     pub fn parse_create_text_search(&mut self) -> Result<CreateTextSearch, ParserError> {
         self.expect_keywords(&[Keyword::TEXT, Keyword::SEARCH])?;
         let object_type = self.parse_text_search_object_type()?;
         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)?;
+        let options = self
+            .parse_parenthesized(|parser| parser.parse_comma_separated(Parser::parse_sql_option))?;
         Ok(CreateTextSearch {
             object_type,
             name,
             options,
         })
     }
 
-    fn parse_alter_text_search_dictionary_option(
-        &mut self,
-    ) -> Result<AlterTextSearchDictionaryOption, ParserError> {
+    fn parse_alter_text_search_option(&mut self) -> Result<AlterTextSearchOption, ParserError> {
         let key = self.parse_identifier()?;
         let value = if self.consume_token(&Token::Eq) {
             Some(self.parse_expr()?)
         } else {
             None
         };
-        Ok(AlterTextSearchDictionaryOption { key, value })
+        Ok(AlterTextSearchOption { key, value })
+    }
+
+    fn parse_alter_text_search_operation(
+        &mut self,
+    ) -> Result<AlterTextSearchOperation, ParserError> {
+        if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
+            Ok(AlterTextSearchOperation::RenameTo {
+                new_name: self.parse_identifier()?,
+            })
+        } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
+            Ok(AlterTextSearchOperation::OwnerTo(self.parse_owner()?))
+        } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) {
+            Ok(AlterTextSearchOperation::SetSchema {
+                schema_name: self.parse_object_name(false)?,
+            })
+        } else if self.consume_token(&Token::LParen) {
+            let options = self.parse_comma_separated(Parser::parse_alter_text_search_option)?;
+            self.expect_token(&Token::RParen)?;
+            Ok(AlterTextSearchOperation::SetOptions { options })
+        } else {
+            self.expected_ref(
+                "RENAME TO, OWNER TO, SET SCHEMA, or (...)",
+                self.peek_token_ref(),
+            )
+        }
     }
 
     /// Parse a PostgreSQL `ALTER TEXT SEARCH ...` statement.
     pub fn parse_alter_text_search(&mut self) -> Result<AlterTextSearch, ParserError> {
         self.expect_keywords(&[Keyword::TEXT, Keyword::SEARCH])?;
         let object_type = self.parse_text_search_object_type()?;
         let name = self.parse_object_name(false)?;
-
-        let operation = match object_type {
-            TextSearchObjectType::Dictionary => {
-                if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
-                    AlterTextSearchOperation::RenameTo {
-                        new_name: self.parse_identifier()?,
-                    }
-                } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
-                    AlterTextSearchOperation::OwnerTo(self.parse_owner()?)
-                } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) {
-                    AlterTextSearchOperation::SetSchema {
-                        schema_name: self.parse_object_name(false)?,
-                    }
-                } else if self.consume_token(&Token::LParen) {
-                    let options = self
-                        .parse_comma_separated(Parser::parse_alter_text_search_dictionary_option)?;
-                    self.expect_token(&Token::RParen)?;
-                    AlterTextSearchOperation::SetOptions { options }
-                } else {
-                    return self.expected_ref(
-                        "RENAME TO, OWNER TO, SET SCHEMA, or (...) after ALTER TEXT SEARCH DICTIONARY",
-                        self.peek_token_ref(),
-                    );
-                }
-            }
-            TextSearchObjectType::Configuration => {
-                if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
-                    AlterTextSearchOperation::RenameTo {
-                        new_name: self.parse_identifier()?,
-                    }
-                } else if self.parse_keywords(&[Keyword::OWNER, Keyword::TO]) {
-                    AlterTextSearchOperation::OwnerTo(self.parse_owner()?)
-                } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) {
-                    AlterTextSearchOperation::SetSchema {
-                        schema_name: self.parse_object_name(false)?,
-                    }
-                } else {
-                    return self.expected_ref(
-                        "RENAME TO, OWNER TO, or SET SCHEMA after ALTER TEXT SEARCH CONFIGURATION",
-                        self.peek_token_ref(),
-                    );
-                }
-            }
-            TextSearchObjectType::Template => {
-                if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
-                    AlterTextSearchOperation::RenameTo {
-                        new_name: self.parse_identifier()?,
-                    }
-                } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) {
-                    AlterTextSearchOperation::SetSchema {
-                        schema_name: self.parse_object_name(false)?,
-                    }
-                } else {
-                    return self.expected_ref(
-                        "RENAME TO or SET SCHEMA after ALTER TEXT SEARCH TEMPLATE",
-                        self.peek_token_ref(),
-                    );
-                }
-            }
-            TextSearchObjectType::Parser => {
-                if self.parse_keywords(&[Keyword::RENAME, Keyword::TO]) {
-                    AlterTextSearchOperation::RenameTo {
-                        new_name: self.parse_identifier()?,
-                    }
-                } else if self.parse_keywords(&[Keyword::SET, Keyword::SCHEMA]) {
-                    AlterTextSearchOperation::SetSchema {
-                        schema_name: self.parse_object_name(false)?,
-                    }
-                } else {
-                    return self.expected_ref(
-                        "RENAME TO or SET SCHEMA after ALTER TEXT SEARCH PARSER",
-                        self.peek_token_ref(),
-                    );
-                }
-            }
-        };
+        let operation = self.parse_alter_text_search_operation()?;
 
         Ok(AlterTextSearch {
             object_type,

tests/sqlparser_postgres.rs

@@ -8062,28 +8062,22 @@ fn parse_alter_operator_class() {
 
 #[test]
 fn parse_create_and_alter_text_search() {
-    // CREATE — one per object type
-    pg_and_generic().verified_stmt("CREATE TEXT SEARCH DICTIONARY d (template = simple)");
-    pg_and_generic().verified_stmt("CREATE TEXT SEARCH CONFIGURATION c (copy = english)");
-    pg_and_generic().verified_stmt("CREATE TEXT SEARCH TEMPLATE t (lexize = dsimple_lexize)");
-    pg_and_generic().verified_stmt(
+    for sql in [
+        "CREATE TEXT SEARCH DICTIONARY d (template = simple)",
+        "CREATE TEXT SEARCH CONFIGURATION c (copy = english)",
+        "CREATE TEXT SEARCH TEMPLATE t (lexize = dsimple_lexize)",
         "CREATE TEXT SEARCH PARSER p (start = prsd_start, gettoken = prsd_nexttoken, end = prsd_end, lextypes = prsd_lextype)",
-    );
-
-    // CREATE with quoted option key
-    pg_and_generic().verified_stmt("CREATE TEXT SEARCH TEMPLATE t (\"Init\" = init_function)");
-
-    // ALTER — one test per object type arm, one per operation kind
-    pg_and_generic().verified_stmt("ALTER TEXT SEARCH DICTIONARY d (opt = val)");
-    pg_and_generic().verified_stmt("ALTER TEXT SEARCH DICTIONARY d (opt)");
-    pg_and_generic().verified_stmt("ALTER TEXT SEARCH CONFIGURATION c OWNER TO some_user");
-    pg_and_generic().verified_stmt("ALTER TEXT SEARCH TEMPLATE t SET SCHEMA s");
-    pg_and_generic().verified_stmt("ALTER TEXT SEARCH PARSER p RENAME TO p2");
-
-    // Object type must be an unquoted keyword-like token in this position.
-    assert!(pg()
-        .parse_sql_statements("CREATE TEXT SEARCH \"DICTIONARY\" d (template = simple)")
-        .is_err());
+        "CREATE TEXT SEARCH \"DICTIONARY\" d (template = simple)",
+        "CREATE TEXT SEARCH TEMPLATE t (\"Init\" = init_function)",
+        "ALTER TEXT SEARCH DICTIONARY d (opt = val)",
+        "ALTER TEXT SEARCH DICTIONARY d (opt)",
+        "ALTER TEXT SEARCH CONFIGURATION c OWNER TO some_user",
+        "ALTER TEXT SEARCH TEMPLATE t SET SCHEMA s",
+        "ALTER TEXT SEARCH PARSER p RENAME TO p2",
+        "ALTER TEXT SEARCH TEMPLATE t OWNER TO some_user",
+    ] {
+        pg_and_generic().verified_stmt(sql);
+    }
 
     // CREATE options are key-value pairs in PostgreSQL syntax.
     assert!(pg()