DuckDB, MySQL, Spark, Databricks, Hive, ClickHouse: Accept string literal aliases only where each engine does

Author: LucaCappelletti94

src/dialect/clickhouse.rs

@@ -28,6 +28,17 @@ impl Dialect for ClickHouseDialect {
         ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_'
     }
 
+    /// Aliases are identifiers, quoted with `"` or a backtick, see
+    /// <https://clickhouse.com/docs/reference/syntax#identifiers>
+    fn supports_string_literal_column_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
+    /// See <https://clickhouse.com/docs/reference/syntax#identifiers>
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
     fn is_identifier_part(&self, ch: char) -> bool {
         self.is_identifier_start(ch) || ch.is_ascii_digit()
     }

src/dialect/databricks.rs

@@ -31,6 +31,19 @@ impl Dialect for DatabricksDialect {
         matches!(ch, '`')
     }
 
+    /// Aliases are identifiers, see `column_alias` in
+    /// <https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-syntax-qry-select.html> and
+    /// <https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-identifiers.html>
+    fn supports_string_literal_column_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
+    /// Aliases are identifiers, see
+    /// <https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-identifiers.html>
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
     /// See <https://docs.databricks.com/en/sql/language-manual/sql-ref-identifiers.html>
     fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
         Some('`')

src/dialect/duckdb.rs

@@ -28,6 +28,14 @@ impl Dialect for DuckDbDialect {
         true
     }
 
+    fn supports_string_literal_column_alias(&self, explicit: bool) -> bool {
+        explicit
+    }
+
+    fn supports_string_literal_table_alias(&self, explicit: bool) -> bool {
+        explicit
+    }
+
     fn supports_trailing_commas(&self) -> bool {
         true
     }

src/dialect/hive.rs

@@ -31,6 +31,18 @@ impl Dialect for HiveDialect {
         true
     }
 
+    /// The alias is an `identifier`, see `selectItem` in
+    /// <https://github.com/apache/hive/blob/master/parser/src/java/org/apache/hadoop/hive/ql/parse/SelectClauseParser.g>
+    fn supports_string_literal_column_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
+    /// The alias is an `identifier`, see `tableSource` in
+    /// <https://github.com/apache/hive/blob/master/parser/src/java/org/apache/hadoop/hive/ql/parse/FromClauseParser.g>
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
     /// See <https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-RulesforColumnNames>
     fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
         Some('`')

src/dialect/mod.rs

@@ -1537,11 +1537,20 @@ pub trait Dialect: Debug + Any {
         explicit || self.is_table_alias(kw, parser)
     }
 
-    /// Returns true if a single-quoted string can be an alias, as in `SELECT 1 AS 'x'`.
+    /// Returns true if a single-quoted string can name a select item, as in `SELECT 1 AS 'x'`.
+    /// `explicit` is true when the alias follows `AS`.
     ///
     /// [MySQL](https://dev.mysql.com/doc/refman/8.4/en/problems-with-alias.html),
     /// [SQLite](https://www.sqlite.org/lang_keywords.html)
-    fn supports_string_literal_alias(&self) -> bool {
+    fn supports_string_literal_column_alias(&self, _explicit: bool) -> bool {
+        true
+    }
+
+    /// Returns true if a single-quoted string can name a table, as in `FROM t AS 'x'`.
+    /// `explicit` is true when the alias follows `AS`.
+    ///
+    /// [SQLite](https://www.sqlite.org/lang_keywords.html)
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
         true
     }
 

src/dialect/mysql.rs

