Merge remote-tracking branch 'origin/main' into feat/foreign-table-fdw

# Conflicts:
#	src/ast/ddl.rs
#	src/ast/mod.rs
#	src/parser/mod.rs

Author: fmguerreiro

src/ast/ddl.rs

@@ -5859,3 +5859,126 @@ impl From<CreateForeignTable> for crate::ast::Statement {
         crate::ast::Statement::CreateForeignTable(v)
     }
 }
+/// `CREATE TEXT SEARCH CONFIGURATION` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createtsconfig.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTextSearchConfiguration {
+    /// Name of the text search configuration being created.
+    pub name: ObjectName,
+    /// Options list — must include `PARSER = parser_name`.
+    pub options: Vec<SqlOption>,
+}
+
+impl fmt::Display for CreateTextSearchConfiguration {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE TEXT SEARCH CONFIGURATION {name} ({options})",
+            name = self.name,
+            options = display_comma_separated(&self.options),
+        )
+    }
+}
+
+impl From<CreateTextSearchConfiguration> for crate::ast::Statement {
+    fn from(v: CreateTextSearchConfiguration) -> Self {
+        crate::ast::Statement::CreateTextSearchConfiguration(v)
+    }
+}
+
+/// `CREATE TEXT SEARCH DICTIONARY` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createtsdictionary.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTextSearchDictionary {
+    /// Name of the text search dictionary being created.
+    pub name: ObjectName,
+    /// Options list — must include `TEMPLATE = template_name`.
+    pub options: Vec<SqlOption>,
+}
+
+impl fmt::Display for CreateTextSearchDictionary {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE TEXT SEARCH DICTIONARY {name} ({options})",
+            name = self.name,
+            options = display_comma_separated(&self.options),
+        )
+    }
+}
+
+impl From<CreateTextSearchDictionary> for crate::ast::Statement {
+    fn from(v: CreateTextSearchDictionary) -> Self {
+        crate::ast::Statement::CreateTextSearchDictionary(v)
+    }
+}
+
+/// `CREATE TEXT SEARCH PARSER` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createtsparser.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+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`).
+    pub options: Vec<SqlOption>,
+}
+
+impl fmt::Display for CreateTextSearchParser {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE TEXT SEARCH PARSER {name} ({options})",
+            name = self.name,
+            options = display_comma_separated(&self.options),
+        )
+    }
+}
+
+impl From<CreateTextSearchParser> for crate::ast::Statement {
+    fn from(v: CreateTextSearchParser) -> Self {
+        crate::ast::Statement::CreateTextSearchParser(v)
+    }
+}
+
+/// `CREATE TEXT SEARCH TEMPLATE` statement.
+///
+/// Note: this is a PostgreSQL-specific statement.
+/// <https://www.postgresql.org/docs/current/sql-createtstemplate.html>
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct CreateTextSearchTemplate {
+    /// Name of the text search template being created.
+    pub name: ObjectName,
+    /// Options list — must include `LEXIZE` (and optionally `INIT`).
+    pub options: Vec<SqlOption>,
+}
+
+impl fmt::Display for CreateTextSearchTemplate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "CREATE TEXT SEARCH TEMPLATE {name} ({options})",
+            name = self.name,
+            options = display_comma_separated(&self.options),
+        )
+    }
+}
+
+impl From<CreateTextSearchTemplate> for crate::ast::Statement {
+    fn from(v: CreateTextSearchTemplate) -> Self {
+        crate::ast::Statement::CreateTextSearchTemplate(v)
+    }
+}

src/ast/mod.rs

