fix: allow keywords after a dot in Snowflake JSON paths and link their AST nodes

The previous commit lets a keyword name the first element after ":" in a
JSON path. A keyword further along the path still threw a ParseException:

  SELECT v:a.output, v:a.b.from::INT, v:a[0].from.x[1] FROM t

The expression parser reads v:a.output as a qualified column name, and a
qualified name does not accept a keyword as a part. JsonPathElement now
also looks ahead with isJsonPathWithKeywordAfterDot(), which walks the
identifiers, dots and [...] subscripts of the path and reports whether a
keyword follows a ".". If so, JsonPathKeyword parses the path, with a new
JsonPathStep production taking a keyword after "." as an element name.
isKeywordJsonPathName() shares its keyword test with it through
isKeywordWord(). A word followed by "(" stays a function call, and
t.output outside a JSON path is still rejected.

JsonPathKeyword also left the last step or cast of a path without an AST
node, for example the cast in v:select::INT or v:from::INT + 1. It linked
the previous element before building each step, so the one built last was
never linked. ASTNodeCoverageTest did not notice, as it only walks the SQL
resources. Each step and cast is now linked where it is built, and the
keyword-path cases are added to testStatementsTheCorpusLacks.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Author: harryfoster2006

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -1093,14 +1093,21 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
      */
     private boolean isKeywordJsonPathName() {
         Token colon = getToken(0);
-        Token word = getToken(1);
-        if (colon == null || !":".equals(colon.image) || word.image == null
-                || word.kind == S_IDENTIFIER || word.kind == S_QUOTED_IDENTIFIER
-                || "(".equals(getToken(2).image)) {
+        return colon != null && ":".equals(colon.image) && isKeywordWord(1);
+    }
+
+    /**
+     * Whether the token at the given position is a word that is no identifier token, i.e. a keyword,
+     * and not the name of a function call.
+     */
+    private boolean isKeywordWord(int position) {
+        Token word = getToken(position);
+        if (word.image == null || word.kind == S_IDENTIFIER || word.kind == S_QUOTED_IDENTIFIER
+                || "(".equals(getToken(position + 1).image)) {
             return false;
         }
         String image = word.image;
-        if (!Character.isLetter(image.charAt(0)) && image.charAt(0) != '_') {
+        if (image.isEmpty() || (!Character.isLetter(image.charAt(0)) && image.charAt(0) != '_')) {
             return false;
         }
         for (int i = 1; i < image.length(); i++) {
@@ -1111,6 +1118,51 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         return true;
     }
 
+    /**
+     * Whether the path after the ":" of a JSON path, which starts with an identifier, goes on with a
+     * keyword after a ".", e.g. v:a.output or v:a[0].b.from. The expression parser would read such a
+     * path as a qualified column name, which does not take a keyword as a part.
+     */
+    private boolean isJsonPathWithKeywordAfterDot() {
+        Token colon = getToken(0);
+        if (colon == null || !":".equals(colon.image)) {
+            return false;
+        }
+        Token first = getToken(1);
+        if (first.kind != S_IDENTIFIER && first.kind != S_QUOTED_IDENTIFIER) {
+            return false;
+        }
+        int position = 2;
+        while (true) {
+            Token token = getToken(position);
+            if (".".equals(token.image)) {
+                if (isKeywordWord(position + 1)) {
+                    return true;
+                }
+                Token name = getToken(position + 1);
+                if (name.kind != S_IDENTIFIER && name.kind != S_QUOTED_IDENTIFIER) {
+                    return false;
+                }
+                position += 2;
+            } else if ("[".equals(token.image)) {
+                int depth = 0;
+                do {
+                    token = getToken(position);
+                    if ("[".equals(token.image)) {
+                        depth++;
+                    } else if ("]".equals(token.image)) {
+                        depth--;
+                    } else if (token.kind == EOF) {
+                        return false;
+                    }
+                    position++;
+                } while (depth > 0);
+            } else {
+                return false;
+            }
+        }
+    }
+
     private boolean isPostgreSqlJsonAccess(Token token) {
         return ("->".equals(token.image) || "->>".equals(token.image)
                 || "#>".equals(token.image) || "#>>".equals(token.image))
@@ -14976,7 +15028,7 @@ Expression JsonPathElement() #void:
 { Expression element; }
 {
     (
-        LOOKAHEAD({ isKeywordJsonPathName() }) element=JsonPathKeyword()
+        LOOKAHEAD({ isKeywordJsonPathName() || isJsonPathWithKeywordAfterDot() }) element=JsonPathKeyword()
         |
         LOOKAHEAD({getAsBoolean(Feature.allowComplexParsing) && !interrupted}) element=Expression()
         |
@@ -15004,14 +15056,14 @@ Expression JsonPathKeyword() #void:
         keyword = getNextToken();
         element = linkToLastToken(new Column(keyword.image));
     }
-    ( LOOKAHEAD(2) { linkASTIfMissing(element, first); } step=NavigationStep(element) { element = step; } )*
+    ( LOOKAHEAD(2) step=JsonPathStep(element) { element = linked(step, first); } )*
     (
-        LOOKAHEAD(2) { linkASTIfMissing(element, first); } "::" type=ColDataType() {
+        LOOKAHEAD(2) "::" type=ColDataType() {
             cast = new CastExpression();
             cast.setUseCastKeyword(false);
             cast.setLeftExpression(element);
             cast.setColDataType(type);
-            element = cast;
+            element = linked(cast, first);
         }
     )*
     {
@@ -15020,6 +15072,23 @@ Expression JsonPathKeyword() #void:
     }
 }
 
+/**
+ * A navigation step within a JSON path, where a keyword after a "." names a path element as well:
+ * v:a.output, v:a[0].from.
+ */
+Expression JsonPathStep(Expression base) #void:
+{ Expression step; }
+{
+    (
+        LOOKAHEAD({ ".".equals(getToken(1).image) && isKeywordWord(2) }) "." {
+            step = new RowGetExpression(base, getNextToken().image);
+        }
+        |
+        step=NavigationStep(base)
+    )
+    { return step; }
+}
+
 JsonExpression JsonExpression(Expression expr, List<Map.Entry<Expression, String>> idents) : {
   JsonExpression result = new JsonExpression(expr, idents);
   Expression expression;

src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java

@@ -112,6 +112,36 @@ void testKeywordPathNameInsideNestedConstructs(String sql) throws JSQLParserExce
         assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SNOWFLAKE));
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {"select", "from", "where", "join", "union", "and", "or", "not", "case",
+            "when", "else", "as", "is", "like", "having", "distinct", "inner", "into", "with",
+            "outer", "cross", "using", "output", "null", "true", "false", "order", "group"})
+    void testSnowflakeKeywordAfterDotInPath(String keyword) throws JSQLParserException {
+        String sqlStr = "SELECT v:a." + keyword + ", v:a.b." + keyword + "::INT, v:a[0]." + keyword
+                + ".x[1] FROM vartab";
+        PlainSelect st = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        for (int i = 0; i < 3; i++) {
+            Assertions.assertInstanceOf(JsonExpression.class, st.getSelectItem(i).getExpression());
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "SELECT v:a.output + 1, \"F\".\"X\":\"a\".from::VARIANT AS y FROM t F",
+            "SELECT * FROM t WHERE v:payload.output::INT = 1 ORDER BY v:payload.from",
+            "SELECT v:a.output FROM t, lateral flatten(input => t.v:a.input.where) f"})
+    void testKeywordAfterDotInPathInContext(String sql) throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed(sql, true, parser -> parser.withDialect(Dialect.SNOWFLAKE));
+    }
+
+    @Test
+    void testKeywordAfterDotOutsideJsonPathIsStillRejected() {
+        // a reserved word is not a part of a qualified name, only of a JSON path
+        Assertions.assertThrows(JSQLParserException.class,
+                () -> CCJSqlParserUtil.parse("SELECT t.output FROM t",
+                        parser -> parser.withDialect(Dialect.SNOWFLAKE)));
+    }
+
     @Test
     void testKeywordFollowedByParenthesisStaysFunction() throws JSQLParserException {
         // only parsing is asserted: a function behind ":" deparses with "."

src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java

@@ -171,6 +171,12 @@ public void testStatementsTheCorpusLacks() throws JSQLParserException {
                 "DELETE FROM t USING s JOIN u ON s.id = u.id, v WHERE t.id = s.id"}) {
             new Walk(sql, sql, problems).check(CCJSqlParserUtil.parseStatements(sql));
         }
+        for (String sql : new String[] {"SELECT v:select FROM t", "SELECT v:select::INT FROM t",
+                "SELECT v:select.x[0], v:from::INT + 1 FROM t",
+                "SELECT v:a.output, v:a.b.from::INT, v:a[0].from.x[1] + 1 FROM t"}) {
+            new Walk(sql, sql, problems).check(CCJSqlParserUtil.parseStatements(sql,
+                    parser -> parser.withDialect(AbstractJSqlParser.Dialect.SNOWFLAKE)));
+        }
         String block = "BEGIN x := 1; NULL; foo(1); END;";
         new Walk(block, block, problems).check(CCJSqlParserUtil.parseStatements(block,
                 parser -> parser.withDialect(AbstractJSqlParser.Dialect.ORACLE)));