diff --git a/README.md b/README.md
index d39e81ea6..0afa5b6d9 100644
--- a/README.md
+++ b/README.md
@@ -145,6 +145,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 | **DDL** | `CREATE …` · `ALTER …` · `DROP …` |
 | **MySQL table maintenance** | `ANALYZE` · `CHECK` · `OPTIMIZE` · `REPAIR TABLE` |
 | **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` |
+| **PostgreSQL administration** | `CREATE`/`ALTER EVENT TRIGGER` · `REINDEX` · `SECURITY LABEL` |
 | **Informix constraints** | `ALTER TABLE … ADD CONSTRAINT` with trailing constraint names for primary, unique, foreign and check constraints; enable with `parser.withDialect(Dialect.INFORMIX)` |
 | **Salesforce SOQL** | `INCLUDES` · `EXCLUDES` |
 
diff --git a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
index 0d3d080fb..1439ac97a 100644
--- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
+++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
@@ -29,6 +29,7 @@
 import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.UseStatement;
 import net.sf.jsqlparser.statement.alter.Alter;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
 import net.sf.jsqlparser.statement.analyze.Analyze;
 import net.sf.jsqlparser.statement.comment.Comment;
@@ -40,6 +41,7 @@
 import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.view.AlterView;
 import net.sf.jsqlparser.statement.create.view.CreateView;
 import net.sf.jsqlparser.statement.delete.Delete;
@@ -48,6 +50,7 @@
 import net.sf.jsqlparser.statement.grant.Grant;
 import net.sf.jsqlparser.statement.merge.Merge;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
 import net.sf.jsqlparser.statement.select.Fetch;
 import net.sf.jsqlparser.statement.select.First;
 import net.sf.jsqlparser.statement.select.KSQLWindow;
@@ -60,6 +63,7 @@
 import net.sf.jsqlparser.statement.select.TableFunction;
 import net.sf.jsqlparser.statement.select.Top;
 import net.sf.jsqlparser.statement.select.UnPivot;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.show.*;
 import net.sf.jsqlparser.statement.truncate.Truncate;
 import net.sf.jsqlparser.statement.update.Update;
@@ -607,6 +611,26 @@ public enum Feature {
      * SQL "CREATE TRIGGER" statement is allowed
      */
     createTrigger,
+    /**
+     * PostgreSQL "CREATE EVENT TRIGGER" and "ALTER EVENT TRIGGER" statements are allowed
+     *
+     * @see CreateEventTrigger
+     * @see AlterEventTrigger
+     */
+    createEventTrigger, alterEventTrigger,
+    /**
+     * PostgreSQL "REINDEX" statement is allowed; "REINDEX … CONCURRENTLY" additionally requires
+     * {@link #reindexConcurrently}
+     *
+     * @see Reindex
+     */
+    reindex, reindexConcurrently,
+    /**
+     * PostgreSQL "SECURITY LABEL" statement is allowed
+     *
+     * @see SecurityLabel
+     */
+    securityLabel,
     /**
      * SQL "COMMIT" statement is allowed
      *
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
index 91b272124..ca3f100a9 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
@@ -36,6 +36,7 @@
 import net.sf.jsqlparser.statement.alter.AlterSession;
 import net.sf.jsqlparser.statement.alter.AlterStatistics;
 import net.sf.jsqlparser.statement.alter.AlterSubscription;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
 import net.sf.jsqlparser.statement.alter.AlterTablespaceMove;
 import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration;
@@ -68,6 +69,7 @@
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
 import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.type.CreateType;
 import net.sf.jsqlparser.statement.create.user.CreateUser;
@@ -93,6 +95,8 @@
 import net.sf.jsqlparser.statement.oracle.OracleBlock;
 import net.sf.jsqlparser.statement.oracle.OracleNullStatement;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.role.AlterRole;
 import net.sf.jsqlparser.statement.role.CreateRole;
 import net.sf.jsqlparser.statement.select.FromItemVisitor;
@@ -1065,6 +1069,29 @@ public <S> Void visit(CreateTrigger statement, S context) {
         return schemaOnly();
     }
 
+    @Override
+    public <S> Void visit(CreateEventTrigger statement, S context) {
+        return schemaOnly();
+    }
+
+    @Override
+    public <S> Void visit(AlterEventTrigger statement, S context) {
+        return schemaOnly();
+    }
+
+    @Override
+    public <S> Void visit(Reindex statement, S context) {
+        analysis.claimTopLevel();
+        // rebuilds index storage from the indexed rows
+        analysis.certain(StmtFeature.MODIFIES_SCHEMA, StmtFeature.READS_DATA);
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(SecurityLabel statement, S context) {
+        return schemaOnly();
+    }
+
     @Override
     public <S> Void visit(CreateType statement, S context) {
         analysis.claimTopLevel();
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
index bf0bf3e8b..e1592dbbd 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
@@ -52,6 +52,7 @@
 
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.AlterSession;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
 import net.sf.jsqlparser.statement.alter.RenameTableStatement;
 import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
@@ -66,6 +67,7 @@
 import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.user.CreateUser;
 import net.sf.jsqlparser.statement.create.view.AlterView;
@@ -83,6 +85,8 @@
 import net.sf.jsqlparser.statement.lock.LockStatement;
 import net.sf.jsqlparser.statement.merge.Merge;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.select.Select;
 import net.sf.jsqlparser.statement.show.ShowIndexStatement;
 import net.sf.jsqlparser.statement.show.ShowTablesStatement;
@@ -223,6 +227,38 @@ default void visit(CreateTrigger createTrigger) {
         this.visit(createTrigger, null);
     }
 
+    default <S> T visit(CreateEventTrigger statement, S context) {
+        return null;
+    }
+
+    default void visit(CreateEventTrigger statement) {
+        this.visit(statement, null);
+    }
+
+    default <S> T visit(AlterEventTrigger statement, S context) {
+        return null;
+    }
+
+    default void visit(AlterEventTrigger statement) {
+        this.visit(statement, null);
+    }
+
+    default <S> T visit(Reindex statement, S context) {
+        return null;
+    }
+
+    default void visit(Reindex statement) {
+        this.visit(statement, null);
+    }
+
+    default <S> T visit(SecurityLabel statement, S context) {
+        return null;
+    }
+
+    default void visit(SecurityLabel statement) {
+        this.visit(statement, null);
+    }
+
     <S> T visit(CreateView createView, S context);
 
     default void visit(CreateView createView) {
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
index 8a80763ca..4a4c86ba0 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
@@ -54,6 +54,7 @@
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.AlterExpression;
 import net.sf.jsqlparser.statement.alter.AlterSession;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
 import net.sf.jsqlparser.statement.alter.RenameTableStatement;
 import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
@@ -68,6 +69,7 @@
 import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.user.CreateUser;
 import net.sf.jsqlparser.statement.create.view.AlterView;
@@ -88,6 +90,8 @@
 import net.sf.jsqlparser.statement.merge.MergeOperationVisitor;
 import net.sf.jsqlparser.statement.merge.MergeOperationVisitorAdapter;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.select.FromItemVisitor;
 import net.sf.jsqlparser.statement.select.FromItemVisitorAdapter;
 import net.sf.jsqlparser.statement.select.PivotVisitor;
@@ -383,6 +387,7 @@ public <S> T visit(CreateIndex createIndex, S context) {
 
     @Override
     public <S> T visit(CreateSchema createSchema, S context) {
+        createSchema.getStatements().forEach(element -> element.accept(this, context));
         return null;
     }
 
@@ -422,6 +427,32 @@ public <S> T visit(CreateTrigger createTrigger, S context) {
         return null;
     }
 
+    @Override
+    public <S> T visit(CreateEventTrigger statement, S context) {
+        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
+        return null;
+    }
+
+    @Override
+    public <S> T visit(AlterEventTrigger statement, S context) {
+        return null;
+    }
+
+    @Override
+    public <S> T visit(Reindex statement, S context) {
+        if (statement.getTable() != null) {
+            statement.getTable().accept(fromItemVisitor, context);
+        }
+        return null;
+    }
+
+    @Override
+    public <S> T visit(SecurityLabel statement, S context) {
+        statement.visitRelations(table -> table.accept(fromItemVisitor, context));
+        expressionVisitor.visitExpression(statement.getLabel(), context);
+        return null;
+    }
+
     @Override
     public <S> T visit(CreateView createView, S context) {
         createView.getView().accept(fromItemVisitor, context);
diff --git a/src/main/java/net/sf/jsqlparser/statement/alter/AlterEventTrigger.java b/src/main/java/net/sf/jsqlparser/statement/alter/AlterEventTrigger.java
new file mode 100644
index 000000000..0efb70b9b
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/alter/AlterEventTrigger.java
@@ -0,0 +1,131 @@
+/*-
+ * #%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.alter;
+
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+
+/**
+ * A PostgreSQL {@code ALTER EVENT TRIGGER} statement. The enable states are shared with the trigger
+ * and rule actions of {@link RelationAlterAction}. Each non-null setter selects its action and
+ * discards the values of the other actions.
+ */
+public class AlterEventTrigger implements Statement {
+    public enum Action {
+        STATE, OWNER, RENAME
+    }
+
+    private String name;
+    private Action action;
+    private RelationAlterAction.EnableState enableState;
+    private String owner;
+    private String newName;
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Action getAction() {
+        return action;
+    }
+
+    /** {@code ENABLE}, {@code ENABLE REPLICA}, {@code ENABLE ALWAYS} or {@code DISABLE}. */
+    public RelationAlterAction.EnableState getEnableState() {
+        return enableState;
+    }
+
+    public void setEnableState(RelationAlterAction.EnableState enableState) {
+        if (enableState != null) {
+            select(Action.STATE);
+        }
+        this.enableState = enableState;
+    }
+
+    public String getOwner() {
+        return owner;
+    }
+
+    public void setOwner(String owner) {
+        if (owner != null) {
+            select(Action.OWNER);
+        }
+        this.owner = owner;
+    }
+
+    public String getNewName() {
+        return newName;
+    }
+
+    public void setNewName(String newName) {
+        if (newName != null) {
+            select(Action.RENAME);
+        }
+        this.newName = newName;
+    }
+
+    private void select(Action action) {
+        this.action = action;
+        enableState = null;
+        owner = null;
+        newName = null;
+    }
+
+    public StringBuilder appendTo(StringBuilder sql) {
+        sql.append("ALTER EVENT TRIGGER ").append(name);
+        switch (action) {
+            case STATE:
+                sql.append(' ').append(enableState.name().replace('_', ' '));
+                break;
+            case OWNER:
+                sql.append(" OWNER TO ").append(owner);
+                break;
+            case RENAME:
+                sql.append(" RENAME TO ").append(newName);
+                break;
+            default:
+                throw new IllegalStateException("Unknown event trigger action: " + action);
+        }
+        return sql;
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    public AlterEventTrigger withName(String name) {
+        setName(name);
+        return this;
+    }
+
+    public AlterEventTrigger withEnableState(RelationAlterAction.EnableState enableState) {
+        setEnableState(enableState);
+        return this;
+    }
+
+    public AlterEventTrigger withOwner(String owner) {
+        setOwner(owner);
+        return this;
+    }
+
+    public AlterEventTrigger withNewName(String newName) {
+        setNewName(newName);
+        return this;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java b/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java
index f8888132f..6e8d2da99 100644
--- a/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java
+++ b/src/main/java/net/sf/jsqlparser/statement/create/schema/CreateSchema.java
@@ -14,6 +14,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 import net.sf.jsqlparser.statement.Statement;
@@ -36,7 +37,7 @@ public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
     }
 
     /**
-     * Add a statement to the schema definition
+     * Add a schema element, for example a CREATE TABLE or GRANT statement, to the schema definition
      *
      * @param statement The statement to be added
      * @return true if the operation was successful
@@ -109,7 +110,8 @@ public void setSchemaPath(List<String> schemaPath) {
     }
 
     /**
-     * The statements executed as part of the schema creation
+     * The schema elements created as part of the schema, in source order. Their names are kept as
+     * written; unqualified names refer to the new schema.
      *
      * @return the statements
      */
@@ -139,7 +141,32 @@ public CreateSchema setIfNotExists(boolean hasIfNotExists) {
         return this;
     }
 
+    @Override
     public String toString() {
+        StringBuilder builder = new StringBuilder();
+        return appendTo(builder, builder::append).toString();
+    }
+
+    /**
+     * Appends the schema definition, rendering each schema element with the given writer.
+     *
+     * @param builder the target
+     * @param elementWriter renders one schema element
+     * @return the target
+     */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Statement> elementWriter) {
+        builder.append(headerSql());
+        if (schemaPath != null && !schemaPath.isEmpty()) {
+            builder.append(" PATH ").append(String.join(", ", schemaPath));
+        }
+        for (Statement statement : statements) {
+            builder.append(' ');
+            elementWriter.accept(statement);
+        }
+        return builder;
+    }
+
+    private String headerSql() {
         String sql = "CREATE SCHEMA";
         if (hasIfNotExists) {
             sql += " IF NOT EXISTS";
diff --git a/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateEventTrigger.java b/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateEventTrigger.java
new file mode 100644
index 000000000..daa1ace7c
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/create/trigger/CreateEventTrigger.java
@@ -0,0 +1,196 @@
+/*-
+ * #%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.create.trigger;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.Function;
+import net.sf.jsqlparser.expression.StringValue;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+
+/**
+ * A PostgreSQL {@code CREATE EVENT TRIGGER} statement. Unlike {@link CreateTrigger}, it fires on a
+ * database event such as {@code ddl_command_start} rather than on table rows. The function is
+ * invoked like a {@link CreateTrigger} routine, with the same {@code FUNCTION} or {@code PROCEDURE}
+ * spelling, but never takes arguments.
+ */
+public class CreateEventTrigger implements Statement {
+
+    private String name;
+    private String event;
+    private final List<Filter> filters = new ArrayList<>();
+    private CreateTrigger.ExecuteKeyword executeKeyword = CreateTrigger.ExecuteKeyword.FUNCTION;
+    private Function function;
+
+    /** A {@code WHEN} condition, for example {@code TAG IN ('CREATE TABLE', 'DROP TABLE')}. */
+    public static class Filter implements Serializable {
+        private String variable;
+        private final List<StringValue> values = new ArrayList<>();
+
+        public Filter() {
+            // empty constructor
+        }
+
+        public Filter(String variable, Collection<StringValue> values) {
+            this.variable = variable;
+            setValues(values);
+        }
+
+        /** The filter variable as written, for example {@code TAG}. */
+        public String getVariable() {
+            return variable;
+        }
+
+        public void setVariable(String variable) {
+            this.variable = variable;
+        }
+
+        /** The accepted values in source order. */
+        public List<StringValue> getValues() {
+            return Collections.unmodifiableList(values);
+        }
+
+        public void setValues(Collection<StringValue> values) {
+            this.values.clear();
+            if (values != null) {
+                this.values.addAll(values);
+            }
+        }
+
+        public Filter addValues(StringValue... values) {
+            Collections.addAll(this.values, values);
+            return this;
+        }
+
+        public StringBuilder appendTo(StringBuilder sql, Consumer<Expression> expressionWriter) {
+            sql.append(variable).append(" IN (");
+            for (int i = 0; i < values.size(); i++) {
+                if (i > 0) {
+                    sql.append(", ");
+                }
+                expressionWriter.accept(values.get(i));
+            }
+            return sql.append(')');
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder sql = new StringBuilder();
+            return appendTo(sql, sql::append).toString();
+        }
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /** The event name as written, for example {@code ddl_command_start} or {@code sql_drop}. */
+    public String getEvent() {
+        return event;
+    }
+
+    public void setEvent(String event) {
+        this.event = event;
+    }
+
+    /** The {@code WHEN} conditions in source order; all of them must match. */
+    public List<Filter> getFilters() {
+        return Collections.unmodifiableList(filters);
+    }
+
+    public void setFilters(Collection<Filter> filters) {
+        this.filters.clear();
+        if (filters != null) {
+            this.filters.addAll(filters);
+        }
+    }
+
+    public CreateEventTrigger addFilters(Filter... filters) {
+        Collections.addAll(this.filters, filters);
+        return this;
+    }
+
+    public CreateTrigger.ExecuteKeyword getExecuteKeyword() {
+        return executeKeyword;
+    }
+
+    public void setExecuteKeyword(CreateTrigger.ExecuteKeyword executeKeyword) {
+        this.executeKeyword = executeKeyword;
+    }
+
+    /** The invoked function, rendered with its empty argument list. */
+    public Function getFunction() {
+        return function;
+    }
+
+    public void setFunction(Function function) {
+        this.function = function;
+    }
+
+    /** Visits the filter values and the invoked function. */
+    public void visitExpressions(Consumer<Expression> visitor) {
+        filters.forEach(filter -> filter.getValues().forEach(visitor));
+        if (function != null) {
+            visitor.accept(function);
+        }
+    }
+
+    public StringBuilder appendTo(StringBuilder sql, Consumer<Expression> expressionWriter) {
+        sql.append("CREATE EVENT TRIGGER ").append(name).append(" ON ").append(event);
+        for (int i = 0; i < filters.size(); i++) {
+            sql.append(i == 0 ? " WHEN " : " AND ");
+            filters.get(i).appendTo(sql, expressionWriter);
+        }
+        sql.append(" EXECUTE ").append(executeKeyword).append(' ');
+        expressionWriter.accept(function);
+        return sql;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sql = new StringBuilder();
+        return appendTo(sql, sql::append).toString();
+    }
+
+    public CreateEventTrigger withName(String name) {
+        setName(name);
+        return this;
+    }
+
+    public CreateEventTrigger withEvent(String event) {
+        setEvent(event);
+        return this;
+    }
+
+    public CreateEventTrigger withExecuteKeyword(CreateTrigger.ExecuteKeyword executeKeyword) {
+        setExecuteKeyword(executeKeyword);
+        return this;
+    }
+
+    public CreateEventTrigger withFunction(Function function) {
+        setFunction(function);
+        return this;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/reindex/Reindex.java b/src/main/java/net/sf/jsqlparser/statement/reindex/Reindex.java
new file mode 100644
index 000000000..5402be1d8
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/reindex/Reindex.java
@@ -0,0 +1,182 @@
+/*-
+ * #%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.reindex;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+
+/** A PostgreSQL {@code REINDEX} statement. */
+public class Reindex implements Statement {
+
+    public enum Target {
+        INDEX, TABLE, SCHEMA, DATABASE, SYSTEM
+    }
+
+    private final List<Option> options = new ArrayList<>();
+    private Target target;
+    private boolean concurrently;
+    private Table name;
+
+    /** A parenthesized option, for example {@code VERBOSE} or {@code TABLESPACE fast_space}. */
+    public static class Option implements Serializable {
+        public enum Name {
+            CONCURRENTLY, TABLESPACE, VERBOSE
+        }
+
+        private Name name;
+        private String value;
+
+        public Option() {
+            // empty constructor
+        }
+
+        public Option(Name name, String value) {
+            this.name = name;
+            this.value = value;
+        }
+
+        public Name getName() {
+            return name;
+        }
+
+        public void setName(Name name) {
+            this.name = name;
+        }
+
+        /**
+         * The value as written, such as {@code false}, {@code 0} or a tablespace; null if omitted.
+         */
+        public String getValue() {
+            return value;
+        }
+
+        public void setValue(String value) {
+            this.value = value;
+        }
+
+        @Override
+        public String toString() {
+            return value == null ? name.name() : name + " " + value;
+        }
+    }
+
+    public Reindex() {
+        // empty constructor
+    }
+
+    public Reindex(Target target, Table name) {
+        this.target = target;
+        this.name = name;
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+
+    /** The parenthesized options in source order; empty when the list is omitted. */
+    public List<Option> getOptions() {
+        return Collections.unmodifiableList(options);
+    }
+
+    public void setOptions(Collection<Option> options) {
+        this.options.clear();
+        if (options != null) {
+            this.options.addAll(options);
+        }
+    }
+
+    public Reindex addOptions(Option... options) {
+        Collections.addAll(this.options, options);
+        return this;
+    }
+
+    public Target getTarget() {
+        return target;
+    }
+
+    public void setTarget(Target target) {
+        this.target = target;
+    }
+
+    /** Whether the {@code CONCURRENTLY} keyword follows the target kind. */
+    public boolean isConcurrently() {
+        return concurrently;
+    }
+
+    public void setConcurrently(boolean concurrently) {
+        this.concurrently = concurrently;
+    }
+
+    /**
+     * The index, table, schema or database name. Only DATABASE and SYSTEM may omit it, which
+     * selects the current database.
+     */
+    public Table getName() {
+        return name;
+    }
+
+    public void setName(Table name) {
+        this.name = name;
+    }
+
+    /** Returns the reindexed table, or null when the target is not a table. */
+    public Table getTable() {
+        return target == Target.TABLE ? name : null;
+    }
+
+    public StringBuilder appendTo(StringBuilder sql) {
+        sql.append("REINDEX ");
+        if (!options.isEmpty()) {
+            sql.append(options.stream().map(Option::toString)
+                    .collect(Collectors.joining(", ", "(", ") ")));
+        }
+        sql.append(target);
+        if (concurrently) {
+            sql.append(" CONCURRENTLY");
+        }
+        if (name != null) {
+            sql.append(' ').append(name);
+        }
+        return sql;
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    public Reindex withTarget(Target target) {
+        setTarget(target);
+        return this;
+    }
+
+    public Reindex withConcurrently(boolean concurrently) {
+        setConcurrently(concurrently);
+        return this;
+    }
+
+    public Reindex withName(Table name) {
+        setName(name);
+        return this;
+    }
+
+    public Reindex withOptions(Collection<Option> options) {
+        setOptions(options);
+        return this;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabel.java b/src/main/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabel.java
new file mode 100644
index 000000000..cc0b37592
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabel.java
@@ -0,0 +1,234 @@
+/*-
+ * #%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.securitylabel;
+
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.expression.StringValue;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.RoutineReference;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+
+/**
+ * A PostgreSQL {@code SECURITY LABEL} statement. The labeled object is a named object, a column, a
+ * routine signature or a large object, selected by {@link #getObjectType()}. Each target setter
+ * selects its object type and discards the previous target. A null label stands for
+ * {@code IS NULL}, which removes the label.
+ */
+public class SecurityLabel implements Statement {
+
+    public enum ObjectType {
+        TABLE, COLUMN, AGGREGATE, DATABASE, DOMAIN, EVENT_TRIGGER, FOREIGN_TABLE, FUNCTION, LANGUAGE, LARGE_OBJECT, MATERIALIZED_VIEW, PROCEDURE, PUBLICATION, ROLE, ROUTINE, SCHEMA, SEQUENCE, SUBSCRIPTION, TABLESPACE, TYPE, VIEW;
+
+        private static final Set<ObjectType> ROUTINES =
+                EnumSet.of(AGGREGATE, FUNCTION, PROCEDURE, ROUTINE);
+        private static final Set<ObjectType> RELATIONS =
+                EnumSet.of(TABLE, FOREIGN_TABLE, MATERIALIZED_VIEW, VIEW);
+
+        /** Returns the SQL spelling, for example {@code MATERIALIZED VIEW}. */
+        public String getKeyword() {
+            return name().replace('_', ' ');
+        }
+
+        /** Whether the object is addressed by a routine signature. */
+        public boolean isRoutine() {
+            return ROUTINES.contains(this);
+        }
+
+        /** Whether the object is a table or view that table visitors report. */
+        public boolean isRelation() {
+            return RELATIONS.contains(this);
+        }
+
+        /** Whether the object is addressed by its name alone. */
+        public boolean isNamed() {
+            return this != COLUMN && this != LARGE_OBJECT && !isRoutine();
+        }
+    }
+
+    private String provider;
+    private ObjectType objectType;
+    private Table objectName;
+    private Column column;
+    private RoutineReference routine;
+    private Long largeObjectOid;
+    private boolean procedural;
+    private StringValue label;
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+
+    /** The label provider as written, an identifier or a string literal; null if omitted. */
+    public String getProvider() {
+        return provider;
+    }
+
+    public void setProvider(String provider) {
+        this.provider = provider;
+    }
+
+    public ObjectType getObjectType() {
+        return objectType;
+    }
+
+    /** The name of a {@linkplain ObjectType#isNamed() named} object. */
+    public Table getObjectName() {
+        return objectName;
+    }
+
+    /** Selects a {@linkplain ObjectType#isNamed() named} object. */
+    public void setObjectName(ObjectType objectType, Table objectName) {
+        if (!objectType.isNamed()) {
+            throw new IllegalArgumentException(objectType + " is not addressed by a name");
+        }
+        select(objectType);
+        this.objectName = objectName;
+    }
+
+    public Column getColumn() {
+        return column;
+    }
+
+    /** Selects a column, addressed by its qualified name. */
+    public void setColumn(Column column) {
+        select(ObjectType.COLUMN);
+        this.column = column;
+    }
+
+    public RoutineReference getRoutine() {
+        return routine;
+    }
+
+    /** Selects a function, procedure, routine or aggregate signature. */
+    public void setRoutine(ObjectType objectType, RoutineReference routine) {
+        if (!objectType.isRoutine()) {
+            throw new IllegalArgumentException(objectType + " is not addressed by a signature");
+        }
+        select(objectType);
+        this.routine = routine;
+    }
+
+    public Long getLargeObjectOid() {
+        return largeObjectOid;
+    }
+
+    /** Selects a large object, addressed by its OID. */
+    public void setLargeObjectOid(long largeObjectOid) {
+        select(ObjectType.LARGE_OBJECT);
+        this.largeObjectOid = largeObjectOid;
+    }
+
+    /** Whether a LANGUAGE target is spelled {@code PROCEDURAL LANGUAGE}. */
+    public boolean isProcedural() {
+        return procedural;
+    }
+
+    public void setProcedural(boolean procedural) {
+        this.procedural = procedural;
+    }
+
+    /** The label, or null for {@code IS NULL}. */
+    public StringValue getLabel() {
+        return label;
+    }
+
+    public void setLabel(StringValue label) {
+        this.label = label;
+    }
+
+    private void select(ObjectType objectType) {
+        this.objectType = objectType;
+        objectName = null;
+        column = null;
+        routine = null;
+        largeObjectOid = null;
+    }
+
+    /** Visits the table or view explicitly named by this label, including a column's table. */
+    public void visitRelations(Consumer<Table> visitor) {
+        Table relation = objectType == ObjectType.COLUMN && column != null ? column.getTable()
+                : objectType != null && objectType.isRelation() ? objectName : null;
+        if (relation != null) {
+            visitor.accept(relation);
+        }
+    }
+
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Table> relationWriter,
+            Consumer<Column> columnWriter, Consumer<StringValue> labelWriter) {
+        builder.append("SECURITY LABEL ");
+        if (provider != null) {
+            builder.append("FOR ").append(provider).append(' ');
+        }
+        builder.append("ON ");
+        if (objectType == ObjectType.LANGUAGE && procedural) {
+            builder.append("PROCEDURAL ");
+        }
+        builder.append(objectType.getKeyword()).append(' ');
+        if (objectType == ObjectType.COLUMN) {
+            columnWriter.accept(column);
+        } else if (objectType.isRoutine()) {
+            builder.append(routine);
+        } else if (objectType == ObjectType.LARGE_OBJECT) {
+            builder.append(largeObjectOid);
+        } else if (objectType.isRelation()) {
+            relationWriter.accept(objectName);
+        } else {
+            builder.append(objectName);
+        }
+        builder.append(" IS ");
+        if (label == null) {
+            builder.append("NULL");
+        } else {
+            labelWriter.accept(label);
+        }
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        return appendTo(builder, builder::append, builder::append, builder::append).toString();
+    }
+
+    public SecurityLabel withProvider(String provider) {
+        setProvider(provider);
+        return this;
+    }
+
+    public SecurityLabel withObjectName(ObjectType objectType, Table objectName) {
+        setObjectName(objectType, objectName);
+        return this;
+    }
+
+    public SecurityLabel withColumn(Column column) {
+        setColumn(column);
+        return this;
+    }
+
+    public SecurityLabel withRoutine(ObjectType objectType, RoutineReference routine) {
+        setRoutine(objectType, routine);
+        return this;
+    }
+
+    public SecurityLabel withLargeObjectOid(long largeObjectOid) {
+        setLargeObjectOid(largeObjectOid);
+        return this;
+    }
+
+    public SecurityLabel withLabel(StringValue label) {
+        setLabel(label);
+        return this;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
index aeecdb89d..f4b621c89 100644
--- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
+++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -122,6 +122,7 @@
 import net.sf.jsqlparser.statement.alter.AlterSession;
 import net.sf.jsqlparser.statement.alter.AlterStatistics;
 import net.sf.jsqlparser.statement.alter.AlterSubscription;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
 import net.sf.jsqlparser.statement.alter.AlterTablespaceMove;
 import net.sf.jsqlparser.statement.alter.AlterTextSearchConfiguration;
@@ -155,6 +156,7 @@
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
 import net.sf.jsqlparser.statement.create.textsearch.CreateTextSearchConfiguration;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.type.CreateType;
 import net.sf.jsqlparser.statement.create.user.CreateUser;
@@ -213,6 +215,8 @@
 import net.sf.jsqlparser.statement.piped.WherePipeOperator;
 import net.sf.jsqlparser.statement.piped.WindowPipeOperator;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.role.AlterRole;
 import net.sf.jsqlparser.statement.role.CreateRole;
 import net.sf.jsqlparser.statement.select.AllColumns;
@@ -1708,7 +1712,7 @@ public void visit(CreateIndex createIndex) {
 
     @Override
     public <S> Void visit(CreateSchema createSchema, S context) {
-        throwUnsupported(createSchema);
+        createSchema.getStatements().forEach(element -> element.accept(this, context));
         return null;
     }
 
@@ -1781,6 +1785,31 @@ public void visit(CreateTrigger createTrigger) {
         StatementVisitor.super.visit(createTrigger);
     }
 
+    @Override
+    public <S> Void visit(CreateEventTrigger statement, S context) {
+        statement.visitExpressions(expression -> expression.accept(this, context));
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(AlterEventTrigger statement, S context) {
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(Reindex statement, S context) {
+        if (statement.getTable() != null) {
+            visit(statement.getTable(), context);
+        }
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(SecurityLabel statement, S context) {
+        statement.visitRelations(table -> visit(table, context));
+        return null;
+    }
+
     @Override
     public <S> Void visit(CreateView create, S context) {
         visit(create.getView(), null);
diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
index 2490baa3e..ddffa00ec 100644
--- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
+++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
@@ -80,6 +80,7 @@
 import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.AlterSession;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
 import net.sf.jsqlparser.statement.alter.RenameTableStatement;
 import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
@@ -94,6 +95,7 @@
 import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.user.CreateUser;
 import net.sf.jsqlparser.statement.create.view.AlterView;
@@ -111,6 +113,8 @@
 import net.sf.jsqlparser.statement.lock.LockStatement;
 import net.sf.jsqlparser.statement.merge.Merge;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.select.Select;
 import net.sf.jsqlparser.statement.select.SelectVisitor;
 import net.sf.jsqlparser.statement.select.WithItem;
@@ -216,6 +220,30 @@ public <S> StringBuilder visit(CreateTrigger createTrigger, S context) {
         return builder;
     }
 
+    @Override
+    public <S> StringBuilder visit(CreateEventTrigger statement, S context) {
+        return statement.appendTo(builder,
+                expression -> expression.accept(expressionDeParser, context));
+    }
+
+    @Override
+    public <S> StringBuilder visit(AlterEventTrigger statement, S context) {
+        return statement.appendTo(builder);
+    }
+
+    @Override
+    public <S> StringBuilder visit(Reindex statement, S context) {
+        return statement.appendTo(builder);
+    }
+
+    @Override
+    public <S> StringBuilder visit(SecurityLabel statement, S context) {
+        return statement.appendTo(builder,
+                table -> table.accept(selectDeParser, context),
+                column -> column.accept(expressionDeParser, context),
+                label -> label.accept(expressionDeParser, context));
+    }
+
     @Override
     public <S> StringBuilder visit(CreateView createView, S context) {
         CreateViewDeParser createViewDeParser = new CreateViewDeParser(builder, selectDeParser);
@@ -513,8 +541,7 @@ public <S> StringBuilder visit(Grant grant, S context) {
 
     @Override
     public <S> StringBuilder visit(CreateSchema aThis, S context) {
-        builder.append(aThis.toString());
-        return builder;
+        return aThis.appendTo(builder, element -> element.accept(this, context));
     }
 
     @Override
diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java
index 6f45efefc..48fa1ea8a 100644
--- a/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java
+++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/FeaturesAllowed.java
@@ -111,7 +111,7 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS
             Feature.createTableCreateOptionStrings, Feature.createTableTableOptionStrings,
             Feature.createTableIfNotExists, Feature.createTableRowMovement,
             Feature.createTableFromSelect,
-            Feature.createTrigger,
+            Feature.createTrigger, Feature.createEventTrigger,
             Feature.createView).unmodifyable();
     /**
      * all "ALTER" {@link Feature}'s
@@ -119,7 +119,7 @@ public class FeaturesAllowed implements FeatureSetValidation, ModifyableFeatureS
     public static final FeaturesAllowed ALTER =
             new FeaturesAllowed("ALTER", Feature.alterTable, Feature.alterSequence,
                     Feature.alterTextSearchConfiguration,
-                    Feature.alterCollation,
+                    Feature.alterCollation, Feature.alterEventTrigger,
                     Feature.alterView, Feature.alterIndex, Feature.alterSchema,
                     Feature.alterForeignDataWrapper, Feature.alterServer, Feature.alterUserMapping)
                     .unmodifyable();
diff --git a/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java b/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java
index 023a8c0e1..1e5a2e5fa 100644
--- a/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java
+++ b/src/main/java/net/sf/jsqlparser/util/validation/feature/PostgresqlVersion.java
@@ -155,7 +155,10 @@ public enum PostgresqlVersion implements Version {
                     Feature.explain, // https://www.postgresql.org/docs/current/sql-grant.html
                     Feature.grant,
                     Feature.revoke, Feature.createRole, Feature.alterRole,
-                    Feature.alterDefaultPrivileges, Feature.createTrigger, // https://www.postgresql.org/docs/current/sql-set.html
+                    Feature.alterDefaultPrivileges, Feature.createTrigger, // https://www.postgresql.org/docs/current/sql-createeventtrigger.html
+                    Feature.createEventTrigger, Feature.alterEventTrigger, // https://www.postgresql.org/docs/current/sql-reindex.html
+                    Feature.reindex, // https://www.postgresql.org/docs/current/sql-security-label.html
+                    Feature.securityLabel, // https://www.postgresql.org/docs/current/sql-set.html
                     Feature.set, Feature.setAssignmentTo, // https://www.postgresql.org/docs/current/sql-reset.html
                     Feature.reset, // https://www.postgresql.org/docs/current/sql-commit.html
                     Feature.commit, Feature.startTransaction, Feature.releaseSavepoint,
@@ -163,6 +166,7 @@ public enum PostgresqlVersion implements Version {
                             V10.copy().getFeatures()), V12("12",
                                     V11.copy()
                                             .add(Feature.createAccessMethodTable,
+                                                    Feature.reindexConcurrently,
                                                     Feature.transactionChain)
                                             .getFeatures()), V13(
                                                     "13",
diff --git a/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java
index 1de8380a7..278608b51 100644
--- a/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java
+++ b/src/main/java/net/sf/jsqlparser/util/validation/validator/StatementValidator.java
@@ -79,6 +79,7 @@
 import net.sf.jsqlparser.statement.TableMaintenanceStatement;
 import net.sf.jsqlparser.statement.alter.Alter;
 import net.sf.jsqlparser.statement.alter.AlterSession;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
 import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
 import net.sf.jsqlparser.statement.alter.RenameTableStatement;
 import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
@@ -95,6 +96,7 @@
 import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
 import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.user.CreateUser;
 import net.sf.jsqlparser.statement.create.view.AlterView;
@@ -112,6 +114,8 @@
 import net.sf.jsqlparser.statement.lock.LockStatement;
 import net.sf.jsqlparser.statement.merge.Merge;
 import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.select.Select;
 import net.sf.jsqlparser.statement.select.SelectVisitor;
 import net.sf.jsqlparser.statement.show.ShowIndexStatement;
@@ -166,6 +170,52 @@ public <S> Void visit(CreateTrigger createTrigger, S context) {
         return null;
     }
 
+    @Override
+    public <S> Void visit(CreateEventTrigger statement, S context) {
+        // the filter values are tags and the function is declared, not called
+        validateFeature(Feature.createEventTrigger);
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(AlterEventTrigger statement, S context) {
+        validateFeature(Feature.alterEventTrigger);
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(Reindex statement, S context) {
+        validateFeature(Feature.reindex);
+        if (statement.isConcurrently() || statement.getOptions().stream()
+                .anyMatch(option -> option.getName() == Reindex.Option.Name.CONCURRENTLY)) {
+            validateFeature(Feature.reindexConcurrently);
+        }
+        if (statement.getName() != null) {
+            validateName(reindexedObject(statement.getTarget()),
+                    statement.getName().getFullyQualifiedName());
+        }
+        return null;
+    }
+
+    private static NamedObject reindexedObject(Reindex.Target target) {
+        switch (target) {
+            case INDEX:
+                return NamedObject.index;
+            case TABLE:
+                return NamedObject.table;
+            case SCHEMA:
+                return NamedObject.schema;
+            default:
+                return NamedObject.database;
+        }
+    }
+
+    @Override
+    public <S> Void visit(SecurityLabel statement, S context) {
+        validateFeature(Feature.securityLabel);
+        return null;
+    }
+
     @Override
     public <S> Void visit(CreateView createView, S context) {
         getValidator(CreateViewValidator.class).validate(createView);
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
index 2210dbe9d..3eb854247 100644
--- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
+++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -89,6 +89,8 @@ import net.sf.jsqlparser.statement.execute.*;
 import net.sf.jsqlparser.statement.piped.*;
 import net.sf.jsqlparser.statement.select.*;
 import net.sf.jsqlparser.statement.refresh.*;
+import net.sf.jsqlparser.statement.reindex.Reindex;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
 import net.sf.jsqlparser.statement.show.*;
 import net.sf.jsqlparser.statement.truncate.*;
 import net.sf.jsqlparser.statement.update.*;
@@ -140,6 +142,9 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
     // then-branch closes the ternary and must not be taken as the JSON path operator
     private int ternaryThenBranchDepth = 0;
 
+    // depth of open CREATE SCHEMA elements: GRANT there starts the next element, never an alias
+    private int schemaElementDepth = 0;
+
     // Keep this routing check aligned with SingleStatement, including aliases and dialect gates.
     // It does not validate syntax that the grammar captures as opaque.
     private boolean isStatementStartAhead() {
@@ -161,6 +166,10 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
                 return true;
             case K_DO:
                 return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect));
+            case K_SECURITY:
+                return "LABEL".equalsIgnoreCase(getToken(2).image);
+            case K_REINDEX:
+                return isReindexAhead();
             case K_IMPORT: case K_EXPORT:
                 return Dialect.EXASOL.name().equals(getAsString(Feature.dialect))
                     || next.kind == K_EXPORT && getToken(2).kind == K_DATA;
@@ -1905,6 +1914,11 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             return false;
         }
 
+        // GRANT after a CREATE SCHEMA element starts the next element
+        if (kind == K_GRANT && schemaElementDepth > 0) {
+            return false;
+        }
+
         // For reserved keywords in alias position, skip the structural-
         // keyword whitelist and go directly to follower disambiguation.
         // Only check keywords that are actually in RelObjectName's token
@@ -2007,6 +2021,16 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         return table == K_TABLE || table == K_TABLES;
     }
 
+    /** Whether a PostgreSQL REINDEX statement starts here; REINDEX stays an identifier elsewhere. */
+    private boolean isReindexAhead() {
+        if (getToken(1).kind != K_REINDEX) {
+            return false;
+        }
+        int next = getToken(2).kind;
+        return next == K_INDEX || next == K_TABLE || next == K_SCHEMA || next == K_DATABASE
+                || next == K_SYSTEM || "(".equals(getToken(2).image);
+    }
+
     /** Whether the next tokens spell an option accepted by this table maintenance operation. */
     private boolean isTableMaintenanceOptionAhead(TableMaintenanceStatement.Operation operation) {
         Token token = getToken(1);
@@ -2242,6 +2266,23 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         }
     }
 
+    /**
+     * Whether EVENT TRIGGER starts a PostgreSQL event trigger rather than a MySQL event named
+     * trigger: the trigger name is followed by ON in CREATE and by an action keyword in ALTER.
+     */
+    private boolean isPostgreSqlEventTriggerAhead(boolean alter) {
+        if (getToken(1).kind != K_EVENT || getToken(2).kind != K_TRIGGER
+                || ".".equals(getToken(3).image)) {
+            return false;
+        }
+        Token next = getToken(4);
+        if (!alter) {
+            return next.kind == K_ON;
+        }
+        return next.kind == K_ENABLE || next.kind == K_DISABLE || next.kind == K_RENAME
+                || next.kind == S_IDENTIFIER && "OWNER".equalsIgnoreCase(next.image);
+    }
+
     // In these dialects -> always denotes JSON access, even after a comma or parentheses.
     private boolean isJsonArrowDialect() {
         return Dialect.POSTGRESQL.name().equals(getAsString(Feature.dialect))
@@ -3214,6 +3255,7 @@ String NonReservedWord() :
       | tk=<K_RLIKE: "RLIKE">
       | tk=<K_REGEXP_LIKE: "REGEXP_LIKE">
       | tk=<K_REGISTER: "REGISTER">
+      | tk=<K_REINDEX: "REINDEX">
       | tk=<K_REMOTE: "REMOTE">
       | tk=<K_REMOVE: "REMOVE">
       | tk=<K_REMAINDER: "REMAINDER">
@@ -3916,6 +3958,11 @@ Statement SingleStatement() :
             |
             LOOKAHEAD({ isTableMaintenanceAhead() }) stm = TableMaintenanceStatement()
             |
+            LOOKAHEAD({ isReindexAhead() }) stm = Reindex()
+            |
+            LOOKAHEAD({ getToken(1).kind == K_SECURITY && "LABEL".equalsIgnoreCase(getToken(2).image) })
+            stm = SecurityLabel()
+            |
             stm = Truncate()
             |
             stm = Execute()
@@ -15819,11 +15866,9 @@ CreateTrigger CreateTrigger():
 CreateSchema CreateSchema():
 {
     Token tk = null;
-    CreateTable table = null;
-    CreateView view = null;
+    Statement element = null;
     CreateSchema schema = new CreateSchema();
     List<String> schemaPath = null;
-    List<Statement> statements = new ArrayList<Statement>();
     DatabaseOption databaseOption = null;
 }
 {
@@ -15849,26 +15894,44 @@ CreateSchema CreateSchema():
 
     [schemaPath=PathSpecification() { schema.setSchemaPath(schemaPath); }]
 
+    // Elements keep their names as written; unqualified names refer to the new schema.
     (
-        LOOKAHEAD(2) (
-            <K_CREATE>
+        LOOKAHEAD({ getToken(1).kind == K_CREATE || getToken(1).kind == K_GRANT })
+        element=SchemaElement() { schema.addStatement(element); }
+    )*
+    {
+        requireDdlSyntax(!schema.hasIfNotExists() || schema.getStatements().isEmpty(),
+                "CREATE SCHEMA IF NOT EXISTS cannot include schema elements");
+        return schema;
+    }
+}
 
-            table = CreateTable(false)
+/**
+ * A statement nested in CREATE SCHEMA. Only the object kinds that PostgreSQL accepts as schema
+ * elements are allowed: tables, views, indexes, sequences, triggers and GRANT.
+ */
+Statement SchemaElement():
+{
+    Statement element;
+}
+{
+    { schemaElementDepth++; }
+    try {
+        (
+            element=Create()
             {
-                table.getTable().setSchemaName(schema.getSchemaName());
-                schema.addStatement(table);
+                requireDdlSyntax(element instanceof CreateTable || element instanceof CreateIndex
+                        || element instanceof CreateSequence || element instanceof CreateTrigger
+                        || element instanceof CreateView && !((CreateView) element).isMaterialized(),
+                        "A schema element must be CREATE TABLE, VIEW, INDEX, SEQUENCE, TRIGGER or GRANT");
             }
             |
-            view = CreateView(false)
-            {
-                view.getView().setSchemaName(schema.getSchemaName());
-                schema.addStatement(view);
-            }
+            element=Grant()
         )
-    )*
-    {
-        return schema;
+    } finally {
+        schemaElementDepth--;
     }
+    { return element; }
 }
 
 DatabaseOption MySqlDatabaseOption():
@@ -17322,6 +17385,141 @@ Analyze Analyze():
     }
 }
 
+/** Parses PostgreSQL REINDEX; only DATABASE and SYSTEM may omit the name. */
+Reindex Reindex():
+{
+    Reindex statement = new Reindex();
+    Reindex.Option option;
+    Table table;
+    String name;
+}
+{
+    <K_REINDEX>
+    [ "(" option=ReindexOption() { statement.addOptions(option); }
+      ( "," option=ReindexOption() { statement.addOptions(option); } )* ")" ]
+    (
+        ( <K_INDEX> { statement.setTarget(Reindex.Target.INDEX); }
+          | <K_TABLE> { statement.setTarget(Reindex.Target.TABLE); } )
+        ReindexConcurrently(statement)
+        table=Table() { statement.setName(table); }
+        |
+        <K_SCHEMA> { statement.setTarget(Reindex.Target.SCHEMA); }
+        ReindexConcurrently(statement)
+        name=RelObjectName() { statement.setName(new Table(name, false)); }
+        |
+        ( <K_DATABASE> { statement.setTarget(Reindex.Target.DATABASE); }
+          | <K_SYSTEM> { statement.setTarget(Reindex.Target.SYSTEM); } )
+        ReindexConcurrently(statement)
+        [ LOOKAHEAD(1) name=RelObjectName() { statement.setName(new Table(name, false)); } ]
+    )
+    { return statement; }
+}
+
+void ReindexConcurrently(Reindex statement):
+{}
+{
+    // CONCURRENTLY is a keyword here, as in CREATE INDEX, never the reindexed object's name
+    [ LOOKAHEAD({ getToken(1).kind == K_CONCURRENTLY }) <K_CONCURRENTLY> { statement.setConcurrently(true); } ]
+}
+
+Reindex.Option ReindexOption():
+{ Reindex.Option option = new Reindex.Option(); Token token; String value = null; }
+{
+    ( <K_CONCURRENTLY> { option.setName(Reindex.Option.Name.CONCURRENTLY); }
+      | <K_TABLESPACE> { option.setName(Reindex.Option.Name.TABLESPACE); }
+      | <K_VERBOSE> { option.setName(Reindex.Option.Name.VERBOSE); } )
+    [
+        LOOKAHEAD(1)
+        ( token=<K_TRUE> | token=<K_FALSE> | token=<K_ON> | token=<S_LONG> | token=<S_CHAR_LITERAL> )
+        { value = token.image; }
+        | value=RelObjectName()
+    ]
+    {
+        requireDdlSyntax(option.getName() != Reindex.Option.Name.TABLESPACE || value != null,
+                "The REINDEX TABLESPACE option requires a tablespace name");
+        option.setValue(value);
+        return option;
+    }
+}
+
+/**
+ * Parses PostgreSQL SECURITY LABEL. The object kind selects how the object is addressed: by a
+ * name, a qualified column, a routine signature or a large object OID.
+ */
+SecurityLabel SecurityLabel():
+{
+    SecurityLabel statement = new SecurityLabel();
+    SecurityLabel.ObjectType type;
+    Token token;
+    String name;
+    Table object;
+    Column column;
+    RoutineReference routine;
+    StringValue label;
+}
+{
+    <K_SECURITY> ContextualKeyword("LABEL")
+    [ <K_FOR> ( token=<S_CHAR_LITERAL> { statement.setProvider(token.image); }
+                | name=RelObjectName() { statement.setProvider(name); } ) ]
+    <K_ON> type=SecurityLabelObjectType(statement)
+    (
+        LOOKAHEAD({ type == SecurityLabel.ObjectType.COLUMN })
+        column=Column() { statement.setColumn(column); }
+        |
+        LOOKAHEAD({ type.isRoutine() })
+        routine=RoutineReference(type == SecurityLabel.ObjectType.AGGREGATE)
+        { statement.setRoutine(type, routine); }
+        |
+        LOOKAHEAD({ type == SecurityLabel.ObjectType.LARGE_OBJECT })
+        token=<S_LONG> { statement.setLargeObjectOid(Long.parseLong(token.image)); }
+        |
+        LOOKAHEAD({ type.isRelation() || type == SecurityLabel.ObjectType.SEQUENCE
+                || type == SecurityLabel.ObjectType.TYPE || type == SecurityLabel.ObjectType.DOMAIN })
+        object=CommentObjectName() { statement.setObjectName(type, object); }
+        |
+        name=RelObjectName() { statement.setObjectName(type, new Table(name, false)); }
+    )
+    <K_IS> ( label=CharacterLiteral() { statement.setLabel(label); } | <K_NULL> )
+    { return statement; }
+}
+
+SecurityLabel.ObjectType SecurityLabelObjectType(SecurityLabel statement):
+{ SecurityLabel.ObjectType type; }
+{
+    (
+        <K_TABLE> { type = SecurityLabel.ObjectType.TABLE; }
+        | <K_COLUMN> { type = SecurityLabel.ObjectType.COLUMN; }
+        | <K_AGGREGATE> { type = SecurityLabel.ObjectType.AGGREGATE; }
+        | <K_DATABASE> { type = SecurityLabel.ObjectType.DATABASE; }
+        | <K_DOMAIN> { type = SecurityLabel.ObjectType.DOMAIN; }
+        | <K_EVENT> <K_TRIGGER> { type = SecurityLabel.ObjectType.EVENT_TRIGGER; }
+        | <K_FOREIGN> <K_TABLE> { type = SecurityLabel.ObjectType.FOREIGN_TABLE; }
+        | <K_FUNCTION> { type = SecurityLabel.ObjectType.FUNCTION; }
+        | <K_MATERIALIZED> <K_VIEW> { type = SecurityLabel.ObjectType.MATERIALIZED_VIEW; }
+        | <K_PROCEDURE> { type = SecurityLabel.ObjectType.PROCEDURE; }
+        | <K_SCHEMA> { type = SecurityLabel.ObjectType.SCHEMA; }
+        | <K_SEQUENCE> { type = SecurityLabel.ObjectType.SEQUENCE; }
+        | <K_TABLESPACE> { type = SecurityLabel.ObjectType.TABLESPACE; }
+        | <K_TYPE> { type = SecurityLabel.ObjectType.TYPE; }
+        | <K_VIEW> { type = SecurityLabel.ObjectType.VIEW; }
+        | LOOKAHEAD({ isKeywordAhead("LARGE") }) ContextualKeyword("LARGE") ContextualKeyword("OBJECT")
+          { type = SecurityLabel.ObjectType.LARGE_OBJECT; }
+        | LOOKAHEAD({ isKeywordAhead("PROCEDURAL") }) ContextualKeyword("PROCEDURAL")
+          ContextualKeyword("LANGUAGE") { type = SecurityLabel.ObjectType.LANGUAGE; statement.setProcedural(true); }
+        | LOOKAHEAD({ isKeywordAhead("LANGUAGE") }) ContextualKeyword("LANGUAGE")
+          { type = SecurityLabel.ObjectType.LANGUAGE; }
+        | LOOKAHEAD({ isKeywordAhead("PUBLICATION") }) ContextualKeyword("PUBLICATION")
+          { type = SecurityLabel.ObjectType.PUBLICATION; }
+        | LOOKAHEAD({ isKeywordAhead("ROLE") }) ContextualKeyword("ROLE")
+          { type = SecurityLabel.ObjectType.ROLE; }
+        | LOOKAHEAD({ isKeywordAhead("ROUTINE") }) ContextualKeyword("ROUTINE")
+          { type = SecurityLabel.ObjectType.ROUTINE; }
+        | LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) ContextualKeyword("SUBSCRIPTION")
+          { type = SecurityLabel.ObjectType.SUBSCRIPTION; }
+    )
+    { return type; }
+}
+
 ExpressionList<Column> ColumnWithCommentList():
 {
     ExpressionList<Column> expressions = new ExpressionList<Column>();
@@ -19607,6 +19805,8 @@ Statement Alter():
                 |
                 LOOKAHEAD({ isKeywordAhead("SUBSCRIPTION") }) statement = AlterSubscription()
                 |
+                LOOKAHEAD({ isPostgreSqlEventTriggerAhead(true) }) statement = AlterEventTrigger()
+                |
                 statement = AlterEvent()
                 |
                 LOOKAHEAD(( <K_TABLE> | <K_INDEX> | <K_MATERIALIZED> <K_VIEW> ) <K_ALL> <K_IN> <K_TABLESPACE>)
@@ -20705,6 +20905,54 @@ Expression PostgreSqlTriggerArgument():
     { return result; }
 }
 
+/**
+ * Parses PostgreSQL CREATE EVENT TRIGGER. The routine invocation matches CREATE TRIGGER but takes
+ * no arguments; the event and filter names stay ordinary identifiers.
+ */
+CreateEventTrigger CreateEventTrigger():
+{
+    CreateEventTrigger statement = new CreateEventTrigger();
+    CreateEventTrigger.Filter filter;
+    Function function = new Function();
+    String name;
+}
+{
+    <K_EVENT> <K_TRIGGER> name=RelObjectName() { statement.setName(name); }
+    <K_ON> name=RelObjectName() { statement.setEvent(name); }
+    [ <K_WHEN> filter=EventTriggerFilter() { statement.addFilters(filter); }
+      ( <K_AND> filter=EventTriggerFilter() { statement.addFilters(filter); } )* ]
+    <K_EXECUTE> ( <K_FUNCTION> | <K_PROCEDURE> { statement.setExecuteKeyword(CreateTrigger.ExecuteKeyword.PROCEDURE); } )
+    name=AccessQualifiedName() "(" ")"
+    {
+        function.setName(name);
+        function.setParameters(new ExpressionList<Expression>());
+        statement.setFunction(function);
+        return statement;
+    }
+}
+
+CreateEventTrigger.Filter EventTriggerFilter():
+{ CreateEventTrigger.Filter filter = new CreateEventTrigger.Filter(); String name; Token value; }
+{
+    name=RelObjectName() { filter.setVariable(name); }
+    <K_IN> "(" value=<S_CHAR_LITERAL> { filter.addValues(stringValue(value)); }
+    ( "," value=<S_CHAR_LITERAL> { filter.addValues(stringValue(value)); } )* ")"
+    { return filter; }
+}
+
+/** Event trigger states reuse the enable states of table trigger and rule actions. */
+AlterEventTrigger AlterEventTrigger():
+{ AlterEventTrigger statement = new AlterEventTrigger(); RelationAlterAction.EnableState state; String name; }
+{
+    <K_EVENT> <K_TRIGGER> name=RelObjectName() { statement.setName(name); }
+    (
+        state=PostgreSqlEnableState() { statement.setEnableState(state); }
+        | ContextualKeyword("OWNER") <K_TO> name=RelObjectName() { statement.setOwner(name); }
+        | <K_RENAME> <K_TO> name=RelObjectName() { statement.setNewName(name); }
+    )
+    { return statement; }
+}
+
 List<String> UsersList():
 {
     List<String> users = new ArrayList<String>();
@@ -20952,6 +21200,10 @@ Statement Create():
         |
         statement = CreateUser()
         |
+        LOOKAHEAD({ isPostgreSqlEventTriggerAhead(false) })
+        { requireDdlSyntax(!isUsingOrReplace, "CREATE EVENT TRIGGER does not support OR REPLACE"); }
+        statement = CreateEventTrigger()
+        |
         statement = CreateEvent()
         |
         LOOKAHEAD(MySqlViewPrefix() <K_VIEW>) statement = CreateView(isUsingOrReplace)
diff --git a/src/site/sphinx/index.rst b/src/site/sphinx/index.rst
index 5f3b0157b..90f9d0f67 100644
--- a/src/site/sphinx/index.rst
+++ b/src/site/sphinx/index.rst
@@ -160,6 +160,8 @@ One grammar covers the SQL standard plus all major RDBMS. Missing syntax gets ad
       - ``ANALYZE`` · ``CHECK`` · ``OPTIMIZE`` · ``REPAIR TABLE``
     * - **PostgreSQL RLS**
       - ``CREATE POLICY`` · ``ALTER TABLE … ENABLE``/``DISABLE``/``FORCE``/``NO FORCE ROW LEVEL SECURITY``
+    * - **PostgreSQL administration**
+      - ``CREATE``/``ALTER EVENT TRIGGER`` · ``REINDEX`` · ``SECURITY LABEL``
     * - **Salesforce SOQL**
       - ``INCLUDES`` · ``EXCLUDES``
 
diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst
index 901608d62..455cec7e2 100644
--- a/src/site/sphinx/usage.rst
+++ b/src/site/sphinx/usage.rst
@@ -1742,7 +1742,7 @@ role values, trigger conditions and invocation arguments. Declaring a trigger
 is classified as a schema change, not execution of its body.
 
 Capability validation covers these statement families, not every server-version
-or catalog-dependent restriction. EVENT TRIGGER is outside this support.
+or catalog-dependent restriction. Event triggers use separate statements, described below.
 Serialized role SQL can contain passwords; avoid logging real credentials.
 
 References: `CREATE ROLE <https://www.postgresql.org/docs/18/sql-createrole.html>`_,
