Add support for Snowflake identifier function (apache#1929)

yoavcloud · ayman-sigma · commit 3bc8dc3d2e3d · 2026-02-02T18:39:08.000-08:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -344,12 +344,14 @@ impl fmt::Display for ObjectName {
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
 pub enum ObjectNamePart {
     Identifier(Ident),
+    Function(ObjectNamePartFunction),
 }
 
 impl ObjectNamePart {
     pub fn as_ident(&self) -> Option<&Ident> {
         match self {
             ObjectNamePart::Identifier(ident) => Some(ident),
+            ObjectNamePart::Function(_) => None,
         }
     }
 }
@@ -358,10 +360,30 @@ impl fmt::Display for ObjectNamePart {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             ObjectNamePart::Identifier(ident) => write!(f, "{ident}"),
+            ObjectNamePart::Function(func) => write!(f, "{func}"),
         }
     }
 }
 
+/// An object name part that consists of a function that dynamically
+/// constructs identifiers.
+///
+/// - [Snowflake](https://docs.snowflake.com/en/sql-reference/identifier-literal)
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ObjectNamePartFunction {
+    pub name: Ident,
+    pub args: Vec<FunctionArg>,
+}
+
+impl fmt::Display for ObjectNamePartFunction {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}(", self.name)?;
+        write!(f, "{})", display_comma_separated(&self.args))
+    }
+}
+
 /// Represents an Array Expression, either
 /// `ARRAY[..]`, or `[..]`
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
diff --git a/src/ast/spans.rs b/src/ast/spans.rs
@@ -1676,6 +1676,10 @@ impl Spanned for ObjectNamePart {
     fn span(&self) -> Span {
         match self {
             ObjectNamePart::Identifier(ident) => ident.span,
+            ObjectNamePart::Function(func) => func
+                .name
+                .span
+                .union(&union_spans(func.args.iter().map(|i| i.span()))),
         }
     }
 }
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
@@ -49,7 +49,7 @@ pub use self::postgresql::PostgreSqlDialect;
 pub use self::redshift::RedshiftSqlDialect;
 pub use self::snowflake::SnowflakeDialect;
 pub use self::sqlite::SQLiteDialect;
-use crate::ast::{ColumnOption, Expr, GranteesType, Statement};
+use crate::ast::{ColumnOption, Expr, GranteesType, Ident, ObjectNamePart, Statement};
 pub use crate::keywords;
 use crate::keywords::Keyword;
 use crate::parser::{Parser, ParserError};