@@ -41,6 +41,12 @@ const RESERVED_FOR_TABLE_ALIAS_MYSQL: &[Keyword] = &[
 pub struct MySqlDialect {}
 
 impl Dialect for MySqlDialect {
+    /// Only select-list aliases may use string quoting, see
+    /// <https://dev.mysql.com/doc/refman/8.4/en/problems-with-alias.html>
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
     fn is_identifier_start(&self, ch: char) -> bool {
         // See https://dev.mysql.com/doc/refman/8.0/en/identifiers.html.
         // Identifiers which begin with a digit are recognized while tokenizing numbers,

src/dialect/postgresql.rs

@@ -116,7 +116,13 @@ impl Dialect for PostgreSqlDialect {
 
     /// Aliases are identifiers, see `output_name` and `alias` in
     /// <https://www.postgresql.org/docs/current/sql-select.html>
-    fn supports_string_literal_alias(&self) -> bool {
+    fn supports_string_literal_column_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
+    /// Aliases are identifiers, see `alias` in
+    /// <https://www.postgresql.org/docs/current/sql-select.html>
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
         false
     }
 

src/dialect/spark.rs

@@ -36,6 +36,18 @@ impl Dialect for SparkSqlDialect {
         matches!(ch, '`')
     }
 
+    /// Aliases are identifiers, see `named_expression` in
+    /// <https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select.html> and
+    /// <https://spark.apache.org/docs/latest/sql-ref-identifier.html>
+    fn supports_string_literal_column_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
+    /// Aliases are identifiers, see <https://spark.apache.org/docs/latest/sql-ref-identifier.html>
+    fn supports_string_literal_table_alias(&self, _explicit: bool) -> bool {
+        false
+    }
+
     /// See <https://spark.apache.org/docs/latest/sql-ref-identifier.html>
     fn identifier_quote_style(&self, _identifier: &str) -> Option<char> {
         Some('`')

src/parser/mod.rs

@@ -366,6 +366,13 @@ pub struct Parser<'a> {
     failed_in_subquery_positions: BTreeMap<usize, Option<usize>>,
 }
 
+/// Whether an alias names a select item or a table.
+#[derive(Debug, Clone, Copy)]
+enum AliasKind {
+    Column,
+    Table,
+}
+
 /// Copy marker for a [`ParserError`] cached by the `parse_prefix` failure
 /// memoization, so the caches hold no strings.
 #[derive(Debug, Clone, Copy)]
@@ -1414,7 +1421,7 @@ impl<'a> Parser<'a> {
         fn validator(explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool {
             explicit || !&[Keyword::ASC, Keyword::DESC, Keyword::GROUP].contains(kw)
         }
-        let alias = self.parse_optional_alias_inner(None, validator)?;
+        let alias = self.parse_optional_alias_inner(None, AliasKind::Column, validator)?;
         let order_by = OrderByOptions {
             sort: self.parse_optional_order_by_sort(),
             nulls_first: None,
@@ -13605,7 +13612,7 @@ impl<'a> Parser<'a> {
         fn validator(explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
             parser.dialect.is_select_item_alias(explicit, kw, parser)
         }
-        self.parse_optional_alias_inner(None, validator)
+        self.parse_optional_alias_inner(None, AliasKind::Column, validator)
     }
 
     /// Optionally parses an alias for a table like in `... FROM generate_series(1, 10) AS t (col)`.
@@ -13616,7 +13623,7 @@ impl<'a> Parser<'a> {
             parser.dialect.is_table_factor_alias(explicit, kw, parser)
         }
         let explicit = self.peek_keyword(Keyword::AS);
-        match self.parse_optional_alias_inner(None, validator)? {
+        match self.parse_optional_alias_inner(None, AliasKind::Table, validator)? {
             Some(name) => {
                 let columns = self.parse_table_alias_column_defs()?;
                 let at = if self.dialect.supports_partiql() && self.parse_keyword(Keyword::AT) {
@@ -13704,7 +13711,7 @@ impl<'a> Parser<'a> {
         fn validator(_explicit: bool, _kw: &Keyword, _parser: &mut Parser) -> bool {
             false
         }
-        self.parse_optional_alias_inner(Some(reserved_kwds), validator)
+        self.parse_optional_alias_inner(Some(reserved_kwds), AliasKind::Column, validator)
     }
 
     /// Parses an optional alias after a SQL element such as a select list item
@@ -13716,6 +13723,7 @@ impl<'a> Parser<'a> {
     fn parse_optional_alias_inner<F>(
         &mut self,
         reserved_kwds: Option<&[Keyword]>,
+        kind: AliasKind,
         validator: F,
     ) -> Result<Option<Ident>, ParserError>
     where
@@ -13739,7 +13747,14 @@ impl<'a> Parser<'a> {
             Token::Word(w) if validator(after_as, &w.keyword, self) => {
                 Ok(Some(w.into_ident(next_token.span)))
             }
-            Token::SingleQuotedString(s) if self.dialect.supports_string_literal_alias() => {
+            Token::SingleQuotedString(s)
+                if match kind {
+                    AliasKind::Column => {
+                        self.dialect.supports_string_literal_column_alias(after_as)
+                    }
+                    AliasKind::Table => self.dialect.supports_string_literal_table_alias(after_as),
+                } =>
+            {
                 Ok(Some(Ident::with_quote('\'', s)))
             }
             Token::DoubleQuotedString(s) => Ok(Some(Ident::with_quote('\"', s))),
@@ -17883,7 +17898,7 @@ impl<'a> Parser<'a> {
                 // ~ for a PIVOT aggregate function the alias must not be a "FOR"; in any dialect
                 kw != &Keyword::FOR && parser.dialect.is_select_item_alias(explicit, kw, parser)
             }
-            self.parse_optional_alias_inner(None, validator)?
+            self.parse_optional_alias_inner(None, AliasKind::Column, validator)?
         };
         Ok(ExprWithAlias { expr, alias })
     }

tests/sqlparser_common.rs

@@ -20750,8 +20750,80 @@ fn parse_cte_materialization() {
 
 #[test]
 fn parse_string_literal_alias() {
-    let dialects = all_dialects_where(|d| d.supports_string_literal_alias());
-    dialects.one_statement_parses_to("SELECT 1 'x'", "SELECT 1 AS 'x'");
-    dialects.verified_stmt("SELECT 1 AS 'x'");
-    dialects.verified_stmt("SELECT a FROM t AS 'y'");
+    for (sql, canonical, table, explicit, error) in [
+        (
+            "SELECT 1 AS 'x'",
+            "SELECT 1 AS 'x'",
+            false,
+            true,
+            "Expected: an identifier after AS, found: 'x'",
+        ),
+        (
+            "SELECT 1 'x'",
+            "SELECT 1 AS 'x'",
+            false,
+            false,
+            "Expected: end of statement, found: 'x'",
+        ),
+        (
+            "SELECT a FROM t AS 'y'",
+            "SELECT a FROM t AS 'y'",
+            true,
+            true,
+            "Expected: an identifier after AS, found: 'y'",
+        ),
+        (
+            "SELECT a FROM t 'y'",
+            "SELECT a FROM t 'y'",
+            true,
+            false,
+            "Expected: end of statement, found: 'y'",
+        ),
+    ] {
+        let supported = |d: &dyn Dialect| {
+            if table {
+                d.supports_string_literal_table_alias(explicit)
+            } else {
+                d.supports_string_literal_column_alias(explicit)
+            }
+        };
+        all_dialects_where(supported).one_statement_parses_to(sql, canonical);
+        assert_eq!(
+            all_dialects_where(|d| !supported(d)).parse_sql_statements(sql),
+            Err(ParserError::ParserError(error.to_string())),
+            "{sql}"
+        );
+    }
+}
+
+#[test]
+fn parse_string_literal_alias_per_engine() {
+    let forms = [
+        "SELECT 1 AS 'x'",
+        "SELECT 1 'x'",
+        "SELECT a FROM t AS 'y'",
+        "SELECT a FROM t 'y'",
+    ];
+    let dialects: [(Box<dyn Dialect>, [bool; 4]); 8] = [
+        (Box::new(PostgreSqlDialect {}), [false, false, false, false]),
+        (Box::new(SQLiteDialect {}), [true, true, true, true]),
+        (Box::new(DuckDbDialect {}), [true, false, true, false]),
+        (Box::new(MySqlDialect {}), [true, true, false, false]),
+        (
+            Box::new(sqlparser::dialect::SparkSqlDialect {}),
+            [false, false, false, false],
+        ),
+        (Box::new(DatabricksDialect {}), [false, false, false, false]),
+        (Box::new(HiveDialect {}), [false, false, false, false]),
+        (Box::new(ClickHouseDialect {}), [false, false, false, false]),
+    ];
+    for (dialect, accepted) in dialects {
+        for (sql, accepted) in forms.iter().zip(accepted) {
+            assert_eq!(
+                Parser::parse_sql(dialect.as_ref(), sql).is_ok(),
+                accepted,
+                "{dialect:?}: {sql}"
+            );
+        }
+    }
 }