@@ -1752,6 +1752,56 @@ References: `CREATE ROLE <https://www.postgresql.org/docs/18/sql-createrole.html
 `ALTER DEFAULT PRIVILEGES <https://www.postgresql.org/docs/18/sql-alterdefaultprivileges.html>`_,
 `CREATE TRIGGER <https://www.postgresql.org/docs/18/sql-createtrigger.html>`_.
 
+PostgreSQL event triggers, REINDEX, SECURITY LABEL and schema elements
+----------------------------------------------------------------------
+
+``CREATE EVENT TRIGGER`` parses to ``CreateEventTrigger``. ``getEvent()`` keeps the event
+name as written and ``getFilters()`` the ``WHEN … IN (…)`` conditions in source order. The
+invoked function reuses ``CreateTrigger.ExecuteKeyword`` and a ``Function`` without
+arguments. ``ALTER EVENT TRIGGER`` parses to ``AlterEventTrigger``; its states reuse
+``RelationAlterAction.EnableState``, and each non-null setter selects the ``STATE``,
+``OWNER`` or ``RENAME`` action. A MySQL event named ``trigger`` still parses to
+``CreateEvent`` or ``AlterEvent``.
+
+.. code-block:: java
+
+    CreateEventTrigger trigger = (CreateEventTrigger) CCJSqlParserUtil.parse(
+        "CREATE EVENT TRIGGER etg ON ddl_command_start "
+        + "WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION abort_any_command()");
+    trigger.getEvent();                          // ddl_command_start
+    trigger.getFilters().get(0).getVariable();   // TAG
+    trigger.getFunction().getName();             // abort_any_command
+
+``REINDEX`` parses to ``Reindex``: a ``Target`` (INDEX, TABLE, SCHEMA, DATABASE or SYSTEM),
+the ``CONCURRENTLY`` keyword, the parenthesized ``CONCURRENTLY``, ``TABLESPACE`` and
+``VERBOSE`` options with their values as written, and the object name. Only DATABASE and
+SYSTEM may omit the name. ``getTable()`` returns the name only for ``REINDEX TABLE``, which
+table visitors report. ``REINDEX`` is a non-reserved keyword.
+
+``SECURITY LABEL`` parses to ``SecurityLabel`` with the provider as written and one target,
+told apart by ``getObjectType()``: a named object (``getObjectName()``), a qualified column
+(``getColumn()``), a FUNCTION, PROCEDURE, ROUTINE or AGGREGATE signature (``getRoutine()``)
+or a large object OID. A null label stands for ``IS NULL``. Table visitors report tables,
+views, materialized views, foreign tables and a column's table.
+
+``CREATE SCHEMA`` keeps its schema elements in ``getStatements()`` and renders them after the
+``AUTHORIZATION`` and ``PATH`` clauses. The element kinds are PostgreSQL's: ``CREATE TABLE``,
+``CREATE VIEW``, ``CREATE INDEX``, ``CREATE SEQUENCE``, ``CREATE TRIGGER`` and ``GRANT``;
+``CREATE SCHEMA IF NOT EXISTS`` cannot include them. Elements keep their names as written,
+and unqualified names refer to the new schema. The parser no longer copies the schema name
+into ``CREATE TABLE`` elements. Table visitors, validation and ``StatementDeParser`` traverse
+the elements.
+
+Validators report ``createEventTrigger``, ``alterEventTrigger``, ``reindex``,
+``reindexConcurrently`` (PostgreSQL 12) and ``securityLabel``. Feature analysis classifies
+these statements as schema changes; ``REINDEX`` also reads data.
+
+References: `CREATE EVENT TRIGGER <https://www.postgresql.org/docs/18/sql-createeventtrigger.html>`_,
+`ALTER EVENT TRIGGER <https://www.postgresql.org/docs/18/sql-altereventtrigger.html>`_,
+`REINDEX <https://www.postgresql.org/docs/18/sql-reindex.html>`_,
+`SECURITY LABEL <https://www.postgresql.org/docs/18/sql-security-label.html>`_,
+`CREATE SCHEMA <https://www.postgresql.org/docs/18/sql-createschema.html>`_.
+
 Migrating shared ALTER enums
 ----------------------------
 
