feat: Clickhouse GLOBAL IN ...

manticore-projects · manticore-projects · commit ced0d0090c5c · 2023-09-12T15:54:04.000+07:00
- sourced from https://github.com/herbert2008/JSqlParser/tree/clickhouse_global_in - resolves PR #1794
diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/relational/InExpression.java b/src/main/java/net/sf/jsqlparser/expression/operators/relational/InExpression.java
@@ -17,6 +17,7 @@ public class InExpression extends ASTNodeAccessImpl
         implements Expression, SupportsOldOracleJoinSyntax {
 
     private Expression leftExpression;
+    private boolean global = false;
     private boolean not = false;
     private Expression rightExpression;
     private int oldOracleJoinSyntax = NO_ORACLE_JOIN;
@@ -56,6 +57,15 @@ public final void setLeftExpression(Expression expression) {
         leftExpression = expression;
     }
 
+    public boolean isGlobal() {
+        return global;
+    }
+
+    public InExpression setGlobal(boolean b) {
+        global = b;
+        return this;
+    }
+
     public boolean isNot() {
         return not;
     }
@@ -87,6 +97,9 @@ public String toString() {
         statementBuilder.append(getLeftExpressionString());
 
         statementBuilder.append(" ");
+        if (global) {
+            statementBuilder.append("GLOBAL ");
+        }
         if (not) {
             statementBuilder.append("NOT ");
         }
@@ -124,6 +137,11 @@ public InExpression withOraclePriorPosition(int priorPosition) {
         return this;
     }
 
+    public InExpression withGlobal(boolean global) {
+        this.setGlobal(global);
+        return this;
+    }
+
     public InExpression withNot(boolean not) {
         this.setNot(not);
         return this;
diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java
@@ -247,6 +247,9 @@ public void visit(InExpression inExpression) {
                 .getOldOracleJoinSyntax() == SupportsOldOracleJoinSyntax.ORACLE_JOIN_RIGHT) {
             buffer.append("(+)");
         }
+        if (inExpression.isGlobal()) {
+            buffer.append(" GLOBAL");
+        }
         if (inExpression.isNot()) {
             buffer.append(" NOT");
         }
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -3464,15 +3464,18 @@ Expression InExpression() #InExpression :
 {
     Token token;
     int oldOracleJoin = 0;
-    boolean usesNot = false;
+    boolean usingNot = false;
+    boolean usingGlobal = false;
     Expression leftExpression;
     Expression rightExpression;
 }
 {
     leftExpression=SimpleExpression()
     [ "(" "+" ")" { oldOracleJoin=EqualsTo.ORACLE_JOIN_RIGHT; } ]
 
-    [<K_NOT> { usesNot=true; } ] <K_IN>
+    [<K_GLOBAL> { usingGlobal=true; } ]
+    [<K_NOT> { usingNot=true; } ]
+    <K_IN>
     (
         LOOKAHEAD(2) token=<S_CHAR_LITERAL> {  rightExpression = new StringValue(token.image); }
         | LOOKAHEAD(3) rightExpression = Function()
@@ -3483,7 +3486,8 @@ Expression InExpression() #InExpression :
     {
         InExpression inExpression =  new InExpression(leftExpression, rightExpression)
                                                 .withOldOracleJoinSyntax(oldOracleJoin)
-                                                .withNot(usesNot);
+                                                .withNot(usingNot)
+                                                .setGlobal(usingGlobal);
         linkAST(inExpression,jjtThis);
         return inExpression;
     }
diff --git a/src/test/java/net/sf/jsqlparser/statement/select/ClickHouseTest.java b/src/test/java/net/sf/jsqlparser/statement/select/ClickHouseTest.java
@@ -10,7 +10,6 @@
 package net.sf.jsqlparser.statement.select;
 
 import net.sf.jsqlparser.JSQLParserException;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
@@ -37,33 +36,9 @@ public void testFunctionWithAttributesIssue1742() throws JSQLParserException {
     }
 
     @Test
-    public void testSelectUsingFinal() throws JSQLParserException {
-        String sqlStr = "SELECT column FROM table_name AS tn FINAL";
-        assertSqlCanBeParsedAndDeparsed(sqlStr, true);
-
-        // check that FINAL is reserved keyword and won't be read as an Alias
-        sqlStr = "SELECT column FROM table_name FINAL";
-        PlainSelect select = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sqlStr, true);
-
-        Assertions.assertTrue(select.isUsingFinal());
-        Assertions.assertFalse(select.withUsingFinal(false).toString().contains("FINAL"));
-    }
-
-    @Test
-    public void testLimitBy() throws JSQLParserException {
-        String sqlStr = "SELECT * FROM limit_by ORDER BY id, val LIMIT 1, 2 BY id";
-        assertSqlCanBeParsedAndDeparsed(sqlStr, true);
-
-        sqlStr = "SELECT\n"
-                + "    domainWithoutWWW(URL) AS domain,\n"
-                + "    domainWithoutWWW(REFERRER_URL) AS referrer,\n"
-                + "    device_type,\n"
-                + "    count() cnt\n"
-                + "FROM hits\n"
-                + "GROUP BY domain, referrer, device_type\n"
-                + "ORDER BY cnt DESC\n"
-                + "LIMIT 5 BY domain, device_type\n"
-                + "LIMIT 100";
-        assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+    public void testGlobalIn() throws JSQLParserException {
+        String sql =
+                "SELECT lo_linenumber,lo_orderkey from lo_linenumber where lo_linenumber global in (1,2,3)";
+        assertSqlCanBeParsedAndDeparsed(sql, true);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -247,6 +247,9 @@ public void visit(InExpression inExpression) {`
`247`	`247`	`.getOldOracleJoinSyntax() == SupportsOldOracleJoinSyntax.ORACLE_JOIN_RIGHT) {`
`248`	`248`	`buffer.append("(+)");`
`249`	`249`	`}`
	`250`	`+ if (inExpression.isGlobal()) {`
	`251`	`+ buffer.append(" GLOBAL");`
	`252`	`+ }`
`250`	`253`	`if (inExpression.isNot()) {`
`251`	`254`	`buffer.append(" NOT");`
`252`	`255`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3464,15 +3464,18 @@ Expression InExpression() #InExpression :`
`3464`	`3464`	`{`
`3465`	`3465`	`Token token;`
`3466`	`3466`	`int oldOracleJoin = 0;`
`3467`		`- boolean usesNot = false;`
	`3467`	`+ boolean usingNot = false;`
	`3468`	`+ boolean usingGlobal = false;`
`3468`	`3469`	`Expression leftExpression;`
`3469`	`3470`	`Expression rightExpression;`
`3470`	`3471`	`}`
`3471`	`3472`	`{`
`3472`	`3473`	`leftExpression=SimpleExpression()`
`3473`	`3474`	`[ "(" "+" ")" { oldOracleJoin=EqualsTo.ORACLE_JOIN_RIGHT; } ]`
`3474`	`3475`
`3475`		`- [<K_NOT> { usesNot=true; } ] <K_IN>`
	`3476`	`+ [<K_GLOBAL> { usingGlobal=true; } ]`
	`3477`	`+ [<K_NOT> { usingNot=true; } ]`
	`3478`	`+ <K_IN>`
`3476`	`3479`	`(`
`3477`	`3480`	`LOOKAHEAD(2) token=<S_CHAR_LITERAL> { rightExpression = new StringValue(token.image); }`
`3478`	`3481`	`\| LOOKAHEAD(3) rightExpression = Function()`
`@@ -3483,7 +3486,8 @@ Expression InExpression() #InExpression :`
`3483`	`3486`	`{`
`3484`	`3487`	`InExpression inExpression = new InExpression(leftExpression, rightExpression)`
`3485`	`3488`	`.withOldOracleJoinSyntax(oldOracleJoin)`
`3486`		`- .withNot(usesNot);`
	`3489`	`+ .withNot(usingNot)`
	`3490`	`+ .setGlobal(usingGlobal);`
`3487`	`3491`	`linkAST(inExpression,jjtThis);`
`3488`	`3492`	`return inExpression;`
`3489`	`3493`	`}`