@@ -71,10 +71,11 @@ pub use self::ddl::{
     ColumnPolicyProperty, ConstraintCharacteristics, CreateCollation, CreateCollationDefinition,
     CreateConnector, CreateDomain, CreateExtension, CreateForeignDataWrapper, CreateForeignTable,
     CreateFunction, CreateIndex, CreateOperator, CreateOperatorClass, CreateOperatorFamily,
-    CreatePolicy, CreatePolicyCommand, CreatePolicyType, CreateTable, CreateTrigger, CreateView,
-    Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension, DropFunction,
-    DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature, DropPolicy,
-    DropTrigger, FdwRoutineClause, ForValues, FunctionReturnType, GeneratedAs,
+    CreatePolicy, CreatePolicyCommand, CreatePolicyType, CreateTable, CreateTextSearchConfiguration,
+    CreateTextSearchDictionary, CreateTextSearchParser, CreateTextSearchTemplate, CreateTrigger,
+    CreateView, Deduplicate, DeferrableInitial, DistStyle, DropBehavior, DropExtension,
+    DropFunction, DropOperator, DropOperatorClass, DropOperatorFamily, DropOperatorSignature,
+    DropPolicy, DropTrigger, FdwRoutineClause, ForValues, FunctionReturnType, GeneratedAs,
     GeneratedExpressionMode, IdentityParameters, IdentityProperty, IdentityPropertyFormatKind,
     IdentityPropertyKind, IdentityPropertyOrder, IndexColumn, IndexOption, IndexType,
     KeyOrIndexDisplay, Msck, NullsDistinctOption, OperatorArgTypes, OperatorClassItem,
@@ -3986,6 +3987,30 @@ pub enum Statement {
     /// <https://www.postgresql.org/docs/current/sql-createcollation.html>
     CreateCollation(CreateCollation),
     /// ```sql
+    /// CREATE TEXT SEARCH CONFIGURATION name ( PARSER = parser_name )
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createtsconfig.html>
+    CreateTextSearchConfiguration(CreateTextSearchConfiguration),
+    /// ```sql
+    /// CREATE TEXT SEARCH DICTIONARY name ( TEMPLATE = template_name [, option = value, ...] )
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createtsdictionary.html>
+    CreateTextSearchDictionary(CreateTextSearchDictionary),
+    /// ```sql
+    /// CREATE TEXT SEARCH PARSER name ( START = start_fn, GETTOKEN = gettoken_fn, END = end_fn, LEXTYPES = lextypes_fn [, HEADLINE = headline_fn] )
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createtsparser.html>
+    CreateTextSearchParser(CreateTextSearchParser),
+    /// ```sql
+    /// CREATE TEXT SEARCH TEMPLATE name ( [INIT = init_fn,] LEXIZE = lexize_fn )
+    /// ```
+    /// Note: this is a PostgreSQL-specific statement.
+    /// <https://www.postgresql.org/docs/current/sql-createtstemplate.html>
+    CreateTextSearchTemplate(CreateTextSearchTemplate),
+    /// ```sql
     /// DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
     /// ```
     /// Note: this is a PostgreSQL-specific statement.
@@ -5468,6 +5493,10 @@ impl fmt::Display for Statement {
             Statement::CreateIndex(create_index) => create_index.fmt(f),
             Statement::CreateExtension(create_extension) => write!(f, "{create_extension}"),
             Statement::CreateCollation(create_collation) => write!(f, "{create_collation}"),
+            Statement::CreateTextSearchConfiguration(v) => write!(f, "{v}"),
+            Statement::CreateTextSearchDictionary(v) => write!(f, "{v}"),
+            Statement::CreateTextSearchParser(v) => write!(f, "{v}"),
+            Statement::CreateTextSearchTemplate(v) => write!(f, "{v}"),
             Statement::DropExtension(drop_extension) => write!(f, "{drop_extension}"),
             Statement::DropOperator(drop_operator) => write!(f, "{drop_operator}"),
             Statement::DropOperatorFamily(drop_operator_family) => {

src/ast/spans.rs

@@ -265,6 +265,10 @@ impl Spanned for Values {
 /// - [Statement::Declare]
 /// - [Statement::CreateExtension]
 /// - [Statement::CreateCollation]
+/// - [Statement::CreateTextSearchConfiguration]
+/// - [Statement::CreateTextSearchDictionary]
+/// - [Statement::CreateTextSearchParser]
+/// - [Statement::CreateTextSearchTemplate]
 /// - [Statement::AlterCollation]
 /// - [Statement::Fetch]
 /// - [Statement::Flush]
@@ -380,6 +384,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::DropExtension(drop_extension) => drop_extension.span(),
             Statement::DropOperator(drop_operator) => drop_operator.span(),
             Statement::DropOperatorFamily(drop_operator_family) => drop_operator_family.span(),

src/keywords.rs

@@ -244,6 +244,7 @@ define_keywords!(
     COMPRESSION,
     COMPUPDATE,
     COMPUTE,
+    CONFIGURATION,
     CONCURRENTLY,
     CONDITION,
     CONFLICT,
@@ -333,6 +334,7 @@ define_keywords!(
     DETACH,
     DETAIL,
     DETERMINISTIC,
+    DICTIONARY,
     DIMENSIONS,
     DIRECTORY,
     DISABLE,
@@ -766,6 +768,7 @@ define_keywords!(
     PARALLEL,
     PARAMETER,
     PARQUET,
+    PARSER,
     PART,
     PARTIAL,
     PARTITION,
@@ -1036,6 +1039,7 @@ define_keywords!(
     TASK,
     TBLPROPERTIES,
     TEMP,
+    TEMPLATE,
     TEMPORARY,
     TEMPTABLE,
     TERMINATED,

src/parser/mod.rs

@@ -5224,6 +5224,8 @@ impl<'a> Parser<'a> {
                     self.peek_token_ref(),
                 )
             }
+        } else if self.parse_keywords(&[Keyword::TEXT, Keyword::SEARCH]) {
+            self.parse_create_text_search()
         } else {
             self.expected_ref("an object type after CREATE", self.peek_token_ref())
         }
@@ -8188,6 +8190,49 @@ 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 },
+            ))
+        } 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 },
+            ))
+        } 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,
+            }))
+        } 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 },
+            ))
+        } else {
+            self.expected_ref(
+                "CONFIGURATION, DICTIONARY, PARSER, or TEMPLATE after CREATE TEXT SEARCH",
+                self.peek_token_ref(),
+            )
+        }
+    }
+
     /// Parse a PostgreSQL-specific [Statement::DropExtension] statement.
     pub fn parse_drop_extension(&mut self) -> Result<Statement, ParserError> {
         let if_exists = self.parse_keywords(&[Keyword::IF, Keyword::EXISTS]);