Support DuckDB syntax: FROM-first, SEMI/ANTI joins, COPY, ATTACH, MACRO, PRAGMA and DuckDB 2.0 additions

src/main/java/net/sf/jsqlparser/expression/operators/relational/LikeExpression.java

@@ -119,7 +119,7 @@ public LikeExpression withRightExpression(Expression arg0) {
     }
 
     public enum KeyWord {
-        LIKE, ILIKE, RLIKE, REGEXP_LIKE, REGEXP, SIMILAR_TO, MATCH_ANY, MATCH_ALL, MATCH_PHRASE, MATCH_PHRASE_PREFIX, MATCH_REGEXP;
+        LIKE, ILIKE, RLIKE, REGEXP_LIKE, REGEXP, GLOB, SIMILAR_TO, MATCH_ANY, MATCH_ALL, MATCH_PHRASE, MATCH_PHRASE_PREFIX, MATCH_REGEXP;
 
         public static KeyWord from(String keyword) {
             return Enum.valueOf(KeyWord.class,

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/AttachStatement.java

@@ -0,0 +1,121 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+import net.sf.jsqlparser.statement.select.PlainSelect;
+
+import java.util.List;
+
+/**
+ * DuckDB's {@code ATTACH [DATABASE] [IF NOT EXISTS] path [AS alias] [(options)]}, which adds
+ * another database file or remote database to the session.
+ *
+ * @see <a href="https://duckdb.org/docs/stable/sql/statements/attach">ATTACH</a>
+ */
+public class AttachStatement implements Statement {
+    private String databasePath;
+    private String alias;
+    private boolean usingDatabaseKeyword;
+    private boolean ifNotExists;
+    private List<String> options;
+
+    public String getDatabasePath() {
+        return databasePath;
+    }
+
+    public void setDatabasePath(String databasePath) {
+        this.databasePath = databasePath;
+    }
+
+    public AttachStatement withDatabasePath(String databasePath) {
+        setDatabasePath(databasePath);
+        return this;
+    }
+
+    public String getAlias() {
+        return alias;
+    }
+
+    public void setAlias(String alias) {
+        this.alias = alias;
+    }
+
+    public AttachStatement withAlias(String alias) {
+        setAlias(alias);
+        return this;
+    }
+
+    public boolean isUsingDatabaseKeyword() {
+        return usingDatabaseKeyword;
+    }
+
+    public void setUsingDatabaseKeyword(boolean usingDatabaseKeyword) {
+        this.usingDatabaseKeyword = usingDatabaseKeyword;
+    }
+
+    public AttachStatement withUsingDatabaseKeyword(boolean usingDatabaseKeyword) {
+        setUsingDatabaseKeyword(usingDatabaseKeyword);
+        return this;
+    }
+
+    public boolean isIfNotExists() {
+        return ifNotExists;
+    }
+
+    public void setIfNotExists(boolean ifNotExists) {
+        this.ifNotExists = ifNotExists;
+    }
+
+    public AttachStatement withIfNotExists(boolean ifNotExists) {
+        setIfNotExists(ifNotExists);
+        return this;
+    }
+
+    public List<String> getOptions() {
+        return options;
+    }
+
+    public void setOptions(List<String> options) {
+        this.options = options;
+    }
+
+    public AttachStatement withOptions(List<String> options) {
+        setOptions(options);
+        return this;
+    }
+
+    public StringBuilder appendTo(StringBuilder builder) {
+        builder.append("ATTACH ");
+        if (usingDatabaseKeyword) {
+            builder.append("DATABASE ");
+        }
+        if (ifNotExists) {
+            builder.append("IF NOT EXISTS ");
+        }
+        builder.append(databasePath);
+        if (alias != null) {
+            builder.append(" AS ").append(alias);
+        }
+        if (options != null && !options.isEmpty()) {
+            builder.append(" ").append(PlainSelect.getStringList(options, true, true));
+        }
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+}

src/main/java/net/sf/jsqlparser/statement/ConnectStatement.java

@@ -0,0 +1,69 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+/**
+ * DuckDB's {@code CONNECT target [AS alias]}, which routes the session's queries to a remote
+ * database.
+ */
+public class ConnectStatement implements Statement {
+    private String target;
+    private String alias;
+
+    public ConnectStatement() {}
+
+    public ConnectStatement(String target) {
+        this.target = target;
+    }
+
+    public String getTarget() {
+        return target;
+    }
+
+    public void setTarget(String target) {
+        this.target = target;
+    }
+
+    public ConnectStatement withTarget(String target) {
+        setTarget(target);
+        return this;
+    }
+
+    public String getAlias() {
+        return alias;
+    }
+
+    public void setAlias(String alias) {
+        this.alias = alias;
+    }
+
+    public ConnectStatement withAlias(String alias) {
+        setAlias(alias);
+        return this;
+    }
+
+    public StringBuilder appendTo(StringBuilder builder) {
+        builder.append("CONNECT ").append(target);
+        if (alias != null) {
+            builder.append(" AS ").append(alias);
+        }
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+}

src/main/java/net/sf/jsqlparser/statement/CopyStatement.java

@@ -0,0 +1,139 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2026 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
+package net.sf.jsqlparser.statement;
+
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.select.PlainSelect;
+import net.sf.jsqlparser.statement.select.Select;
+
+import java.util.List;
+
+/**
+ * {@code COPY table [(columns)] FROM path [(options)]} and
+ * {@code COPY {table | (query)} TO path [(options)]}, DuckDB's bulk import and export statement.
+ *
+ * @see <a href="https://duckdb.org/docs/stable/sql/statements/copy">COPY</a>
+ */
+public class CopyStatement implements Statement {
+    private Table table;
+    private ExpressionList<Column> columns;
+    private Select select;
+    private boolean from;
+    private String path;
+    private List<String> options;
+
+    public Table getTable() {
+        return table;
+    }
+
+    public void setTable(Table table) {
+        this.table = table;
+    }
+
+    public CopyStatement withTable(Table table) {
+        setTable(table);
+        return this;
+    }
+
+    public ExpressionList<Column> getColumns() {
+        return columns;
+    }
+
+    public void setColumns(ExpressionList<Column> columns) {
+        this.columns = columns;
+    }
+
+    public CopyStatement withColumns(ExpressionList<Column> columns) {
+        setColumns(columns);
+        return this;
+    }
+
+    public Select getSelect() {
+        return select;
+    }
+
+    public void setSelect(Select select) {
+        this.select = select;
+    }
+
+    public CopyStatement withSelect(Select select) {
+        setSelect(select);
+        return this;
+    }
+
+    /** {@code true} for COPY ... FROM (import), {@code false} for COPY ... TO (export). */
+    public boolean isFrom() {
+        return from;
+    }
+
+    public void setFrom(boolean from) {
+        this.from = from;
+    }
+
+    public CopyStatement withFrom(boolean from) {
+        setFrom(from);
+        return this;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public CopyStatement withPath(String path) {
+        setPath(path);
+        return this;
+    }
+
+    public List<String> getOptions() {
+        return options;
+    }
+
+    public void setOptions(List<String> options) {
+        this.options = options;
+    }
+
+    public CopyStatement withOptions(List<String> options) {
+        setOptions(options);
+        return this;
+    }
+
+    public StringBuilder appendTo(StringBuilder builder) {
+        builder.append("COPY ");
+        if (select != null) {
+            builder.append("(").append(select).append(")");
+        } else {
+            builder.append(table);
+            if (columns != null && !columns.isEmpty()) {
+                builder.append(" (").append(columns).append(")");
+            }
+        }
+        builder.append(from ? " FROM " : " TO ").append(path);
+        if (options != null && !options.isEmpty()) {
+            builder.append(" ").append(PlainSelect.getStringList(options, true, true));
+        }
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+}