diff --git a/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlEventTriggerTest.java b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlEventTriggerTest.java
new file mode 100644
index 000000000..83810d69a
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/statement/create/PostgreSqlEventTriggerTest.java
@@ -0,0 +1,183 @@
+/*-
+ * #%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.create;
+
+import static net.sf.jsqlparser.test.TestUtils.assertDeparse;
+import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.expression.Function;
+import net.sf.jsqlparser.expression.StringValue;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
+import net.sf.jsqlparser.parser.CCJSqlParser;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StmtFeature;
+import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
+import net.sf.jsqlparser.statement.alter.RelationAlterAction.EnableState;
+import net.sf.jsqlparser.statement.create.event.AlterEvent;
+import net.sf.jsqlparser.statement.create.event.CreateEvent;
+import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
+import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
+import net.sf.jsqlparser.util.TablesNamesFinder;
+import net.sf.jsqlparser.util.validation.Validation;
+import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed;
+import net.sf.jsqlparser.util.validation.feature.MySqlVersion;
+import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class PostgreSqlEventTriggerTest {
+    private static final Consumer<CCJSqlParser> POSTGRESQL =
+            parser -> parser.withDialect(Dialect.POSTGRESQL);
+
+    private static <T extends Statement> T roundTrip(String sql, Class<T> type)
+            throws JSQLParserException {
+        T statement =
+                assertInstanceOf(type, assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL));
+        assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), POSTGRESQL).toString());
+        return statement;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG IN ('CREATE TABLE') "
+                    + "EXECUTE FUNCTION abort_any_command()",
+            "CREATE EVENT TRIGGER etg ON sql_drop EXECUTE FUNCTION f()",
+            "CREATE EVENT TRIGGER \"On Login\" ON login EXECUTE FUNCTION app.on_login()",
+            "CREATE EVENT TRIGGER etg ON table_rewrite EXECUTE PROCEDURE f()"})
+    void parsesEventTriggerDefinitions(String sql) throws JSQLParserException {
+        roundTrip(sql, CreateEventTrigger.class);
+        assertInstanceOf(CreateEventTrigger.class, CCJSqlParserUtil.parse(sql));
+        assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", POSTGRESQL).size());
+    }
+
+    @Test
+    void keepsEventFiltersAndFunction() throws JSQLParserException {
+        CreateEventTrigger trigger = roundTrip("CREATE EVENT TRIGGER etg ON ddl_command_end "
+                + "WHEN TAG IN ('CREATE TABLE', 'DROP TABLE') AND tag IN ('ALTER TABLE') "
+                + "EXECUTE PROCEDURE audit.log_ddl()", CreateEventTrigger.class);
+
+        assertEquals("etg", trigger.getName());
+        assertEquals("ddl_command_end", trigger.getEvent());
+        assertEquals(2, trigger.getFilters().size());
+        CreateEventTrigger.Filter first = trigger.getFilters().get(0);
+        assertEquals("TAG", first.getVariable());
+        assertEquals(List.of("CREATE TABLE", "DROP TABLE"), first.getValues().stream()
+                .map(StringValue::getValue).collect(Collectors.toList()));
+        assertEquals("tag", trigger.getFilters().get(1).getVariable());
+        assertEquals(CreateTrigger.ExecuteKeyword.PROCEDURE, trigger.getExecuteKeyword());
+        assertEquals("audit.log_ddl", trigger.getFunction().getName());
+        assertTrue(trigger.getFunction().getParameters().isEmpty());
+    }
+
+    @Test
+    void buildsAnEventTrigger() {
+        CreateEventTrigger trigger = new CreateEventTrigger().withName("etg")
+                .withEvent("ddl_command_start")
+                .withFunction(new Function().withName("guard")
+                        .withParameters(new ExpressionList<>()))
+                .addFilters(new CreateEventTrigger.Filter("TAG",
+                        List.of(new StringValue("DROP TABLE"))));
+
+        assertDeparse(trigger, "CREATE EVENT TRIGGER etg ON ddl_command_start "
+                + "WHEN TAG IN ('DROP TABLE') EXECUTE FUNCTION guard()");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"DISABLE", "ENABLE", "ENABLE REPLICA", "ENABLE ALWAYS"})
+    void alterEventTriggerSharesTheEnableStates(String state) throws JSQLParserException {
+        AlterEventTrigger alter =
+                roundTrip("ALTER EVENT TRIGGER etg " + state, AlterEventTrigger.class);
+
+        assertEquals("etg", alter.getName());
+        assertEquals(AlterEventTrigger.Action.STATE, alter.getAction());
+        assertEquals(EnableState.valueOf(state.replace(' ', '_')), alter.getEnableState());
+    }
+
+    @Test
+    void alterEventTriggerOwnerAndName() throws JSQLParserException {
+        AlterEventTrigger owner =
+                roundTrip("ALTER EVENT TRIGGER etg OWNER TO CURRENT_USER", AlterEventTrigger.class);
+        assertEquals(AlterEventTrigger.Action.OWNER, owner.getAction());
+        assertEquals("CURRENT_USER", owner.getOwner());
+
+        AlterEventTrigger rename =
+                roundTrip("ALTER EVENT TRIGGER etg RENAME TO etg2", AlterEventTrigger.class);
+        assertEquals(AlterEventTrigger.Action.RENAME, rename.getAction());
+        assertEquals("etg2", rename.getNewName());
+    }
+
+    @Test
+    void settersSelectTheAction() {
+        AlterEventTrigger alter = new AlterEventTrigger().withName("etg").withOwner("admin");
+        alter.setNewName("etg2");
+        assertEquals(AlterEventTrigger.Action.RENAME, alter.getAction());
+        assertNull(alter.getOwner());
+        assertDeparse(alter, "ALTER EVENT TRIGGER etg RENAME TO etg2");
+
+        alter.setEnableState(EnableState.ENABLE_ALWAYS);
+        assertNull(alter.getNewName());
+        assertDeparse(alter, "ALTER EVENT TRIGGER etg ENABLE ALWAYS");
+    }
+
+    @Test
+    void mySqlEventsNamedTriggerStayEvents() throws JSQLParserException {
+        Consumer<CCJSqlParser> mysql = parser -> parser.withDialect(Dialect.MYSQL);
+        assertInstanceOf(CreateEvent.class, CCJSqlParserUtil.parse(
+                "CREATE EVENT trigger ON SCHEDULE EVERY 1 DAY DO SELECT 1", mysql));
+        assertInstanceOf(AlterEvent.class,
+                CCJSqlParserUtil.parse("ALTER EVENT trigger RENAME TO e2", mysql));
+        assertInstanceOf(AlterEvent.class,
+                CCJSqlParserUtil.parse("ALTER EVENT trigger ENABLE", mysql));
+        assertInstanceOf(AlterEvent.class, CCJSqlParserUtil.parse("ALTER EVENT e DISABLE", mysql));
+    }
+
+    @Test
+    void visitorsValidationAndFeatures() throws JSQLParserException {
+        String create = "CREATE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f()";
+        String alter = "ALTER EVENT TRIGGER etg DISABLE";
+        for (String sql : List.of(create, alter)) {
+            Statement statement = CCJSqlParserUtil.parse(sql, POSTGRESQL);
+            assertTrue(new TablesNamesFinder().getTables(statement).isEmpty());
+            assertThat(statement.getFeatures().getCertain())
+                    .containsExactly(StmtFeature.MODIFIES_SCHEMA);
+            assertTrue(new Validation(List.of(PostgresqlVersion.V10), sql).validate().isEmpty());
+            assertTrue(new Validation(List.of(FeaturesAllowed.DDL), sql).validate().isEmpty());
+            assertThat(new Validation(List.of(MySqlVersion.V8_0), sql).validate()).isNotEmpty();
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "CREATE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f(1)",
+            "CREATE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f",
+            "CREATE OR REPLACE EVENT TRIGGER etg ON ddl_command_start EXECUTE FUNCTION f()",
+            "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG IN () EXECUTE FUNCTION f()",
+            "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG IN (1) EXECUTE FUNCTION f()",
+            "CREATE EVENT TRIGGER etg ON ddl_command_start WHEN TAG = 'x' EXECUTE FUNCTION f()",
+            "ALTER EVENT TRIGGER etg",
+            "ALTER EVENT TRIGGER etg DISABLE ALWAYS",
+            "ALTER EVENT TRIGGER etg OWNER admin"})
+    void rejectsInvalidEventTriggers(String sql) {
+        assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL));
+    }
+}
diff --git a/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java b/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java
index 5d6093f18..eb56e7e73 100644
--- a/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java
+++ b/src/test/java/net/sf/jsqlparser/statement/create/schema/CreateSchemaTest.java
@@ -11,19 +11,50 @@
 
 import static net.sf.jsqlparser.test.TestUtils.assertDeparse;
 import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.List;
+import java.util.function.Consumer;
 import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
+import net.sf.jsqlparser.parser.CCJSqlParser;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.parser.feature.Feature;
+import net.sf.jsqlparser.statement.StmtFeature;
 import net.sf.jsqlparser.statement.create.database.DatabaseOption;
+import net.sf.jsqlparser.statement.create.index.CreateIndex;
+import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
+import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
+import net.sf.jsqlparser.statement.create.view.CreateView;
+import net.sf.jsqlparser.statement.grant.Grant;
+import net.sf.jsqlparser.util.TablesNamesFinder;
+import net.sf.jsqlparser.util.validation.Validation;
+import net.sf.jsqlparser.util.validation.feature.FeaturesAllowed;
+import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 /**
  *
  * @author tw
  */
 public class CreateSchemaTest {
+    private static final Consumer<CCJSqlParser> POSTGRESQL =
+            parser -> parser.withDialect(Dialect.POSTGRESQL);
+
+    private static CreateSchema roundTrip(String sql) throws JSQLParserException {
+        CreateSchema schema = assertInstanceOf(CreateSchema.class,
+                assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL));
+        assertEquals(sql, CCJSqlParserUtil.parse(schema.toString(), POSTGRESQL).toString());
+        return schema;
+    }
 
     @Test
     public void testSimpleCreateSchema() throws JSQLParserException {
@@ -77,4 +108,79 @@ void testMySqlCreateSchemaOptions() throws JSQLParserException {
 
         assertEquals(sql, CCJSqlParserUtil.parse(sql).toString());
     }
+
+    @Test
+    void keepsSchemaElementsAsWritten() throws JSQLParserException {
+        CreateSchema schema = roundTrip("CREATE SCHEMA hollywood "
+                + "CREATE TABLE films (title text, release date, awards text[]) "
+                + "CREATE VIEW winners AS SELECT title, release FROM films WHERE awards IS NOT NULL");
+
+        assertEquals("hollywood", schema.getSchemaName());
+        assertEquals(2, schema.getStatements().size());
+        CreateTable films = assertInstanceOf(CreateTable.class, schema.getStatements().get(0));
+        assertEquals("films", films.getTable().getFullyQualifiedName());
+        assertNull(films.getTable().getSchemaName());
+        CreateView winners = assertInstanceOf(CreateView.class, schema.getStatements().get(1));
+        assertEquals("winners", winners.getView().getFullyQualifiedName());
+        assertThat(new TablesNamesFinder().getTables(schema)).containsExactlyInAnyOrder("films",
+                "winners");
+    }
+
+    @Test
+    void acceptsEveryPostgreSqlSchemaElement() throws JSQLParserException {
+        CreateSchema schema = roundTrip("CREATE SCHEMA app AUTHORIZATION app_owner "
+                + "CREATE TABLE t (id int) "
+                + "CREATE VIEW v AS SELECT id FROM t "
+                + "GRANT SELECT ON v TO PUBLIC "
+                + "CREATE UNIQUE INDEX i ON t (id) "
+                + "CREATE SEQUENCE s START WITH 10 "
+                + "CREATE TRIGGER trg BEFORE INSERT ON t FOR EACH ROW EXECUTE FUNCTION f() "
+                + "GRANT USAGE ON SEQUENCE s TO app_user");
+
+        assertEquals("app_owner", schema.getAuthorization());
+        assertEquals(List.of(CreateTable.class, CreateView.class, Grant.class, CreateIndex.class,
+                CreateSequence.class, CreateTrigger.class, Grant.class),
+                schema.getStatements().stream().map(Object::getClass)
+                        .collect(java.util.stream.Collectors.toList()));
+        assertThat(new TablesNamesFinder().getTables(schema)).contains("t", "v");
+        assertThat(schema.getFeatures().getCertain()).containsExactly(StmtFeature.MODIFIES_SCHEMA);
+        assertTrue(new Validation(List.of(PostgresqlVersion.V10), schema.toString()).validate()
+                .isEmpty());
+        assertThat(new Validation(List.of(new FeaturesAllowed(Feature.createSchema)),
+                "CREATE SCHEMA app CREATE TABLE t (id int)").validate()).isNotEmpty();
+    }
+
+    @Test
+    void schemaElementsWithoutAName() throws JSQLParserException {
+        CreateSchema schema = roundTrip("CREATE SCHEMA AUTHORIZATION joe CREATE TABLE t (a int)");
+        assertNull(schema.getSchemaName());
+        assertEquals("t", ((CreateTable) schema.getStatements().get(0)).getTable().getName());
+    }
+
+    @Test
+    void grantRemainsAnAliasOutsideSchemaElements() throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t grant");
+        assertEquals(2, CCJSqlParserUtil
+                .parseStatements("CREATE SCHEMA s;\nCREATE TABLE t (a int);").size());
+    }
+
+    @Test
+    void rendersSchemaPathAndElements() throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed("CREATE SCHEMA s PATH a, b");
+        CreateSchema schema = new CreateSchema().withSchemaName("s");
+        schema.addStatement(CCJSqlParserUtil.parse("CREATE TABLE t (a int)"));
+        assertDeparse(schema, "CREATE SCHEMA s CREATE TABLE t (a int)");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "CREATE SCHEMA IF NOT EXISTS s CREATE TABLE t (a int)",
+            "CREATE SCHEMA s CREATE MATERIALIZED VIEW v AS SELECT 1",
+            "CREATE SCHEMA s CREATE FUNCTION f() RETURNS int AS 'SELECT 1' LANGUAGE sql",
+            "CREATE SCHEMA s CREATE SCHEMA t",
+            "CREATE SCHEMA s VIEW v AS SELECT 1",
+            "CREATE SCHEMA s CREATE TABLE t (a int) REVOKE SELECT ON t FROM u"})
+    void rejectsOtherSchemaElements(String sql) {
+        assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL));
+    }
 }
