add support for xml namespaces

Author: lovasoa

src/ast/mod.rs

@@ -81,8 +81,8 @@ pub use self::query::{
     TableSampleBucket, TableSampleKind, TableSampleMethod, TableSampleModifier,
     TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier, TableSampleUnit, TableVersion,
     TableWithJoins, Top, TopQuantity, UpdateTableFromKind, ValueTableMode, Values,
-    WildcardAdditionalOptions, With, WithFill, XmlPassingArgument, XmlPassingClause,
-    XmlTableColumn, XmlTableColumnOption,
+    WildcardAdditionalOptions, With, WithFill, XmlNamespaceDefinition, XmlPassingArgument,
+    XmlPassingClause, XmlTableColumn, XmlTableColumnOption,
 };
 
 pub use self::trigger::{

src/ast/query.rs

@@ -1291,7 +1291,8 @@ pub enum TableFactor {
     /// );
     /// ````
     XmlTable {
-        // TODO: Add XMLNAMESPACES clause support
+        /// Optional XMLNAMESPACES clause (empty if not present)
+        namespaces: Vec<XmlNamespaceDefinition>,
         /// The row-generating XPath expression.
         row_expression: Expr,
         /// The PASSING clause specifying the document expression.
@@ -1971,10 +1972,19 @@ impl fmt::Display for TableFactor {
                 passing,
                 columns,
                 alias,
+                namespaces,
             } => {
+                write!(f, "XMLTABLE(")?;
+                if !namespaces.is_empty() {
+                    write!(
+                        f,
+                        "XMLNAMESPACES({}), ",
+                        display_comma_separated(namespaces)
+                    )?;
+                }
                 write!(
                     f,
-                    "XMLTABLE({row_expression}{passing} COLUMNS {columns})",
+                    "{row_expression}{passing} COLUMNS {columns})",
                     columns = display_comma_separated(columns)
                 )?;
                 if let Some(alias) = alias {
@@ -3239,3 +3249,22 @@ impl fmt::Display for XmlPassingClause {
         Ok(())
     }
 }
+
+/// Represents a single XML namespace definition in the XMLNAMESPACES clause.
+///
+/// `namespace_uri AS namespace_name`
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct XmlNamespaceDefinition {
+    /// The namespace URI (a text expression).
+    pub uri: Expr,
+    /// The alias for the namespace (a simple identifier).
+    pub name: Ident,
+}
+
+impl fmt::Display for XmlNamespaceDefinition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} AS {}", self.uri, self.name)
+    }
+}

src/keywords.rs

@@ -990,6 +990,7 @@ define_keywords!(
     WORK,
     WRITE,
     XML,
+    XMLNAMESPACES,
     XMLTABLE,
     XOR,
     YEAR,

src/parser/mod.rs

@@ -12345,20 +12345,37 @@ impl<'a> Parser<'a> {
 
     fn parse_xml_table_factor(&mut self) -> Result<TableFactor, ParserError> {
         self.expect_token(&Token::LParen)?;
+        let namespaces = if self.parse_keyword(Keyword::XMLNAMESPACES) {
+            self.expect_token(&Token::LParen)?;
+            let namespaces = self.parse_comma_separated(Parser::parse_xml_namespace_definition)?;
+            self.expect_token(&Token::RParen)?;
+            self.expect_token(&Token::Comma)?;
+            namespaces
+        } else {
+            vec![]
+        };
         let row_expression = self.parse_expr()?;
         let passing = self.parse_xml_passing_clause()?;
         self.expect_keyword_is(Keyword::COLUMNS)?;
         let columns = self.parse_comma_separated(Parser::parse_xml_table_column)?;
         self.expect_token(&Token::RParen)?;
         let alias = self.maybe_parse_table_alias()?;
         Ok(TableFactor::XmlTable {
+            namespaces,
             row_expression,
             passing,
             columns,
             alias,
         })
     }
 
+    fn parse_xml_namespace_definition(&mut self) -> Result<XmlNamespaceDefinition, ParserError> {
+        let uri = self.parse_expr()?;
+        self.expect_keyword_is(Keyword::AS)?;
+        let name = self.parse_identifier()?;
+        Ok(XmlNamespaceDefinition { uri, name })
+    }
+
     fn parse_xml_table_column(&mut self) -> Result<XmlTableColumn, ParserError> {
         let name = self.parse_identifier()?;
 

tests/sqlparser_common.rs

@@ -11760,6 +11760,11 @@ fn test_xmltable() {
     all_dialects().verified_only_select(
         "SELECT X.* FROM T1, XMLTABLE('$CUSTLIST/customers/customerinfo' COLUMNS \"Cid\" BIGINT PATH '@Cid', \"Info\" XML PATH 'document{.}', \"History\" XML PATH 'NULL') AS X"
     );
+
+    // Example from PostgreSQL with XMLNAMESPACES
+    all_dialects().verified_only_select(
+        "SELECT xmltable.* FROM XMLTABLE(XMLNAMESPACES('http://example.com/myns' AS x, 'http://example.com/b' AS \"B\"), '/x:example/x:item' PASSING (SELECT data FROM xmldata) COLUMNS foo INT PATH '@foo', bar INT PATH '@B:bar')"
+    );
 }
 
 #[test]