Merge branch 'main' into not-null-and-notnull-support

Author: ryanschneider

src/ast/query.rs

@@ -321,6 +321,11 @@ pub struct Select {
     pub top_before_distinct: bool,
     /// projection expressions
     pub projection: Vec<SelectItem>,
+    /// Excluded columns from the projection expression which are not specified
+    /// directly after a wildcard.
+    ///
+    /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_EXCLUDE_list.html)
+    pub exclude: Option<ExcludeSelectItem>,
     /// INTO
     pub into: Option<SelectInto>,
     /// FROM
@@ -401,6 +406,10 @@ impl fmt::Display for Select {
             indented_list(f, &self.projection)?;
         }
 
+        if let Some(exclude) = &self.exclude {
+            write!(f, " {exclude}")?;
+        }
+
         if let Some(ref into) = self.into {
             f.write_str(" ")?;
             into.fmt(f)?;

src/ast/spans.rs

@@ -2220,6 +2220,7 @@ impl Spanned for Select {
             distinct: _, // todo
             top: _,      // todo, mysql specific
             projection,
+            exclude: _,
             into,
             from,
             lateral_views,

src/dialect/duckdb.rs

@@ -95,6 +95,10 @@ impl Dialect for DuckDbDialect {
         true
     }
 
+    fn supports_select_wildcard_exclude(&self) -> bool {
+        true
+    }
+  
     /// DuckDB supports `NOTNULL` as an alias for `IS NOT NULL`,
     /// see DuckDB Comparisons <https://duckdb.org/docs/stable/sql/expressions/comparison_operators#between-and-is-not-null>
     fn supports_notnull_operator(&self) -> bool {

src/dialect/generic.rs

@@ -179,4 +179,8 @@ impl Dialect for GenericDialect {
     fn supports_filter_during_aggregation(&self) -> bool {
         true
     }
+
+    fn supports_select_wildcard_exclude(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -570,6 +570,26 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports an exclude option
+    /// following a wildcard in the projection section. For example:
+    /// `SELECT * EXCLUDE col1 FROM tbl`.
+    ///
+    /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_EXCLUDE_list.html)
+    /// [Snowflake](https://docs.snowflake.com/en/sql-reference/sql/select)
+    fn supports_select_wildcard_exclude(&self) -> bool {
+        false
+    }
+
+    /// Returns true if the dialect supports an exclude option
+    /// as the last item in the projection section, not necessarily
+    /// after a wildcard. For example:
+    /// `SELECT *, c1, c2 EXCLUDE c3 FROM tbl`
+    ///
+    /// [Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_EXCLUDE_list.html)
+    fn supports_select_exclude(&self) -> bool {
+        false
+    }
+
     /// Dialect-specific infix parser override
     ///
     /// This method is called to parse the next infix expression.
@@ -998,11 +1018,17 @@ pub trait Dialect: Debug + Any {
         explicit || self.is_column_alias(kw, parser)
     }
 
+    /// Returns true if the specified keyword should be parsed as a table identifier.
+    /// See [keywords::RESERVED_FOR_TABLE_ALIAS]
+    fn is_table_alias(&self, kw: &Keyword, _parser: &mut Parser) -> bool {
+        !keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw)
+    }
+
     /// Returns true if the specified keyword should be parsed as a table factor alias.
     /// When explicit is true, the keyword is preceded by an `AS` word. Parser is provided
     /// to enable looking ahead if needed.
-    fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, _parser: &mut Parser) -> bool {
-        explicit || !keywords::RESERVED_FOR_TABLE_ALIAS.contains(kw)
+    fn is_table_factor_alias(&self, explicit: bool, kw: &Keyword, parser: &mut Parser) -> bool {
+        explicit || self.is_table_alias(kw, parser)
     }
 
     /// Returns true if this dialect supports querying historical table data

src/dialect/redshift.rs

@@ -131,4 +131,12 @@ impl Dialect for RedshiftSqlDialect {
     fn supports_string_literal_backslash_escape(&self) -> bool {
         true
     }
+
+    fn supports_select_wildcard_exclude(&self) -> bool {
+        true
+    }
+
+    fn supports_select_exclude(&self) -> bool {
+        true
+    }
 }

src/dialect/snowflake.rs

@@ -318,9 +318,11 @@ impl Dialect for SnowflakeDialect {
             }
 
             // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT`
-            // which would give it a different meanings, for example: `SELECT 1 FETCH FIRST 10 ROWS` - not an alias
-            Keyword::FETCH
-                if parser.peek_keyword(Keyword::FIRST) || parser.peek_keyword(Keyword::NEXT) =>
+            // which would give it a different meanings, for example: 
+            // `SELECT 1 FETCH FIRST 10 ROWS` - not an alias
+            // `SELECT 1 FETCH 10` - not an alias
+            Keyword::FETCH if parser.peek_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT]).is_some()
+                    || matches!(parser.peek_token().token, Token::Number(_, _)) =>
             {
                 false
             }
@@ -345,6 +347,86 @@ impl Dialect for SnowflakeDialect {
         }
     }
 