diff --git a/src/test/java/net/sf/jsqlparser/statement/reindex/ReindexTest.java b/src/test/java/net/sf/jsqlparser/statement/reindex/ReindexTest.java
new file mode 100644
index 000000000..c68ab2966
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/statement/reindex/ReindexTest.java
@@ -0,0 +1,166 @@
+/*-
+ * #%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.reindex;
+
+import static net.sf.jsqlparser.test.TestUtils.assertDeparse;
+import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
+import net.sf.jsqlparser.parser.CCJSqlParser;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.Statements;
+import net.sf.jsqlparser.statement.StmtFeature;
+import net.sf.jsqlparser.statement.UnsupportedStatement;
+import net.sf.jsqlparser.statement.reindex.Reindex.Option;
+import net.sf.jsqlparser.statement.reindex.Reindex.Target;
+import net.sf.jsqlparser.util.TablesNamesFinder;
+import net.sf.jsqlparser.util.validation.Validation;
+import net.sf.jsqlparser.util.validation.feature.MySqlVersion;
+import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class ReindexTest {
+    private static final Consumer<CCJSqlParser> POSTGRESQL =
+            parser -> parser.withDialect(Dialect.POSTGRESQL);
+
+    private static Reindex roundTrip(String sql) throws JSQLParserException {
+        Reindex reindex = assertInstanceOf(Reindex.class,
+                assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL));
+        assertEquals(sql, CCJSqlParserUtil.parse(reindex.toString(), POSTGRESQL).toString());
+        return reindex;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "REINDEX INDEX CONCURRENTLY idx",
+            "REINDEX TABLE users",
+            "REINDEX TABLE CONCURRENTLY app.users",
+            "REINDEX (VERBOSE) INDEX app.idx",
+            "REINDEX (VERBOSE false, TABLESPACE fast_space, CONCURRENTLY) SCHEMA app",
+            "REINDEX (CONCURRENTLY ON, VERBOSE 1) TABLE t",
+            "REINDEX (TABLESPACE 'pg_default') TABLE t",
+            "REINDEX SCHEMA CONCURRENTLY app",
+            "REINDEX DATABASE",
+            "REINDEX DATABASE CONCURRENTLY mydb",
+            "REINDEX SYSTEM",
+            "REINDEX SYSTEM mydb"})
+    void parsesReindexStatements(String sql) throws JSQLParserException {
+        roundTrip(sql);
+        assertInstanceOf(Reindex.class, CCJSqlParserUtil.parse(sql));
+        assertEquals(2, CCJSqlParserUtil.parseStatements(sql + ";\nSELECT 1", POSTGRESQL).size());
+    }
+
+    @Test
+    void keepsTargetNameAndOptions() throws JSQLParserException {
+        Reindex reindex =
+                roundTrip("REINDEX (VERBOSE, TABLESPACE fast_space) TABLE CONCURRENTLY app.users");
+
+        assertEquals(Target.TABLE, reindex.getTarget());
+        assertTrue(reindex.isConcurrently());
+        assertEquals("app.users", reindex.getName().getFullyQualifiedName());
+        assertEquals("app.users", reindex.getTable().getFullyQualifiedName());
+        assertEquals(2, reindex.getOptions().size());
+        assertEquals(Option.Name.VERBOSE, reindex.getOptions().get(0).getName());
+        assertNull(reindex.getOptions().get(0).getValue());
+        assertEquals(Option.Name.TABLESPACE, reindex.getOptions().get(1).getName());
+        assertEquals("fast_space", reindex.getOptions().get(1).getValue());
+    }
+
+    @Test
+    void namesOnlyTheReindexedObject() throws JSQLParserException {
+        Reindex index = roundTrip("REINDEX INDEX CONCURRENTLY idx");
+        assertEquals(Target.INDEX, index.getTarget());
+        assertEquals("idx", index.getName().getFullyQualifiedName());
+        assertNull(index.getTable());
+        assertTrue(new TablesNamesFinder().getTables((Statement) index).isEmpty());
+
+        Reindex database = roundTrip("REINDEX DATABASE");
+        assertEquals(Target.DATABASE, database.getTarget());
+        assertNull(database.getName());
+        assertFalse(database.isConcurrently());
+        assertTrue(database.getOptions().isEmpty());
+
+        assertThat(TablesNamesFinder.findTables("REINDEX TABLE app.users"))
+                .containsExactly("app.users");
+    }
+
+    @Test
+    void buildsAReindexStatement() {
+        Reindex reindex = new Reindex(Target.SCHEMA, new Table("app")).withConcurrently(true)
+                .addOptions(new Option(Option.Name.VERBOSE, null));
+
+        assertDeparse(reindex, "REINDEX (VERBOSE) SCHEMA CONCURRENTLY app");
+    }
+
+    @Test
+    void validationAndFeatures() throws JSQLParserException {
+        assertTrue(new Validation(List.of(PostgresqlVersion.V10), "REINDEX TABLE t").validate()
+                .isEmpty());
+        assertThat(new Validation(List.of(PostgresqlVersion.V10),
+                "REINDEX TABLE CONCURRENTLY t").validate()).isNotEmpty();
+        assertThat(new Validation(List.of(PostgresqlVersion.V10),
+                "REINDEX (CONCURRENTLY) TABLE t").validate()).isNotEmpty();
+        assertTrue(new Validation(List.of(PostgresqlVersion.V12),
+                "REINDEX TABLE CONCURRENTLY t").validate().isEmpty());
+        assertThat(new Validation(List.of(MySqlVersion.V8_0), "REINDEX TABLE t").validate())
+                .isNotEmpty();
+
+        assertThat(CCJSqlParserUtil.parse("REINDEX TABLE t").getFeatures().getCertain())
+                .containsExactlyInAnyOrder(StmtFeature.MODIFIES_SCHEMA, StmtFeature.READS_DATA);
+    }
+
+    @Test
+    void startsAStatementAmongUnsupportedStatements() throws JSQLParserException {
+        Statements statements = CCJSqlParserUtil.parseStatements(
+                "VACUUM t; REINDEX TABLE t; REINDEX t",
+                parser -> parser.withUnsupportedStatements(true));
+
+        assertEquals(3, statements.size());
+        assertInstanceOf(UnsupportedStatement.class, statements.get(0));
+        assertInstanceOf(Reindex.class, statements.get(1));
+        assertInstanceOf(UnsupportedStatement.class, statements.get(2));
+    }
+
+    @Test
+    void reindexRemainsAnIdentifier() throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed("SELECT reindex FROM reindex", false, POSTGRESQL);
+        assertSqlCanBeParsedAndDeparsed("CREATE TABLE reindex (reindex int)", false, POSTGRESQL);
+        assertSqlCanBeParsedAndDeparsed("ALTER TABLE t ADD COLUMN reindex int", false, POSTGRESQL);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "REINDEX TABLE",
+            "REINDEX SCHEMA",
+            "REINDEX INDEX CONCURRENTLY",
+            "REINDEX INDEX a, b",
+            "REINDEX VIEW v",
+            "REINDEX () TABLE t",
+            "REINDEX (FORCE) TABLE t",
+            "REINDEX (TABLESPACE) TABLE t",
+            "REINDEX SCHEMA app.sub"})
+    void rejectsInvalidReindexStatements(String sql) {
+        assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL));
+    }
+}
diff --git a/src/test/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabelTest.java b/src/test/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabelTest.java
new file mode 100644
index 000000000..211abadac
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/statement/securitylabel/SecurityLabelTest.java
@@ -0,0 +1,218 @@
+/*-
+ * #%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.securitylabel;
+
+import static net.sf.jsqlparser.test.TestUtils.assertDeparse;
+import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.expression.StringValue;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
+import net.sf.jsqlparser.parser.CCJSqlParser;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.RoutineReference;
+import net.sf.jsqlparser.statement.Statements;
+import net.sf.jsqlparser.statement.StmtFeature;
+import net.sf.jsqlparser.statement.UnsupportedStatement;
+import net.sf.jsqlparser.statement.securitylabel.SecurityLabel.ObjectType;
+import net.sf.jsqlparser.util.TablesNamesFinder;
+import net.sf.jsqlparser.util.deparser.ExpressionDeParser;
+import net.sf.jsqlparser.util.deparser.SelectDeParser;
+import net.sf.jsqlparser.util.deparser.StatementDeParser;
+import net.sf.jsqlparser.util.validation.Validation;
+import net.sf.jsqlparser.util.validation.feature.MySqlVersion;
+import net.sf.jsqlparser.util.validation.feature.PostgresqlVersion;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class SecurityLabelTest {
+    private static final Consumer<CCJSqlParser> POSTGRESQL =
+            parser -> parser.withDialect(Dialect.POSTGRESQL);
+
+    private static SecurityLabel roundTrip(String sql) throws JSQLParserException {
+        SecurityLabel label = assertInstanceOf(SecurityLabel.class,
+                assertSqlCanBeParsedAndDeparsed(sql, false, POSTGRESQL));
+        assertEquals(sql, CCJSqlParserUtil.parse(label.toString(), POSTGRESQL).toString());
+        return label;
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "SECURITY LABEL FOR selinux ON TABLE t1 IS 'system_u:object_r:sepgsql_table_t:s0'",
+            "SECURITY LABEL FOR 'dummy' ON TABLE app.t1 IS NULL",
+            "SECURITY LABEL ON COLUMN app.t1.c IS 'x'",
+            "SECURITY LABEL ON SEQUENCE app.s IS 'x'",
+            "SECURITY LABEL ON VIEW v IS 'x'",
+            "SECURITY LABEL ON MATERIALIZED VIEW app.mv IS 'x'",
+            "SECURITY LABEL ON FOREIGN TABLE ft IS 'x'",
+            "SECURITY LABEL ON FUNCTION app.f(int, text) IS 'x'",
+            "SECURITY LABEL ON FUNCTION f IS 'x'",
+            "SECURITY LABEL ON PROCEDURE p() IS 'x'",
+            "SECURITY LABEL ON ROUTINE r(IN a int) IS 'x'",
+            "SECURITY LABEL ON AGGREGATE agg(*) IS 'x'",
+            "SECURITY LABEL ON SCHEMA app IS 'x'",
+            "SECURITY LABEL ON DATABASE mydb IS 'x'",
+            "SECURITY LABEL ON ROLE app_user IS 'x'",
+            "SECURITY LABEL ON TABLESPACE fast_space IS 'x'",
+            "SECURITY LABEL ON DOMAIN app.positive IS 'x'",
+            "SECURITY LABEL ON TYPE app.mood IS 'x'",
+            "SECURITY LABEL ON EVENT TRIGGER etg IS 'x'",
+            "SECURITY LABEL ON LARGE OBJECT 16385 IS 'x'",
+            "SECURITY LABEL ON LANGUAGE plpgsql IS 'x'",
+            "SECURITY LABEL ON PROCEDURAL LANGUAGE plpgsql IS 'x'",
+            "SECURITY LABEL ON PUBLICATION pub IS 'x'",
+            "SECURITY LABEL ON SUBSCRIPTION sub IS 'x'"})
+    void parsesEveryDocumentedObjectKind(String sql) throws JSQLParserException {
+        roundTrip(sql);
+        assertInstanceOf(SecurityLabel.class, CCJSqlParserUtil.parse(sql));
+        assertEquals(2, CCJSqlParserUtil.parseStatements(sql + "; SELECT 1", POSTGRESQL).size());
+    }
+
+    @Test
+    void keepsProviderTargetAndLabel() throws JSQLParserException {
+        SecurityLabel label = roundTrip(
+                "SECURITY LABEL FOR selinux ON TABLE app.t1 IS 'system_u:object_r:sepgsql_table_t:s0'");
+        assertEquals("selinux", label.getProvider());
+        assertEquals(ObjectType.TABLE, label.getObjectType());
+        assertEquals("app.t1", label.getObjectName().getFullyQualifiedName());
+        assertEquals("system_u:object_r:sepgsql_table_t:s0", label.getLabel().getValue());
+
+        SecurityLabel column = roundTrip("SECURITY LABEL ON COLUMN app.t1.c IS NULL");
+        assertNull(column.getProvider());
+        assertEquals(ObjectType.COLUMN, column.getObjectType());
+        assertEquals("c", column.getColumn().getColumnName());
+        assertEquals("app.t1", column.getColumn().getTable().getFullyQualifiedName());
+        assertNull(column.getLabel());
+
+        SecurityLabel function = roundTrip("SECURITY LABEL ON FUNCTION f(int, text) IS 'x'");
+        assertEquals(ObjectType.FUNCTION, function.getObjectType());
+        assertEquals("f", function.getRoutine().getName());
+        assertEquals(2, function.getRoutine().getArguments().size());
+        assertNull(function.getObjectName());
+
+        SecurityLabel largeObject = roundTrip("SECURITY LABEL ON LARGE OBJECT 16385 IS 'x'");
+        assertEquals(ObjectType.LARGE_OBJECT, largeObject.getObjectType());
+        assertEquals(16385L, largeObject.getLargeObjectOid());
+
+        SecurityLabel language =
+                roundTrip("SECURITY LABEL ON PROCEDURAL LANGUAGE plpgsql IS 'x'");
+        assertEquals(ObjectType.LANGUAGE, language.getObjectType());
+        assertTrue(language.isProcedural());
+    }
+
+    @Test
+    void tableVisitorsSeeOnlyRelations() throws JSQLParserException {
+        assertThat(TablesNamesFinder.findTables("SECURITY LABEL ON TABLE app.t1 IS 'x'"))
+                .containsExactly("app.t1");
+        assertThat(TablesNamesFinder.findTables("SECURITY LABEL ON COLUMN app.t1.c IS 'x'"))
+                .containsExactly("app.t1");
+        assertThat(TablesNamesFinder.findTables("SECURITY LABEL ON FOREIGN TABLE ft IS 'x'"))
+                .containsExactly("ft");
+        for (String sql : List.of("SECURITY LABEL ON FUNCTION f(int) IS 'x'",
+                "SECURITY LABEL ON SCHEMA app IS 'x'", "SECURITY LABEL ON ROLE r IS 'x'",
+                "SECURITY LABEL ON TYPE app.t IS 'x'")) {
+            assertTrue(TablesNamesFinder.findTables(sql).isEmpty(), sql);
+        }
+    }
+
+    @Test
+    void settersSelectTheObjectType() {
+        SecurityLabel label = new SecurityLabel().withProvider("selinux")
+                .withObjectName(ObjectType.VIEW, new Table("app", "v"))
+                .withLabel(new StringValue("x"));
+        assertDeparse(label, "SECURITY LABEL FOR selinux ON VIEW app.v IS 'x'");
+
+        RoutineReference routine = new RoutineReference();
+        routine.setName("f");
+        label.setRoutine(ObjectType.PROCEDURE, routine);
+        assertNull(label.getObjectName());
+        assertDeparse(label, "SECURITY LABEL FOR selinux ON PROCEDURE f IS 'x'");
+
+        label.setColumn(new Column(new Table("t"), "c"));
+        assertNull(label.getRoutine());
+        label.setLabel(null);
+        assertDeparse(label, "SECURITY LABEL FOR selinux ON COLUMN t.c IS NULL");
+
+        assertThrows(IllegalArgumentException.class,
+                () -> label.setObjectName(ObjectType.FUNCTION, new Table("f")));
+        assertThrows(IllegalArgumentException.class,
+                () -> label.setRoutine(ObjectType.TABLE, routine));
+    }
+
+    @Test
+    void labelUsesTheExpressionDeparser() throws JSQLParserException {
+        SecurityLabel label = (SecurityLabel) CCJSqlParserUtil
+                .parse("SECURITY LABEL ON TABLE t IS 'before'");
+        StringBuilder output = new StringBuilder();
+        ExpressionDeParser expressions = new ExpressionDeParser() {
+            @Override
+            public <S> StringBuilder visit(StringValue value, S context) {
+                return getBuilder().append("'after'");
+            }
+        };
+        SelectDeParser selects = new SelectDeParser(expressions, output);
+        expressions.setBuilder(output);
+        expressions.setSelectVisitor(selects);
+        label.accept(new StatementDeParser(expressions, selects, output));
+        assertEquals("SECURITY LABEL ON TABLE t IS 'after'", output.toString());
+    }
+
+    @Test
+    void validationAndFeatures() throws JSQLParserException {
+        String sql = "SECURITY LABEL FOR selinux ON TABLE t1 IS 'x'";
+        assertTrue(new Validation(List.of(PostgresqlVersion.V10), sql).validate().isEmpty());
+        assertThat(new Validation(List.of(MySqlVersion.V8_0), sql).validate()).isNotEmpty();
+        assertThat(CCJSqlParserUtil.parse(sql).getFeatures().getCertain())
+                .containsExactly(StmtFeature.MODIFIES_SCHEMA);
+        assertFalse(CCJSqlParserUtil.parse(sql).getFeatures().may(StmtFeature.READS_DATA));
+    }
+
+    @Test
+    void wordsRemainIdentifiers() throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed("SELECT security, label FROM label", false, POSTGRESQL);
+    }
+
+    @Test
+    void startsAStatementAmongUnsupportedStatements() throws JSQLParserException {
+        Statements statements = CCJSqlParserUtil.parseStatements(
+                "VACUUM t; SECURITY LABEL ON TABLE t IS 'x'",
+                parser -> parser.withUnsupportedStatements(true));
+
+        assertEquals(2, statements.size());
+        assertInstanceOf(UnsupportedStatement.class, statements.get(0));
+        assertInstanceOf(SecurityLabel.class, statements.get(1));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "SECURITY LABEL ON TABLE t",
+            "SECURITY LABEL ON TABLE t IS 1",
+            "SECURITY LABEL ON INDEX i IS 'x'",
+            "SECURITY LABEL ON ROLE app.r IS 'x'",
+            "SECURITY LABEL ON AGGREGATE agg IS 'x'",
+            "SECURITY LABEL ON LARGE OBJECT lo IS 'x'",
+            "SECURITY LABEL FOR p IS 'x'",
+            "SECURITY TABLE t IS 'x'"})
+    void rejectsInvalidSecurityLabels(String sql) {
+        assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, POSTGRESQL));
+    }
+}