Support standalone SEMI and ANTI joins

DuckDB allows SEMI/ANTI JOIN without a LEFT prefix, and ANTI as a join
type at all. ANTI previously parsed silently as a table alias, producing
a wrong AST from valid SQL. Adds Join.isAnti(), the LEFT/RIGHT/FULL
SEMI|ANTI prefixes and the standalone form, keeping ANTI usable as an
identifier outside a join prefix.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EqinwHBKuAtPEmtXr3b5P2

Author: hayssams

src/main/java/net/sf/jsqlparser/parser/feature/Feature.java

@@ -182,6 +182,10 @@ public enum Feature {
      * "SEMI" join
      */
     joinSemi,
+    /**
+     * @see net.sf.jsqlparser.statement.select.Join#isAnti()
+     */
+    joinAnti,
     /**
      * "INNER" join
      */

src/main/java/net/sf/jsqlparser/statement/select/Join.java

@@ -36,6 +36,7 @@ public class Join extends ASTNodeAccessImpl {
     private boolean simple = false;
     private boolean cross = false;
     private boolean semi = false;
+    private boolean anti = false;
     private boolean any = false;
     private boolean all = false;
     private boolean straight = false;
@@ -194,6 +195,19 @@ public Join withFetch(boolean b) {
      *
      * @return true if is a "SEMI" join
      */
+    public boolean isAnti() {
+        return anti;
+    }
+
+    public void setAnti(boolean b) {
+        anti = b;
+    }
+
+    public Join withAnti(boolean b) {
+        this.setAnti(b);
+        return this;
+    }
+
     public boolean isSemi() {
         return semi;
     }
@@ -511,6 +525,8 @@ public StringBuilder appendJoinTypeTo(StringBuilder builder) {
             builder.append("INNER ");
         } else if (isSemi()) {
             builder.append("SEMI ");
+        } else if (isAnti()) {
+            builder.append("ANTI ");
         }
 
         if (isArray()) {

src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java

@@ -59,6 +59,7 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS
             Feature.joinCross,
             Feature.joinOuter,
             Feature.joinSemi,
+            Feature.joinAnti,
             Feature.joinInner,
             Feature.joinStraight,
             Feature.joinApply,

src/main/java/net/sf/jsqlparser/util/validation/validator/SelectValidator.java

@@ -328,6 +328,7 @@ public void validateOptionalJoin(Join join) {
             validateFeature(c, join.isOuter(), Feature.joinOuter);
             validateFeature(c, join.isInner(), Feature.joinInner);
             validateFeature(c, join.isSemi(), Feature.joinSemi);
+            validateFeature(c, join.isAnti(), Feature.joinAnti);
             validateFeature(c, join.isStraight(), Feature.joinStraight);
             validateFeature(c, join.isApply(), Feature.joinApply);
             validateFeature(c, join.isAsOf(), Feature.joinAsOf);

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

@@ -1063,9 +1063,11 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             case K_CONNECT:  return nextKind != K_BY;
             case K_START:    return nextKind != K_WITH;
             case K_LEFT:     return nextKind != K_JOIN && nextKind != K_OUTER
-                                    && nextKind != K_SEMI && nextKind != K_ARRAY_LITERAL;
+                                    && nextKind != K_SEMI && nextKind != K_ANTI
+                                    && nextKind != K_ARRAY_LITERAL;
             case K_RIGHT:    return nextKind != K_JOIN && nextKind != K_OUTER
-                                    && nextKind != K_SEMI && nextKind != K_ARRAY_LITERAL;
+                                    && nextKind != K_SEMI && nextKind != K_ANTI
+                                    && nextKind != K_ARRAY_LITERAL;
             case K_ARRAY_LITERAL:
                              return nextKind != K_JOIN;
             case K_ALL:      return nextKind != K_JOIN;
@@ -1209,6 +1211,15 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         return isReservedKeywordSafeByFollower();
     }
 
+    /** SEMI/ANTI stay contextual identifiers unless they prefix a JOIN. */
+    private boolean isSemiAntiJoinAhead() {
+        int kind = getToken(1).kind;
+        if (kind != K_SEMI && kind != K_ANTI) {
+            return false;
+        }
+        return getToken(2).kind == K_JOIN;
+    }
+
     /** ASOF stays a contextual identifier outside a join prefix. */
     private boolean isAsOfJoinAhead() {
         if (!isKeywordAhead("ASOF")) {
@@ -1238,7 +1249,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
      * reserved keywords.
      */
     private boolean isAliasAhead() {
-        if (isAsOfJoinAhead()) {
+        if (isAsOfJoinAhead() || isSemiAntiJoinAhead()) {
             return false;
         }
         Token t = getToken(1);
@@ -1930,6 +1941,7 @@ String NonReservedWord() :
       | tk=<K_ALWAYS:"ALWAYS">
       | tk=<K_ANALYSE:"ANALYSE">
       | tk=<K_ANALYZE:"ANALYZE">
+      | tk=<K_ANTI:"ANTI">
       | tk=<K_APPEND_ONLY:"APPEND_ONLY">
       | tk=<K_APPLY:"APPLY">
       | tk=<K_APPROXIMATE:"APPROXIMATE">
@@ -7735,15 +7747,19 @@ Join JoinerExpression() #JoinerExpression:
 
     [
         (
-            <K_LEFT> { join.setLeft(true); } [ <K_SEMI> { join.setSemi(true); } | <K_OUTER> { join.setOuter(true); } | <K_ANY> { join.setAny(true); } | <K_ALL> { join.setAll(true); } ]
+            <K_LEFT> { join.setLeft(true); } [ <K_SEMI> { join.setSemi(true); } | <K_ANTI> { join.setAnti(true); } | <K_OUTER> { join.setOuter(true); } | <K_ANY> { join.setAny(true); } | <K_ALL> { join.setAll(true); } ]
             |
             (
                 <K_RIGHT> { join.setRight(true); }
                 |
                 <K_FULL> { join.setFull(true); }
-            ) [ <K_OUTER> { join.setOuter(true); } | <K_ANY> { join.setAny(true); } | <K_ALL> { join.setAll(true); } ]
+            ) [ <K_SEMI> { join.setSemi(true); } | <K_ANTI> { join.setAnti(true); } | <K_OUTER> { join.setOuter(true); } | <K_ANY> { join.setAny(true); } | <K_ALL> { join.setAll(true); } ]
             |
             <K_INNER> { join.setInner(true); }
+            |
+            // DuckDB allows SEMI/ANTI without a LEFT prefix
+            LOOKAHEAD({ isSemiAntiJoinAhead() })
+            ( <K_SEMI> { join.setSemi(true); } | <K_ANTI> { join.setAnti(true); } )
         )
         |
         <K_CROSS> { join.setCross(true); }

src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java

@@ -54,4 +54,41 @@ void testGlobRemainsUsableAsIdentifier() throws JSQLParserException {
         String sqlStr = "SELECT glob FROM t";
         TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
     }
+
+    @Test
+    void testSemiJoinWithoutLeft() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM t SEMI JOIN u USING (id)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        Join join = select.getJoins().get(0);
+
+        Assertions.assertTrue(join.isSemi());
+        Assertions.assertFalse(join.isLeft());
+        Assertions.assertNull(((Table) select.getFromItem()).getAlias());
+    }
+
+    @Test
+    void testAntiJoinWithoutLeft() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM t ANTI JOIN u ON t.id = u.id";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        Join join = select.getJoins().get(0);
+
+        Assertions.assertTrue(join.isAnti());
+        Assertions.assertNull(((Table) select.getFromItem()).getAlias());
+    }
+
+    @Test
+    void testLeftAntiJoin() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM t LEFT ANTI JOIN u ON t.id = u.id";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        Join join = select.getJoins().get(0);
+
+        Assertions.assertTrue(join.isLeft());
+        Assertions.assertTrue(join.isAnti());
+    }
+
+    @Test
+    void testAntiRemainsUsableAsIdentifier() throws JSQLParserException {
+        String sqlStr = "SELECT anti FROM t anti";
+        TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+    }
 }