Support IGNORE|RESPECT NULLs clause in window functions

src/ast/mod.rs

@@ -595,6 +595,14 @@ pub enum Expr {
         /// `<search modifier>`
         opt_search_modifier: Option<SearchModifier>,
     },
+    RankFunction {
+        name: ObjectName,
+        expr: Box<Expr>,
+        offset: Option<Value>,
+        default: Option<Box<Expr>>,
+        respect_nulls: Option<bool>,
+        window: WindowSpec,
+    },
 }
 
 impl fmt::Display for Expr {
@@ -965,6 +973,32 @@ impl fmt::Display for Expr {
 
                 Ok(())
             }
+            Expr::RankFunction {
+                name,
+                expr,
+                offset,
+                default,
+                respect_nulls,
+                window,
+            } => {
+                write!(f, "{name}({expr}")?;
+                if let Some(offset_value) = offset {
+                    write!(f, ",{offset_value}")?;
+                }
+                if let Some(default_value) = default {
+                    write!(f, ",{default_value}")?;
+                }
+                write!(f, ") ")?;
+                if let Some(respect_nulls_value) = respect_nulls {
+                    if *respect_nulls_value {
+                        write!(f, "RESPECT NULLS ")?;
+                    } else {
+                        write!(f, "IGNORE NULLS ")?;
+                    }
+                }
+                write!(f, "OVER ({window})")?;
+                Ok(())
+            }
         }
     }
 }

src/keywords.rs

@@ -516,6 +516,7 @@ define_keywords!(
     REPLACE,
     REPLICATION,
     RESET,
+    RESPECT,
     RESTRICT,
     RESULT,
     RETAIN,

src/parser/mod.rs

@@ -787,6 +787,9 @@ impl<'a> Parser<'a> {
                 }
                 Keyword::CASE => self.parse_case_expr(),
                 Keyword::CAST => self.parse_cast_expr(),
+                Keyword::LAG | Keyword::FIRST_VALUE | Keyword::LAST_VALUE | Keyword::LEAD if dialect_of!(self is SnowflakeDialect) => {
+                    self.parse_rank_functions(ObjectName(vec![w.to_ident()]))
+                }
                 Keyword::TRY_CAST => self.parse_try_cast_expr(),
                 Keyword::SAFE_CAST => self.parse_safe_cast_expr(),
                 Keyword::EXISTS => self.parse_exists_expr(false),
@@ -7397,6 +7400,47 @@ impl<'a> Parser<'a> {
         Ok(clauses)
     }
 
+    pub fn parse_rank_functions(&mut self, name: ObjectName) -> Result<Expr, ParserError> {
+        self.expect_token(&Token::LParen)?;
+        let expr = self.parse_expr()?;
+        let offset = if self.consume_token(&Token::Comma) {
+            Some(self.parse_number_value()?)
+        } else {
+            None
+        };
+        let default = if self.consume_token(&Token::Comma) {
+            Some(self.parse_expr()?)
+        } else {
+            None
+        };
+        self.expect_token(&Token::RParen)?;
+
+        let respect_nulls;
+        if self.parse_keyword(Keyword::IGNORE) {
+            self.expect_keyword(Keyword::NULLS)?;
+            respect_nulls = Some(false)
+        } else if self.parse_keyword(Keyword::RESPECT) {
+            self.expect_keyword(Keyword::NULLS)?;
+            respect_nulls = Some(true)
+        } else {
+            respect_nulls = None
+        }
+
+        self.expect_keyword(Keyword::OVER)?;
+        self.expect_token(&Token::LParen)?;
+
+        let window = self.parse_window_spec()?;
+
+        Ok(Expr::RankFunction {
+            name,
+            expr: Box::new(expr),
+            offset,
+            default: default.map(Box::new),
+            respect_nulls,
+            window,
+        })
+    }
+
     pub fn parse_merge(&mut self) -> Result<Statement, ParserError> {
         let into = self.parse_keyword(Keyword::INTO);
 

tests/sqlparser_snowflake.rs

@@ -1064,3 +1064,40 @@ fn test_snowflake_trim() {
         snowflake().parse_sql_statements(error_sql).unwrap_err()
     );
 }
+
+#[test]
+fn test_snowflake_rank() {
+    let real_sql = "SELECT col_1, col_2, LAG(col_2) IGNORE NULLS OVER (ORDER BY col_1) FROM t1";
+    assert_eq!(snowflake().verified_stmt(real_sql).to_string(), real_sql);
+
+    let first_sql = "SELECT column1, column2, FIRST_VALUE(column2) OVER (PARTITION BY column1 ORDER BY column2 NULLS LAST) AS column2_first FROM t1";
+    assert_eq!(snowflake().verified_stmt(first_sql).to_string(), first_sql);
+
+    let sql_only_select = "SELECT LAG(col_2,1,0) OVER (PARTITION BY col_3 ORDER BY col_1)";
+    let select = snowflake().verified_only_select(sql_only_select);
+    assert_eq!(
+        &Expr::RankFunction {
+            name: ObjectName(vec![Ident::new("LAG")]),
+            expr: Box::new(Expr::Identifier(Ident::new("col_2"))),
+            offset: Some(Value::Number("1".parse().unwrap(), false)),
+            default: Some(Box::new(Expr::Value(number("0")))),
+            respect_nulls: None,
+            window: WindowSpec {
+                partition_by: vec![Expr::Identifier(Ident {
+                    value: "col_3".to_string(),
+                    quote_style: None,
+                })],
+                order_by: vec![OrderByExpr {
+                    expr: Expr::Identifier(Ident {
+                        value: "col_1".to_string(),
+                        quote_style: None,
+                    }),
+                    asc: None,
+                    nulls_first: None,
+                }],
+                window_frame: None
+            }
+        },
+        expr_from_projection(only(&select.projection))
+    );
+}