+    fn is_table_alias(&self, kw: &Keyword, parser: &mut Parser) -> bool {
+        match kw {
+            // The following keywords can be considered an alias as long as
+            // they are not followed by other tokens that may change their meaning
+            Keyword::LIMIT
+            | Keyword::RETURNING
+            | Keyword::INNER
+            | Keyword::USING
+            | Keyword::PIVOT
+            | Keyword::UNPIVOT
+            | Keyword::EXCEPT
+            | Keyword::MATCH_RECOGNIZE
+            | Keyword::OFFSET
+                if !matches!(parser.peek_token_ref().token, Token::SemiColon | Token::EOF) =>
+            {
+                false
+            }
+
+            // `FETCH` can be considered an alias as long as it's not followed by `FIRST`` or `NEXT`
+            // which would give it a different meanings, for example:
+            // `SELECT * FROM tbl FETCH FIRST 10 ROWS` - not an alias
+            // `SELECT * FROM tbl FETCH 10` - not an alias
+            Keyword::FETCH
+                if parser
+                    .peek_one_of_keywords(&[Keyword::FIRST, Keyword::NEXT])
+                    .is_some()
+                    || matches!(parser.peek_token().token, Token::Number(_, _)) =>
+            {
+                false
+            }
+
+            // All sorts of join-related keywords can be considered aliases unless additional
+            // keywords change their meaning.
+            Keyword::RIGHT | Keyword::LEFT | Keyword::SEMI | Keyword::ANTI
+                if parser
+                    .peek_one_of_keywords(&[Keyword::JOIN, Keyword::OUTER])
+                    .is_some() =>
+            {
+                false
+            }
+            Keyword::GLOBAL if parser.peek_keyword(Keyword::FULL) => false,
+
+            // Reserved keywords by the Snowflake dialect, which seem to be less strictive
+            // than what is listed in `keywords::RESERVED_FOR_TABLE_ALIAS`. The following
+            // keywords were tested with the this statement: `SELECT <KW>.* FROM tbl <KW>`.
+            Keyword::WITH
+            | Keyword::ORDER
+            | Keyword::SELECT
+            | Keyword::WHERE
+            | Keyword::GROUP
+            | Keyword::HAVING
+            | Keyword::LATERAL
+            | Keyword::UNION
+            | Keyword::INTERSECT
+            | Keyword::MINUS
+            | Keyword::ON
+            | Keyword::JOIN
+            | Keyword::INNER
+            | Keyword::CROSS
+            | Keyword::FULL
+            | Keyword::LEFT
+            | Keyword::RIGHT
+            | Keyword::NATURAL
+            | Keyword::USING
+            | Keyword::ASOF
+            | Keyword::MATCH_CONDITION
+            | Keyword::SET
+            | Keyword::QUALIFY
+            | Keyword::FOR
+            | Keyword::START
+            | Keyword::CONNECT
+            | Keyword::SAMPLE
+            | Keyword::TABLESAMPLE
+            | Keyword::FROM => false,
+
+            // Any other word is considered an alias
+            _ => true,
+        }
+    }
+
     /// See: <https://docs.snowflake.com/en/sql-reference/constructs/at-before>
     fn supports_timestamp_versioning(&self) -> bool {
         true
@@ -384,6 +466,10 @@ impl Dialect for SnowflakeDialect {
     fn supports_select_expr_star(&self) -> bool {
         true
     }
+
+    fn supports_select_wildcard_exclude(&self) -> bool {
+        true
+    }
 }
 
 fn parse_file_staging_command(kw: Keyword, parser: &mut Parser) -> Result<Statement, ParserError> {

src/keywords.rs

@@ -1120,6 +1120,7 @@ pub const RESERVED_FOR_COLUMN_ALIAS: &[Keyword] = &[
     Keyword::FETCH,
     Keyword::UNION,
     Keyword::EXCEPT,
+    Keyword::EXCLUDE,
     Keyword::INTERSECT,
     Keyword::MINUS,
     Keyword::CLUSTER,

src/parser/mod.rs

@@ -222,13 +222,17 @@ pub struct ParserOptions {
     /// Controls how literal values are unescaped. See
     /// [`Tokenizer::with_unescape`] for more details.
     pub unescape: bool,
+    /// Controls if the parser expects a semi-colon token
+    /// between statements. Default is `true`.
+    pub require_semicolon_stmt_delimiter: bool,
 }
 
 impl Default for ParserOptions {
     fn default() -> Self {
         Self {
             trailing_commas: false,
             unescape: true,
+            require_semicolon_stmt_delimiter: true,
         }
     }
 }
@@ -470,6 +474,10 @@ impl<'a> Parser<'a> {
                 expecting_statement_delimiter = false;
             }
 
+            if !self.options.require_semicolon_stmt_delimiter {
+                expecting_statement_delimiter = false;
+            }
+
             match self.peek_token().token {
                 Token::EOF => break,
 
@@ -11762,6 +11770,7 @@ impl<'a> Parser<'a> {
                     top: None,
                     top_before_distinct: false,
                     projection: vec![],
+                    exclude: None,
                     into: None,
                     from,
                     lateral_views: vec![],
@@ -11804,6 +11813,12 @@ impl<'a> Parser<'a> {
                 self.parse_projection()?
             };
 
+        let exclude = if self.dialect.supports_select_exclude() {
+            self.parse_optional_select_item_exclude()?
+        } else {
+            None
+        };
+
         let into = if self.parse_keyword(Keyword::INTO) {
             Some(self.parse_select_into()?)
         } else {
@@ -11937,6 +11952,7 @@ impl<'a> Parser<'a> {
             top,
             top_before_distinct,
             projection,
+            exclude,
             into,
             from,
             lateral_views,
@@ -15074,8 +15090,7 @@ impl<'a> Parser<'a> {
         } else {
             None
         };
-        let opt_exclude = if opt_ilike.is_none()
-            && dialect_of!(self is GenericDialect | DuckDbDialect | SnowflakeDialect)
+        let opt_exclude = if opt_ilike.is_none() && self.dialect.supports_select_wildcard_exclude()
         {
             self.parse_optional_select_item_exclude()?
         } else {

src/test_utils.rs

@@ -294,6 +294,11 @@ pub fn all_dialects() -> TestedDialects {
     ])
 }
 
+// Returns all available dialects with the specified parser options
+pub fn all_dialects_with_options(options: ParserOptions) -> TestedDialects {
+    TestedDialects::new_with_options(all_dialects().dialects, options)
+}
+
 /// Returns all dialects matching the given predicate.
 pub fn all_dialects_where<F>(predicate: F) -> TestedDialects
 where