allow calling position as regular function

Author: jmhain

src/parser/mod.rs

@@ -1038,7 +1038,7 @@ impl<'a> Parser<'a> {
                 Keyword::CEIL => self.parse_ceil_floor_expr(true),
                 Keyword::FLOOR => self.parse_ceil_floor_expr(false),
                 Keyword::POSITION if self.peek_token().token == Token::LParen => {
-                    self.parse_position_expr()
+                    self.parse_position_expr(w.to_ident())
                 }
                 Keyword::SUBSTRING => self.parse_substring_expr(),
                 Keyword::OVERLAY => self.parse_overlay_expr(),
@@ -1689,24 +1689,25 @@ impl<'a> Parser<'a> {
         }
     }
 
-    pub fn parse_position_expr(&mut self) -> Result<Expr, ParserError> {
-        // PARSE SELECT POSITION('@' in field)
-        self.expect_token(&Token::LParen)?;
+    pub fn parse_position_expr(&mut self, ident: Ident) -> Result<Expr, ParserError> {
+        match self.maybe_parse(|p| {
+            // PARSE SELECT POSITION('@' in field)
+            p.expect_token(&Token::LParen)?;
 
-        // Parse the subexpr till the IN keyword
-        let expr = self.parse_subexpr(Self::BETWEEN_PREC)?;
-        if self.parse_keyword(Keyword::IN) {
-            let from = self.parse_expr()?;
-            self.expect_token(&Token::RParen)?;
+            // Parse the subexpr till the IN keyword
+            let expr = p.parse_subexpr(Self::BETWEEN_PREC)?;
+            p.expect_keyword(Keyword::IN)?;
+            let from = p.parse_expr()?;
+            p.expect_token(&Token::RParen)?;
             Ok(Expr::Position {
                 expr: Box::new(expr),
                 r#in: Box::new(from),
             })
-        } else {
-            parser_err!(
-                "Position function must include IN keyword".to_string(),
-                self.peek_token().location
-            )
+        }) {
+            Some(expr) => Ok(expr),
+            // Snowflake supports `position` as an ordinary function call
+            // without the special `IN` syntax.
+            None => self.parse_function(ObjectName(vec![ident])),
         }
     }
 

tests/sqlparser_common.rs

@@ -4140,7 +4140,7 @@ fn parse_scalar_function_in_projection() {
 
     for function_name in names {
         // like SELECT sqrt(id) FROM foo
-        let sql = dbg!(format!("SELECT {function_name}(id) FROM foo"));
+        let sql = format!("SELECT {function_name}(id) FROM foo");
         let select = verified_only_select(&sql);
         assert_eq!(
             &call(function_name, [Expr::Identifier(Ident::new("id"))]),
@@ -8202,17 +8202,10 @@ fn parse_position() {
 
 #[test]
 fn parse_position_negative() {
-    let sql = "SELECT POSITION(foo) from bar";
-    let res = parse_sql_statements(sql);
-    assert_eq!(
-        ParserError::ParserError("Position function must include IN keyword".to_string()),
-        res.unwrap_err()
-    );
-
     let sql = "SELECT POSITION(foo IN) from bar";
     let res = parse_sql_statements(sql);
     assert_eq!(
-        ParserError::ParserError("Expected: an expression:, found: )".to_string()),
+        ParserError::ParserError("Expected: (, found: )".to_string()),
         res.unwrap_err()
     );
 }

tests/sqlparser_snowflake.rs

@@ -2256,3 +2256,9 @@ fn asof_joins() {
           "ORDER BY s.observed",
     ));
 }
+
+#[test]
+fn test() {
+    snowflake().verified_query("SELECT position('an', 'banana', 1)");
+    snowflake().verified_query("SELECT n, h, POSITION(n IN h) FROM pos");
+}