add JsonPathElem::ColonBracket variant and remove AST tests

Author: whirlun

src/ast/mod.rs

@@ -651,6 +651,14 @@ pub enum JsonPathElem {
         /// The expression used as the bracket key (string or numeric expression).
         key: Expr,
     },
+    /// Access an object field using colon bracket notation
+    /// e.g. `obj:['foo']`
+    ///
+    /// See <https://docs.databricks.com/en/sql/language-manual/functions/colonsign.html>
+    ColonBracket {
+        /// The expression used as the bracket key (string or numeric expression).
+        key: Expr,
+    },
 }
 
 /// A JSON path.
@@ -685,6 +693,9 @@ impl fmt::Display for JsonPath {
                 JsonPathElem::Bracket { key } => {
                     write!(f, "[{key}]")?;
                 }
+                JsonPathElem::ColonBracket { key } => {
+                    write!(f, ":[{key}]")?;
+                }
             }
         }
         Ok(())

src/ast/spans.rs

@@ -1797,6 +1797,7 @@ impl Spanned for JsonPathElem {
         match self {
             JsonPathElem::Dot { .. } => Span::empty(),
             JsonPathElem::Bracket { key } => key.span(),
+            JsonPathElem::ColonBracket { key } => key.span(),
         }
     }
 }

src/parser/mod.rs

@@ -4211,15 +4211,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn parse_json_path_bracket_key(&mut self) -> Result<Expr, ParserError> {
-        // Databricks supports [*] wildcard accessor
-        if self.consume_token(&Token::Mul) {
-            Ok(Expr::Wildcard(AttachedToken::empty()))
-        } else {
-            self.parse_expr()
-        }
-    }
-
     fn parse_json_access(&mut self, expr: Expr) -> Result<Expr, ParserError> {
         let path = self.parse_json_path()?;
         Ok(Expr::JsonAccess {
@@ -4232,27 +4223,20 @@ impl<'a> Parser<'a> {
         let mut path = Vec::new();
         loop {
             match self.next_token().token {
+                Token::Colon if path.is_empty() && self.peek_token_ref() == &Token::LBracket => {
+                    self.next_token();
+                    let key = self.parse_wildcard_expr()?;
+                    self.expect_token(&Token::RBracket)?;
+                    path.push(JsonPathElem::ColonBracket { key });
+                }
                 Token::Colon if path.is_empty() => {
-                    if self.peek_token_ref().token == Token::LBracket {
-                        // A bracket element directly after the colon, e.g. `raw:['field']`.
-                        // Push an empty Dot so the display re-emits the leading `:` for syntax roundtrip.
-                        path.push(JsonPathElem::Dot {
-                            key: String::new(),
-                            quoted: false,
-                        });
-                        self.next_token();
-                        let key = self.parse_json_path_bracket_key()?;
-                        self.expect_token(&Token::RBracket)?;
-                        path.push(JsonPathElem::Bracket { key });
-                    } else {
-                        path.push(self.parse_json_path_object_key()?);
-                    }
+                    path.push(self.parse_json_path_object_key()?);
                 }
                 Token::Period if !path.is_empty() => {
                     path.push(self.parse_json_path_object_key()?);
                 }
                 Token::LBracket => {
-                    let key = self.parse_json_path_bracket_key()?;
+                    let key = self.parse_wildcard_expr()?;
                     self.expect_token(&Token::RBracket)?;
 
                     path.push(JsonPathElem::Bracket { key });

tests/sqlparser_databricks.rs

@@ -644,106 +644,4 @@ fn parse_databricks_json_accessor() {
         "SELECT raw:store.bicycle.price::double FROM store_data",
         "SELECT raw:store.bicycle.price::DOUBLE FROM store_data",
     );
-
-    // --- AST structure assertions ---
-
-    // Simple dot access
-    assert_eq!(
-        databricks().verified_expr("raw:owner"),
-        Expr::JsonAccess {
-            value: Box::new(Expr::Identifier(Ident::new("raw"))),
-            path: JsonPath {
-                path: vec![JsonPathElem::Dot {
-                    key: "owner".to_owned(),
-                    quoted: false,
-                }],
-            },
-        }
-    );
-
-    // Multi-level dot access
-    assert_eq!(
-        databricks().verified_expr("raw:store.bicycle"),
-        Expr::JsonAccess {
-            value: Box::new(Expr::Identifier(Ident::new("raw"))),
-            path: JsonPath {
-                path: vec![
-                    JsonPathElem::Dot {
-                        key: "store".to_owned(),
-                        quoted: false,
-                    },
-                    JsonPathElem::Dot {
-                        key: "bicycle".to_owned(),
-                        quoted: false,
-                    },
-                ],
-            },
-        }
-    );
-
-    // Dot path followed by an integer-index bracket
-    assert_eq!(
-        databricks().verified_expr("raw:store.fruit[0]"),
-        Expr::JsonAccess {
-            value: Box::new(Expr::Identifier(Ident::new("raw"))),
-            path: JsonPath {
-                path: vec![
-                    JsonPathElem::Dot {
-                        key: "store".to_owned(),
-                        quoted: false,
-                    },
-                    JsonPathElem::Dot {
-                        key: "fruit".to_owned(),
-                        quoted: false,
-                    },
-                    JsonPathElem::Bracket {
-                        key: Expr::value(number("0")),
-                    },
-                ],
-            },
-        }
-    );
-
-    // [*] is stored as Expr::Wildcard inside a Bracket element
-    assert_eq!(
-        databricks().verified_expr("raw:store.basket[*]"),
-        Expr::JsonAccess {
-            value: Box::new(Expr::Identifier(Ident::new("raw"))),
-            path: JsonPath {
-                path: vec![
-                    JsonPathElem::Dot {
-                        key: "store".to_owned(),
-                        quoted: false,
-                    },
-                    JsonPathElem::Dot {
-                        key: "basket".to_owned(),
-                        quoted: false,
-                    },
-                    JsonPathElem::Bracket {
-                        key: Expr::Wildcard(AttachedToken::empty()),
-                    },
-                ],
-            },
-        }
-    );
-
-    // raw:['OWNER'] — bracket directly after the colon. An empty-key sentinel Dot is prepended
-    // so that the display re-emits the leading `:`, enabling a correct round-trip.
-    assert_eq!(
-        databricks().verified_expr("raw:['OWNER']"),
-        Expr::JsonAccess {
-            value: Box::new(Expr::Identifier(Ident::new("raw"))),
-            path: JsonPath {
-                path: vec![
-                    JsonPathElem::Dot {
-                        key: String::new(),
-                        quoted: false,
-                    },
-                    JsonPathElem::Bracket {
-                        key: Expr::value(Value::SingleQuotedString("OWNER".to_owned())),
-                    },
-                ],
-            },
-        }
-    );
 }