feat: Allow more Function keyword arguments (fixes 2 more Special Oracle tests)

manticore-projects · manticore-projects · commit cd71aada3897 · 2026-03-14T01:41:39.000+07:00
Signed-off-by: Andreas Reichel &lt;andreas@manticore-projects.com&gt;
Signed-off-by: manticore-projects &lt;andreas@manticore-projects.com&gt;
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -8929,7 +8929,7 @@ Function InternalFunction(boolean escaped):
     Limit limit;
     Token extraKeywordToken;
     String keywordArgName;
-    Expression keywordArgExpr;
+    ExpressionList keywordArgExprList;
     List<Function.KeywordArgument> keywordArgs = null;
 }
 {
@@ -8988,16 +8988,21 @@ Function InternalFunction(boolean escaped):
 
     // Generic keyword-argument tail: catches KEYWORD expr pairs that are not
     // consumed by any of the explicit clauses above.
-    // Examples: SEPARATOR ',', USING utf8, DELIMITER CHR(10), FORMAT 'json'
+    // Examples: SEPARATOR ',', USING utf8, DELIMITER CHR(10),
+    //           USING col1, col2, col3 (Oracle Data Mining)
     (
         LOOKAHEAD(2, { isKeywordArgumentAhead() })
         keywordArgName = KeywordArgumentName()
-        keywordArgExpr = SimpleExpression()
+        keywordArgExprList = SimpleExpressionList()
         {
             if (keywordArgs == null) {
                 keywordArgs = new ArrayList<Function.KeywordArgument>();
             }
-            keywordArgs.add(new Function.KeywordArgument(keywordArgName, keywordArgExpr));
+            // Unwrap single-element lists so the API returns the expression directly
+            Expression keywordArgValue = keywordArgExprList.size() == 1
+                    ? (Expression) keywordArgExprList.get(0)
+                    : keywordArgExprList;
+            keywordArgs.add(new Function.KeywordArgument(keywordArgName, keywordArgValue));
         }
     )*
 
diff --git a/src/test/java/net/sf/jsqlparser/expression/FunctionKeywordArgumentTest.java b/src/test/java/net/sf/jsqlparser/expression/FunctionKeywordArgumentTest.java
@@ -10,6 +10,7 @@
 package net.sf.jsqlparser.expression;
 
 import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.statement.Statement;
 import net.sf.jsqlparser.statement.select.PlainSelect;
@@ -247,6 +248,34 @@ static Stream<Arguments> roundtripSqlProvider() {
                         "ALL + ORDER BY + SEPARATOR",
                         "SELECT my_agg(ALL col ORDER BY col SEPARATOR ',') FROM t"),
 
+                // -- Multi-value keyword arguments (USING col1, col2, ...) ---
+                // Oracle Data Mining functions use USING followed by a
+                // comma-separated column list.
+
+                Arguments.of(
+                        "Oracle PREDICTION with COST MODEL and USING column list",
+                        "SELECT PREDICTION(dt_sh_clas_sample COST MODEL USING cust_marital_status, education, household_size) FROM t"),
+
+                Arguments.of(
+                        "Oracle PREDICTION in WHERE clause",
+                        "SELECT cust_gender, COUNT(*) AS cnt FROM mining_data_apply_v WHERE PREDICTION(dt_sh_clas_sample COST MODEL USING cust_marital_status, education, household_size) = 1 GROUP BY cust_gender ORDER BY cust_gender"),
+
+                Arguments.of(
+                        "Oracle PREDICTION_PROBABILITY with USING",
+                        "SELECT PREDICTION_PROBABILITY(my_model USING col1, col2, col3) FROM t"),
+
+                Arguments.of(
+                        "Oracle CLUSTER_ID with USING",
+                        "SELECT CLUSTER_ID(my_model USING col1, col2) FROM t"),
+
+                Arguments.of(
+                        "USING with single column",
+                        "SELECT my_func(model USING col1) FROM t"),
+
+                Arguments.of(
+                        "USING with many columns",
+                        "SELECT my_func(model USING a, b, c, d, e) FROM t"),
+
                 // -- Keyword arg in different SQL contexts -------------------
 
                 Arguments.of(
@@ -291,6 +320,31 @@ void testRoundtrip(String label, String sql) throws JSQLParserException {
                         + "  reparsed:  " + stmt2);
     }
 
+    // ====================================================================
+    // GitHub Issue #688 / #1257 - CONVERT(expr USING charset)
+    // These were ParseExceptions before the generic keyword-arg tail.
+    // ====================================================================
+
+    @Test
+    void testIssue688_ConvertUsingGbk() throws JSQLParserException {
+        // Exact SQL from issue #688 — was a ParseException before
+        String sql = "SELECT * FROM a ORDER BY CONVERT(a.name USING gbk) DESC";
+        Statement stmt = CCJSqlParserUtil.parse(sql);
+        assertNotNull(stmt);
+        // Roundtrip
+        String deparsed = stmt.toString();
+        assertEquals(deparsed, CCJSqlParserUtil.parse(deparsed).toString());
+    }
+
+    @Test
+    void testIssue1257_ConvertUsingGBK() throws JSQLParserException {
+        // Exact SQL from issue #1257
+        String sql =
+                "SELECT id, name FROM tbl_template WHERE name LIKE ? ORDER BY CONVERT(name USING GBK) ASC";
+        Statement stmt = CCJSqlParserUtil.parse(sql);
+        assertNotNull(stmt);
+    }
+
     // ====================================================================
     // GROUP_CONCAT migration - now parsed as Function, not MySQLGroupConcat
     // ====================================================================
@@ -388,6 +442,31 @@ void testMultipleKeywordArguments() throws JSQLParserException {
         assertEquals("'utf8'", kwArgs.get(1).getExpression().toString());
     }
 
+    @Test
+    void testMultiValueKeywordArgument_OraclePrediction() throws JSQLParserException {
+        String sql = "SELECT PREDICTION(my_model COST MODEL USING col1, col2, col3) FROM t";
+        Statement stmt = CCJSqlParserUtil.parse(sql);
+        Function func = extractFirstFunction(stmt);
+
+        assertNotNull(func);
+        assertEquals("PREDICTION", func.getName());
+
+        List<Function.KeywordArgument> kwArgs = func.getKeywordArguments();
+        assertNotNull(kwArgs);
+        assertEquals(2, kwArgs.size());
+
+        // COST MODEL — single value, unwrapped to Column
+        assertEquals("COST", kwArgs.get(0).getKeyword().toUpperCase());
+        assertEquals("MODEL", kwArgs.get(0).getExpression().toString());
+
+        // USING col1, col2, col3 — multi-value, kept as ExpressionList
+        assertEquals("USING", kwArgs.get(1).getKeyword().toUpperCase());
+        Expression usingExpr = kwArgs.get(1).getExpression();
+        assertInstanceOf(ExpressionList.class,
+                usingExpr, "Multi-value keyword arg should be an ExpressionList");
+        assertEquals("col1, col2, col3", usingExpr.toString());
+    }
+
     @Test
     void testGetKeywordArgumentValue() throws JSQLParserException {
         String sql = "SELECT my_agg(col SEPARATOR ',' ENCODING 'utf8') FROM t";
diff --git a/src/test/java/net/sf/jsqlparser/statement/select/SpecialOracleTest.java b/src/test/java/net/sf/jsqlparser/statement/select/SpecialOracleTest.java
@@ -90,7 +90,7 @@ public class SpecialOracleTest {
             "for_update01.sql", "for_update02.sql", "for_update03.sql", "function04.sql",
             "function05.sql", "for_update04.sql", "for_update05.sql", "for_update06.sql",
             "function01.sql", "function02.sql", "function03.sql",
-            "function06.sql",
+            "function06.sql", "function07.sql",
             "groupby01.sql",
             "groupby02.sql", "groupby03.sql", "groupby04.sql", "groupby05.sql", "groupby06.sql",
             "groupby08.sql", "groupby09.sql", "groupby10.sql", "groupby11.sql", "groupby12.sql",
@@ -119,7 +119,7 @@ public class SpecialOracleTest {
             "simple07.sql", "simple08.sql", "simple09.sql", "simple10.sql", "simple11.sql",
             "simple12.sql", "simple13.sql", "union01.sql", "union02.sql", "union03.sql",
             "union04.sql", "union05.sql", "union06.sql", "union07.sql", "union08.sql",
-            "union09.sql", "union10.sql", "xmltable02.sql");
+            "union09.sql", "union10.sql", "xmltable01.sql", "xmltable02.sql");
 
     @Test
     public void testAllSqlsParseDeparse() throws IOException {
diff --git a/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/function07.sql b/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/function07.sql
@@ -19,4 +19,5 @@ select cust_gender, count(*) as cnt, round(avg(age)) as avg_age
 --@FAILURE: Encountered: "(" / "(", at line 12, column 20, in lexical state DEFAULT. recorded first on 15 May 2025, 16:24:08
 --@FAILURE: Encountered: <OPENING_BRACKET> / "(", at line 12, column 20, in lexical state DEFAULT. recorded first on 9 Jul 2025, 17:09:17
 --@FAILURE: Encountered: <S_IDENTIFIER> / "cost", at line 12, column 39, in lexical state DEFAULT. recorded first on 12 Mar 2026, 20:27:52
---@FAILURE: Encountered: <K_COMMA> / ",", at line 13, column 32, in lexical state DEFAULT. recorded first on 13 Mar 2026, 20:40:43
+--@FAILURE: Encountered: <K_COMMA> / ",", at line 13, column 32, in lexical state DEFAULT. recorded first on 13 Mar 2026, 20:40:43
+--@SUCCESSFULLY_PARSED_AND_DEPARSED first on 14 Mar 2026, 01:34:50
diff --git a/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/xmltable01.sql b/src/test/resources/net/sf/jsqlparser/statement/select/oracle-tests/xmltable01.sql
@@ -18,4 +18,5 @@ warehouse2
 
 --@FAILURE: Encountered unexpected token: "(" "(" recorded first on Aug 3, 2021, 7:20:08 AM
 --@FAILURE: Encountered: "(" / "(", at line 12, column 10, in lexical state DEFAULT. recorded first on 15 May 2025, 16:24:09
---@FAILURE: Encountered: <OPENING_BRACKET> / "(", at line 12, column 10, in lexical state DEFAULT. recorded first on 9 Jul 2025, 17:09:18
+--@FAILURE: Encountered: <OPENING_BRACKET> / "(", at line 12, column 10, in lexical state DEFAULT. recorded first on 9 Jul 2025, 17:09:18
+--@SUCCESSFULLY_PARSED_AND_DEPARSED first on 14 Mar 2026, 01:34:50

Original file line number	Diff line number	Diff line change
`@@ -8929,7 +8929,7 @@ Function InternalFunction(boolean escaped):`
`8929`	`8929`	`Limit limit;`
`8930`	`8930`	`Token extraKeywordToken;`
`8931`	`8931`	`String keywordArgName;`
`8932`		`- Expression keywordArgExpr;`
	`8932`	`+ ExpressionList keywordArgExprList;`
`8933`	`8933`	`List<Function.KeywordArgument> keywordArgs = null;`
`8934`	`8934`	`}`
`8935`	`8935`	`{`
`@@ -8988,16 +8988,21 @@ Function InternalFunction(boolean escaped):`
`8988`	`8988`
`8989`	`8989`	`// Generic keyword-argument tail: catches KEYWORD expr pairs that are not`
`8990`	`8990`	`// consumed by any of the explicit clauses above.`
`8991`		`- // Examples: SEPARATOR ',', USING utf8, DELIMITER CHR(10), FORMAT 'json'`
	`8991`	`+ // Examples: SEPARATOR ',', USING utf8, DELIMITER CHR(10),`
	`8992`	`+ // USING col1, col2, col3 (Oracle Data Mining)`
`8992`	`8993`	`(`
`8993`	`8994`	`LOOKAHEAD(2, { isKeywordArgumentAhead() })`
`8994`	`8995`	`keywordArgName = KeywordArgumentName()`
`8995`		`- keywordArgExpr = SimpleExpression()`
	`8996`	`+ keywordArgExprList = SimpleExpressionList()`
`8996`	`8997`	`{`
`8997`	`8998`	`if (keywordArgs == null) {`
`8998`	`8999`	`keywordArgs = new ArrayList<Function.KeywordArgument>();`
`8999`	`9000`	`}`
`9000`		`- keywordArgs.add(new Function.KeywordArgument(keywordArgName, keywordArgExpr));`
	`9001`	`+ // Unwrap single-element lists so the API returns the expression directly`
	`9002`	`+ Expression keywordArgValue = keywordArgExprList.size() == 1`
	`9003`	`+ ? (Expression) keywordArgExprList.get(0)`
	`9004`	`+ : keywordArgExprList;`
	`9005`	`+ keywordArgs.add(new Function.KeywordArgument(keywordArgName, keywordArgValue));`
`9001`	`9006`	`}`
`9002`	`9007`	`)*`
`9003`	`9008`