Allow array to be used as a function name again

src/ast/mod.rs

@@ -159,8 +159,13 @@ impl fmt::Display for ObjectName {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+/// Represents an Array Expression, either
+/// `ARRAY[..]`, or `[..]`
 pub struct Array {
+    /// The list of expressions between brackets
     pub elem: Vec<Expr>,
+
+    /// `true` for  `ARRAY[..]`, `false` for `[..]`
     pub named: bool,
 }
 

src/parser.rs

@@ -420,7 +420,11 @@ impl<'a> Parser<'a> {
                 Keyword::TRIM => self.parse_trim_expr(),
                 Keyword::INTERVAL => self.parse_literal_interval(),
                 Keyword::LISTAGG => self.parse_listagg_expr(),
-                Keyword::ARRAY => self.parse_array_expr(true),
+                // Treat ARRAY[1,2,3] as an array [1,2,3], otherwise try as function call
+                Keyword::ARRAY if self.peek_token() == Token::LBracket => {
+                    self.expect_token(&Token::LBracket)?;
+                    self.parse_array_expr(true)
+                }
                 Keyword::NOT => Ok(Expr::UnaryOp {
                     op: UnaryOperator::Not,
                     expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
@@ -450,6 +454,7 @@ impl<'a> Parser<'a> {
                     _ => Ok(Expr::Identifier(w.to_ident())),
                 },
             }, // End of Token::Word
+            // array `[1, 2, 3]`
             Token::LBracket => self.parse_array_expr(false),
             tok @ Token::Minus | tok @ Token::Plus => {
                 let op = if tok == Token::Plus {
@@ -826,10 +831,9 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parses an array expression `[ex1, ex2, ..]`
+    /// if `named` is `true`, came from an expression like  `ARRAY[ex1, ex2]`
     pub fn parse_array_expr(&mut self, named: bool) -> Result<Expr, ParserError> {
-        if named {
-            self.expect_token(&Token::LBracket)?;
-        }
         let exprs = self.parse_comma_separated(Parser::parse_expr)?;
         self.expect_token(&Token::RBracket)?;
         Ok(Expr::Array(Array { elem: exprs, named }))

tests/sqlparser_common.rs

@@ -2246,19 +2246,24 @@ fn parse_bad_constraint() {
 
 #[test]
 fn parse_scalar_function_in_projection() {
-    let sql = "SELECT sqrt(id) FROM foo";
-    let select = verified_only_select(sql);
-    assert_eq!(
-        &Expr::Function(Function {
-            name: ObjectName(vec![Ident::new("sqrt")]),
-            args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(
-                Expr::Identifier(Ident::new("id"))
-            ))],
-            over: None,
-            distinct: false,
-        }),
-        expr_from_projection(only(&select.projection))
-    );
+    let names = vec!["sqrt", "array", "foo"];
+
+    for function_name in names {
+        // like SELECT sqrt(id) FROM foo
+        let sql = dbg!(format!("SELECT {}(id) FROM foo", function_name));
+        let select = verified_only_select(&sql);
+        assert_eq!(
+            &Expr::Function(Function {
+                name: ObjectName(vec![Ident::new(function_name)]),
+                args: vec![FunctionArg::Unnamed(FunctionArgExpr::Expr(
+                    Expr::Identifier(Ident::new("id"))
+                ))],
+                over: None,
+                distinct: false,
+            }),
+            expr_from_projection(only(&select.projection))
+        );
+    }
 }
 
 fn run_explain_analyze(query: &str, expected_verbose: bool, expected_analyze: bool) {