support for weirder stuff

Author: deifactor

src/parser/mod.rs

@@ -3715,29 +3715,26 @@ impl<'a> Parser<'a> {
         })
     }
 
+    // Parser is either looking at a : or a bracket expression.
     fn parse_json_path(&mut self) -> Result<JsonPath, ParserError> {
         let mut path = Vec::new();
-        let has_colon = self.peek_token_ref().token == Token::Colon;
+        let mut has_colon = false;
         loop {
             match self.next_token().token {
                 Token::Colon if path.is_empty() => {
-                    path.push(self.parse_json_path_object_key()?);
+                    has_colon = true;
+                    if *self.peek_token_ref() == Token::LBracket {
+                        path.push(self.parse_json_path_bracket_element()?);
+                    } else {
+                        path.push(self.parse_json_path_object_key()?);
+                    }
                 }
                 Token::Period if !path.is_empty() => {
                     path.push(self.parse_json_path_object_key()?);
                 }
                 Token::LBracket => {
-                    if self.peek_token_ref().token == Token::Mul
-                        && self.dialect.supports_semi_structured_array_all_elements()
-                    {
-                        self.expect_token(&Token::Mul)?;
-                        path.push(JsonPathElem::AllElements);
-                    } else {
-                        let key = self.parse_expr()?;
-                        path.push(JsonPathElem::Bracket { key });
-                    }
-
-                    self.expect_token(&Token::RBracket)?;
+                    self.prev_token();
+                    path.push(self.parse_json_path_bracket_element()?);
                 }
                 _ => {
                     self.prev_token();
@@ -3750,6 +3747,22 @@ impl<'a> Parser<'a> {
         Ok(JsonPath { has_colon, path })
     }
 
+    /// Parses a single bracketed element in a JSON path expression, including both brackets.
+    fn parse_json_path_bracket_element(&mut self) -> Result<JsonPathElem, ParserError> {
+        self.expect_token(&Token::LBracket)?;
+        let elem = if *self.peek_token_ref() == Token::Mul
+            && self.dialect.supports_semi_structured_array_all_elements()
+        {
+            self.expect_token(&Token::Mul)?;
+            JsonPathElem::AllElements
+        } else {
+            let key = self.parse_expr()?;
+            JsonPathElem::Bracket { key }
+        };
+        self.expect_token(&Token::RBracket)?;
+        Ok(elem)
+    }
+
     /// Parses the parens following the `[ NOT ] IN` operator.
     pub fn parse_in(&mut self, expr: Expr, negated: bool) -> Result<Expr, ParserError> {
         // BigQuery allows `IN UNNEST(array_expression)`

tests/sqlparser_databricks.rs

@@ -408,6 +408,28 @@ fn parse_semi_structured_data_traversal() {
         select.projection[0]
     );
 
+    // asterisk for arrays
+    let sql = "SELECT a:['b'].c FROM t";
+    let select = databricks().verified_only_select(sql);
+    assert_eq!(
+        SelectItem::UnnamedExpr(Expr::JsonAccess {
+            value: Box::new(Expr::Identifier(Ident::new("a"))),
+            path: JsonPath {
+                has_colon: true,
+                path: vec![
+                    JsonPathElem::Bracket {
+                        key: Expr::value(Value::SingleQuotedString("b".to_owned())),
+                    },
+                    JsonPathElem::Dot {
+                        key: "c".to_owned(),
+                        quoted: false
+                    }
+                ]
+            },
+        }),
+        select.projection[0]
+    );
+
     // asterisk for arrays
     let sql = "SELECT a:b[*].c FROM t";
     let select = databricks().verified_only_select(sql);