@@ -1081,6 +1081,19 @@ pub trait Dialect: Debug + Any {
     fn supports_comma_separated_drop_column_list(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect considers the specified ident as a function
+    /// that returns an identifier. Typically used to generate identifiers
+    /// programmatically.
+    ///
+    /// - [Snowflake](https://docs.snowflake.com/en/sql-reference/identifier-literal)
+    fn is_identifier_generating_function_name(
+        &self,
+        _ident: &Ident,
+        _name_parts: &[ObjectNamePart],
+    ) -> bool {
+        false
+    }
 }
 
 /// This represents the operators for which precedence must be defined
diff --git a/src/dialect/snowflake.rs b/src/dialect/snowflake.rs
@@ -25,8 +25,8 @@ use crate::ast::helpers::stmt_data_loading::{
 use crate::ast::{
     ColumnOption, ColumnPolicy, ColumnPolicyProperty, CopyIntoSnowflakeKind, Ident,
     IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
-    IdentityPropertyOrder, ObjectName, RowAccessPolicy, ShowObjects, SqlOption, Statement,
-    TagsColumnOption, WrappedCollection,
+    IdentityPropertyOrder, ObjectName, ObjectNamePart, RowAccessPolicy, ShowObjects, SqlOption,
+    Statement, TagsColumnOption, WrappedCollection,
 };
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
@@ -367,6 +367,23 @@ impl Dialect for SnowflakeDialect {
     fn supports_comma_separated_drop_column_list(&self) -> bool {
         true
     }
+
+    fn is_identifier_generating_function_name(
+        &self,
+        ident: &Ident,
+        name_parts: &[ObjectNamePart],
+    ) -> bool {
+        ident.quote_style.is_none()
+            && ident.value.to_lowercase() == "identifier"
+            && !name_parts
+                .iter()
+                .any(|p| matches!(p, ObjectNamePart::Function(_)))
+    }
+
+    // For example: `SELECT IDENTIFIER('alias1').* FROM tbl AS alias1`
+    fn supports_select_expr_star(&self) -> bool {
+        true
+    }
 }
 
 fn parse_file_staging_command(kw: Keyword, parser: &mut Parser) -> Result<Statement, ParserError> {
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -10384,70 +10384,92 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Parse a possibly qualified, possibly quoted identifier, optionally allowing for wildcards,
+    /// Parse a possibly qualified, possibly quoted identifier, e.g.
+    /// `foo` or `myschema."table"
+    ///
+    /// The `in_table_clause` parameter indicates whether the object name is a table in a FROM, JOIN,
+    /// or similar table clause. Currently, this is used only to support unquoted hyphenated identifiers
+    /// in this context on BigQuery.
+    pub fn parse_object_name(&mut self, in_table_clause: bool) -> Result<ObjectName, ParserError> {
+        self.parse_object_name_inner(in_table_clause, false)
+    }
+
+    /// Parse a possibly qualified, possibly quoted identifier, e.g.
+    /// `foo` or `myschema."table"
+    ///
+    /// The `in_table_clause` parameter indicates whether the object name is a table in a FROM, JOIN,
+    /// or similar table clause. Currently, this is used only to support unquoted hyphenated identifiers
+    /// in this context on BigQuery.
+    ///
+    /// The `allow_wildcards` parameter indicates whether to allow for wildcards in the object name
     /// e.g. *, *.*, `foo`.*, or "foo"."bar"
-    fn parse_object_name_with_wildcards(
+    fn parse_object_name_inner(
         &mut self,
         in_table_clause: bool,
         allow_wildcards: bool,
     ) -> Result<ObjectName, ParserError> {
-        let mut idents = vec![];
-
+        let mut parts = vec![];
         if dialect_of!(self is BigQueryDialect) && in_table_clause {
             loop {
                 let (ident, end_with_period) = self.parse_unquoted_hyphenated_identifier()?;
-                idents.push(ident);
+                parts.push(ObjectNamePart::Identifier(ident));
                 if !self.consume_token(&Token::Period) && !end_with_period {
                     break;
                 }
             }
         } else {
             loop {
-                let ident = if allow_wildcards && self.peek_token().token == Token::Mul {
+                if allow_wildcards && self.peek_token().token == Token::Mul {
                     let span = self.next_token().span;
-                    Ident {
+                    parts.push(ObjectNamePart::Identifier(Ident {
                         value: Token::Mul.to_string(),
                         quote_style: None,
                         span,
+                    }));
+                } else if dialect_of!(self is BigQueryDialect) && in_table_clause {
+                    let (ident, end_with_period) = self.parse_unquoted_hyphenated_identifier()?;
+                    parts.push(ObjectNamePart::Identifier(ident));
+                    if !self.consume_token(&Token::Period) && !end_with_period {
+                        break;
                     }
+                } else if self.dialect.supports_object_name_double_dot_notation()
+                    && parts.len() == 1
+                    && matches!(self.peek_token().token, Token::Period)
+                {
+                    // Empty string here means default schema
+                    parts.push(ObjectNamePart::Identifier(Ident::new("")));
                 } else {
-                    if self.dialect.supports_object_name_double_dot_notation()
-                        && idents.len() == 1
-                        && self.consume_token(&Token::Period)
+                    let ident = self.parse_identifier()?;
+                    let part = if self
+                        .dialect
+                        .is_identifier_generating_function_name(&ident, &parts)
                     {
-                        // Empty string here means default schema
-                        idents.push(Ident::new(""));
-                    }
-                    self.parse_identifier()?
-                };
-                idents.push(ident);
+                        self.expect_token(&Token::LParen)?;
+                        let args: Vec<FunctionArg> =
+                            self.parse_comma_separated0(Self::parse_function_args, Token::RParen)?;
+                        self.expect_token(&Token::RParen)?;
+                        ObjectNamePart::Function(ObjectNamePartFunction { name: ident, args })
+                    } else {
+                        ObjectNamePart::Identifier(ident)
+                    };
+                    parts.push(part);
+                }
+
                 if !self.consume_token(&Token::Period) {
                     break;
                 }
             }
         }
-        Ok(ObjectName::from(idents))
-    }
-
-    /// Parse a possibly qualified, possibly quoted identifier, e.g.
-    /// `foo` or `myschema."table"
-    ///
-    /// The `in_table_clause` parameter indicates whether the object name is a table in a FROM, JOIN,
-    /// or similar table clause. Currently, this is used only to support unquoted hyphenated identifiers
-    /// in this context on BigQuery.
-    pub fn parse_object_name(&mut self, in_table_clause: bool) -> Result<ObjectName, ParserError> {
-        let ObjectName(mut idents) =
-            self.parse_object_name_with_wildcards(in_table_clause, false)?;
 
         // BigQuery accepts any number of quoted identifiers of a table name.
         // https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_identifiers
         if dialect_of!(self is BigQueryDialect)
-            && idents.iter().any(|part| {
+            && parts.iter().any(|part| {
                 part.as_ident()
                     .is_some_and(|ident| ident.value.contains('.'))
             })
         {
-            idents = idents
+            parts = parts
                 .into_iter()
                 .flat_map(|part| match part.as_ident() {
                     Some(ident) => ident
@@ -10466,7 +10488,7 @@ impl<'a> Parser<'a> {
                 .collect()
         }
 
-        Ok(ObjectName(idents))
+        Ok(ObjectName(parts))
     }
 
     /// Parse identifiers
@@ -14038,25 +14060,25 @@ impl<'a> Parser<'a> {
                     schemas: self.parse_comma_separated(|p| p.parse_object_name(false))?,
                 })
             } else if self.parse_keywords(&[Keyword::RESOURCE, Keyword::MONITOR]) {
-                Some(GrantObjects::ResourceMonitors(self.parse_comma_separated(
-                    |p| p.parse_object_name_with_wildcards(false, true),
-                )?))
+                Some(GrantObjects::ResourceMonitors(
+                    self.parse_comma_separated(|p| p.parse_object_name(false))?,
+                ))
             } else if self.parse_keywords(&[Keyword::COMPUTE, Keyword::POOL]) {
-                Some(GrantObjects::ComputePools(self.parse_comma_separated(
-                    |p| p.parse_object_name_with_wildcards(false, true),
-                )?))
+                Some(GrantObjects::ComputePools(
+                    self.parse_comma_separated(|p| p.parse_object_name(false))?,
+                ))
             } else if self.parse_keywords(&[Keyword::FAILOVER, Keyword::GROUP]) {
-                Some(GrantObjects::FailoverGroup(self.parse_comma_separated(
-                    |p| p.parse_object_name_with_wildcards(false, true),
-                )?))
+                Some(GrantObjects::FailoverGroup(
+                    self.parse_comma_separated(|p| p.parse_object_name(false))?,
+                ))
             } else if self.parse_keywords(&[Keyword::REPLICATION, Keyword::GROUP]) {
-                Some(GrantObjects::ReplicationGroup(self.parse_comma_separated(
-                    |p| p.parse_object_name_with_wildcards(false, true),
-                )?))
+                Some(GrantObjects::ReplicationGroup(
+                    self.parse_comma_separated(|p| p.parse_object_name(false))?,
+                ))
             } else if self.parse_keywords(&[Keyword::EXTERNAL, Keyword::VOLUME]) {
-                Some(GrantObjects::ExternalVolumes(self.parse_comma_separated(
-                    |p| p.parse_object_name_with_wildcards(false, true),
-                )?))
+                Some(GrantObjects::ExternalVolumes(
+                    self.parse_comma_separated(|p| p.parse_object_name(false))?,
+                ))
             } else {
                 let object_type = self.parse_one_of_keywords(&[
                     Keyword::SEQUENCE,
@@ -14073,7 +14095,7 @@ impl<'a> Parser<'a> {
                     Keyword::CONNECTION,
                 ]);
                 let objects =
-                    self.parse_comma_separated(|p| p.parse_object_name_with_wildcards(false, true));
+                    self.parse_comma_separated(|p| p.parse_object_name_inner(false, true));
                 match object_type {
                     Some(Keyword::DATABASE) => Some(GrantObjects::Databases(objects?)),
                     Some(Keyword::SCHEMA) => Some(GrantObjects::Schemas(objects?)),
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
@@ -1232,14 +1232,18 @@ fn parse_select_expr_star() {
         "SELECT 2. * 3 FROM T",
     );
     dialects.verified_only_select("SELECT myfunc().* FROM T");
-    dialects.verified_only_select("SELECT myfunc().* EXCEPT (foo) FROM T");
 
     // Invalid
     let res = dialects.parse_sql_statements("SELECT foo.*.* FROM T");
     assert_eq!(
         ParserError::ParserError("Expected: end of statement, found: .".to_string()),
         res.unwrap_err()
     );
+
+    let dialects = all_dialects_where(|d| {
+        d.supports_select_expr_star() && d.supports_select_wildcard_except()
+    });
+    dialects.verified_only_select("SELECT myfunc().* EXCEPT (foo) FROM T");
 }
 
 #[test]
diff --git a/tests/sqlparser_snowflake.rs b/tests/sqlparser_snowflake.rs

Original file line number	Diff line number	Diff line change
`@@ -1676,6 +1676,10 @@ impl Spanned for ObjectNamePart {`
`1676`	`1676`	`fn span(&self) -> Span {`
`1677`	`1677`	`match self {`
`1678`	`1678`	`ObjectNamePart::Identifier(ident) => ident.span,`
	`1679`	`+ ObjectNamePart::Function(func) => func`
	`1680`	`+ .name`
	`1681`	`+ .span`
	`1682`	`+ .union(&union_spans(func.args.iter().map(\|i\| i.span()))),`
`1679`	`1683`	`}`
`1680`	`1684`	`}`
`1681`	`1685`	`}`