diff --git a/README.md b/README.md
index e7a8db452..2044e6835 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,7 @@ and missing syntax gets added on demand — [open an issue](https://github.com/J
 | **MySQL table maintenance** | `ANALYZE` · `CHECK` · `CHECKSUM` · `OPTIMIZE` · `REPAIR TABLE` |
 | **PostgreSQL maintenance** | `VACUUM` · `ANALYZE` · `CLUSTER` · `CHECKPOINT` |
 | **MySQL locks** | `LOCK TABLES` · `UNLOCK TABLES` · `LOCK INSTANCE FOR BACKUP` · `UNLOCK INSTANCE` |
+| **PostgreSQL cursors** | `DECLARE … CURSOR` · `FETCH` · `MOVE` · `CLOSE` |
 | **MySQL account management** | `CREATE`/`ALTER`/`RENAME USER` · `CREATE ROLE` · `SET ROLE` · `SET DEFAULT ROLE` · `SET PASSWORD` |
 | **Tablespaces** | MySQL and PostgreSQL `CREATE TABLESPACE` · `ALTER TABLESPACE` |
 | **PostgreSQL RLS** | `CREATE POLICY` · `ALTER TABLE … ENABLE`/`DISABLE`/`FORCE`/`NO FORCE ROW LEVEL SECURITY` |
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 dc3d137e3..e5652f2dd 100644
--- a/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
+++ b/src/main/java/net/sf/jsqlparser/parser/feature/Feature.java
@@ -47,6 +47,9 @@
 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.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.delete.Delete;
 import net.sf.jsqlparser.statement.drop.Drop;
 import net.sf.jsqlparser.statement.execute.Execute;
@@ -915,6 +918,24 @@ public enum Feature {
      * @see DeclareStatement
      */
     declare,
+    /**
+     * PostgreSQL "DECLARE name CURSOR FOR query" statement is allowed
+     *
+     * @see DeclareCursorStatement
+     */
+    declareCursor,
+    /**
+     * PostgreSQL "FETCH" and "MOVE" statements of a cursor are allowed
+     *
+     * @see FetchCursorStatement
+     */
+    fetchCursor,
+    /**
+     * PostgreSQL "CLOSE" statement of a cursor is allowed
+     *
+     * @see CloseCursorStatement
+     */
+    closeCursor,
 
     /** SQL Server local table variables in queries and DML targets. */
     tableVariable,
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
index df67903b0..31514e182 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementFeatureVisitor.java
@@ -84,6 +84,9 @@
 import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping;
 import net.sf.jsqlparser.statement.create.view.AlterView;
 import net.sf.jsqlparser.statement.create.view.CreateView;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.delete.Delete;
 import net.sf.jsqlparser.statement.drop.Drop;
 import net.sf.jsqlparser.statement.drop.DropPolicy;
@@ -981,6 +984,33 @@ public <S> Void visit(DeclareStatement declareStatement, S context) {
         return sessionOnly();
     }
 
+    @Override
+    public <S> Void visit(DeclareCursorStatement declareCursor, S context) {
+        // opens a cursor of the session over its query, which reads as the cursor is fetched
+        analysis.claimTopLevel();
+        analysis.certain(StmtFeature.MODIFIES_SESSION);
+        if (declareCursor.getQuery() != null) {
+            declareCursor.getQuery().accept(analysis.selects, context);
+        }
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(FetchCursorStatement fetchCursor, S context) {
+        // moves the cursor and runs its query that far; only FETCH returns the rows
+        if (analysis.claimTopLevel() && fetchCursor.getKind() == FetchCursorStatement.Kind.FETCH) {
+            analysis.certain(StmtFeature.RETURNS_RESULT_SET);
+        }
+        analysis.certain(StmtFeature.MODIFIES_SESSION);
+        analysis.possible(StmtFeature.READS_DATA);
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(CloseCursorStatement closeCursor, S context) {
+        return sessionOnly();
+    }
+
     @Override
     public <S> Void visit(AlterSystemStatement alterSystemStatement, 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 4063637f7..76370678c 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitor.java
@@ -111,6 +111,9 @@
 import net.sf.jsqlparser.statement.upsert.Upsert;
 import net.sf.jsqlparser.statement.create.macro.CreateMacro;
 import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.export.ExportDataStatement;
 import net.sf.jsqlparser.statement.load.LoadDataStatement;
 
@@ -720,6 +723,30 @@ default void visit(BackupLockStatement backupLock) {
         visit(backupLock, null);
     }
 
+    default <S> T visit(DeclareCursorStatement declareCursor, S context) {
+        return null;
+    }
+
+    default void visit(DeclareCursorStatement declareCursor) {
+        visit(declareCursor, null);
+    }
+
+    default <S> T visit(FetchCursorStatement fetchCursor, S context) {
+        return null;
+    }
+
+    default void visit(FetchCursorStatement fetchCursor) {
+        visit(fetchCursor, null);
+    }
+
+    default <S> T visit(CloseCursorStatement closeCursor, S context) {
+        return null;
+    }
+
+    default void visit(CloseCursorStatement closeCursor) {
+        visit(closeCursor, null);
+    }
+
     <S> T visit(CreatePolicy createPolicy, S context);
 
     default void visit(CreatePolicy createPolicy) {
diff --git a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
index 9cb08129e..f8b303fa1 100644
--- a/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
+++ b/src/main/java/net/sf/jsqlparser/statement/StatementVisitorAdapter.java
@@ -128,6 +128,9 @@
 import net.sf.jsqlparser.util.TableDefinitionTraversal;
 import net.sf.jsqlparser.statement.create.macro.CreateMacro;
 import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.export.ExportDataStatement;
 import net.sf.jsqlparser.statement.load.LoadDataStatement;
 
@@ -559,6 +562,24 @@ public <S> T visit(BackupLockStatement backupLock, S context) {
         return null;
     }
 
+    @Override
+    public <S> T visit(DeclareCursorStatement declareCursor, S context) {
+        if (declareCursor.getQuery() != null) {
+            declareCursor.getQuery().accept(selectVisitor, context);
+        }
+        return null;
+    }
+
+    @Override
+    public <S> T visit(FetchCursorStatement fetchCursor, S context) {
+        return null;
+    }
+
+    @Override
+    public <S> T visit(CloseCursorStatement closeCursor, S context) {
+        return null;
+    }
+
     @Override
     public <S> T visit(CreatePolicy createPolicy, S context) {
         fromItemVisitor.visitFromItem(createPolicy.getTable(), context);
diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/CloseCursorStatement.java b/src/main/java/net/sf/jsqlparser/statement/cursor/CloseCursorStatement.java
new file mode 100644
index 000000000..06a5cacb1
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/cursor/CloseCursorStatement.java
@@ -0,0 +1,64 @@
+/*-
+ * #%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.cursor;
+
+import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+
+/**
+ * PostgreSQL {@code CLOSE {name | ALL}}, which closes one cursor or every open cursor of the
+ * session.<br>
+ * Examples:<br>
+ * CLOSE c<br>
+ * CLOSE ALL<br>
+ *
+ * @see <a href="https://www.postgresql.org/docs/18/sql-close.html">PostgreSQL CLOSE</a>
+ */
+public class CloseCursorStatement extends ASTNodeAccessImpl implements Statement {
+    private String cursorName;
+
+    /** CLOSE ALL. */
+    public CloseCursorStatement() {}
+
+    public CloseCursorStatement(String cursorName) {
+        this.cursorName = cursorName;
+    }
+
+    /** Returns null for CLOSE ALL. */
+    public String getCursorName() {
+        return cursorName;
+    }
+
+    /** A null name makes the statement CLOSE ALL. */
+    public void setCursorName(String cursorName) {
+        this.cursorName = cursorName;
+    }
+
+    /** Whether the statement is CLOSE ALL, which is when it has no cursor name. */
+    public boolean isAll() {
+        return cursorName == null;
+    }
+
+    @Override
+    public StringBuilder appendTo(StringBuilder builder) {
+        return builder.append("CLOSE ").append(isAll() ? "ALL" : cursorName);
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/CursorOption.java b/src/main/java/net/sf/jsqlparser/statement/cursor/CursorOption.java
new file mode 100644
index 000000000..dc36372ba
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/cursor/CursorOption.java
@@ -0,0 +1,44 @@
+/*-
+ * #%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.cursor;
+
+/**
+ * An option of PostgreSQL's {@code DECLARE name [options] CURSOR}. PostgreSQL's grammar takes them
+ * in any order and repeated; the server rejects contradicting ones such as SCROLL and NO SCROLL
+ * when it runs the statement.
+ *
+ * @see <a href="https://www.postgresql.org/docs/18/sql-declare.html">PostgreSQL DECLARE</a>
+ */
+public enum CursorOption {
+    /** Returns the rows in binary rather than text format. */
+    BINARY("BINARY"),
+
+    /** Leaves the visibility of later changes to the implementation. */
+    ASENSITIVE("ASENSITIVE"),
+
+    /** Hides later changes; PostgreSQL's cursors are always insensitive. */
+    INSENSITIVE("INSENSITIVE"),
+
+    /** Allows fetching backward. */
+    SCROLL("SCROLL"),
+
+    /** Forbids fetching backward. */
+    NO_SCROLL("NO SCROLL");
+
+    private final String keyword;
+
+    CursorOption(String keyword) {
+        this.keyword = keyword;
+    }
+
+    public String getKeyword() {
+        return keyword;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/DeclareCursorStatement.java b/src/main/java/net/sf/jsqlparser/statement/cursor/DeclareCursorStatement.java
new file mode 100644
index 000000000..87ca339dc
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/cursor/DeclareCursorStatement.java
@@ -0,0 +1,129 @@
+/*-
+ * #%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.cursor;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+import net.sf.jsqlparser.statement.select.Select;
+
+/**
+ * PostgreSQL {@code DECLARE name [BINARY] [ASENSITIVE | INSENSITIVE] [[NO] SCROLL] CURSOR
+ * [{WITH | WITHOUT} HOLD] FOR query}, which defines a cursor over a SELECT, VALUES or TABLE query.
+ * <br>
+ * Example:<br>
+ * DECLARE c SCROLL CURSOR WITH HOLD FOR SELECT * FROM t<br>
+ * It is not the SQL Server {@link net.sf.jsqlparser.statement.DeclareStatement DECLARE @variable}.
+ *
+ * @see <a href="https://www.postgresql.org/docs/18/sql-declare.html">PostgreSQL DECLARE</a>
+ */
+public class DeclareCursorStatement extends ASTNodeAccessImpl implements Statement {
+    private String cursorName;
+    private final List<CursorOption> options = new ArrayList<>();
+    private Holdability holdability;
+    private Select query;
+
+    public enum Holdability {
+        WITH_HOLD("WITH HOLD"), WITHOUT_HOLD("WITHOUT HOLD");
+
+        private final String keywords;
+
+        Holdability(String keywords) {
+            this.keywords = keywords;
+        }
+
+        public String getKeywords() {
+            return keywords;
+        }
+    }
+
+    public DeclareCursorStatement() {}
+
+    public DeclareCursorStatement(String cursorName, Select query) {
+        this.cursorName = cursorName;
+        this.query = query;
+    }
+
+    public String getCursorName() {
+        return cursorName;
+    }
+
+    public void setCursorName(String cursorName) {
+        this.cursorName = cursorName;
+    }
+
+    /** The options between the name and CURSOR, in their order; the list is live. */
+    public List<CursorOption> getOptions() {
+        return options;
+    }
+
+    public void setOptions(List<CursorOption> options) {
+        this.options.clear();
+        if (options != null) {
+            this.options.addAll(options);
+        }
+    }
+
+    public DeclareCursorStatement addOptions(CursorOption... options) {
+        this.options.addAll(Arrays.asList(options));
+        return this;
+    }
+
+    /** Returns null when neither WITH HOLD nor WITHOUT HOLD is written. */
+    public Holdability getHoldability() {
+        return holdability;
+    }
+
+    public void setHoldability(Holdability holdability) {
+        this.holdability = holdability;
+    }
+
+    public Select getQuery() {
+        return query;
+    }
+
+    public void setQuery(Select query) {
+        this.query = query;
+    }
+
+    @Override
+    public StringBuilder appendTo(StringBuilder builder) {
+        return appendTo(builder, builder::append);
+    }
+
+    /** Renders the query through the caller's select writer. */
+    public StringBuilder appendTo(StringBuilder builder, Consumer<Select> queryPrinter) {
+        builder.append("DECLARE ").append(cursorName);
+        for (CursorOption option : options) {
+            builder.append(' ').append(option.getKeyword());
+        }
+        builder.append(" CURSOR");
+        if (holdability != null) {
+            builder.append(' ').append(holdability.getKeywords());
+        }
+        builder.append(" FOR ");
+        queryPrinter.accept(query);
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/FetchCursorStatement.java b/src/main/java/net/sf/jsqlparser/statement/cursor/FetchCursorStatement.java
new file mode 100644
index 000000000..46f1f30c2
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/cursor/FetchCursorStatement.java
@@ -0,0 +1,140 @@
+/*-
+ * #%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.cursor;
+
+import java.util.Objects;
+import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementVisitor;
+
+/**
+ * PostgreSQL {@code FETCH [direction] [FROM | IN] cursor} and {@code MOVE}, which takes the same
+ * arguments but returns no rows. The direction is an optional {@link FetchDirection} keyword
+ * followed by a count or ALL where the keyword allows one.<br>
+ * Examples:<br>
+ * FETCH NEXT FROM c<br>
+ * FETCH FORWARD ALL IN c<br>
+ * MOVE ABSOLUTE -1 c<br>
+ * FETCH 5 c<br>
+ *
+ * @see <a href="https://www.postgresql.org/docs/18/sql-fetch.html">PostgreSQL FETCH</a>
+ * @see <a href="https://www.postgresql.org/docs/18/sql-move.html">PostgreSQL MOVE</a>
+ */
+public class FetchCursorStatement extends ASTNodeAccessImpl implements Statement {
+    private Kind kind = Kind.FETCH;
+    private FetchDirection direction;
+    private Long count;
+    private boolean all;
+    private FromKeyword fromKeyword;
+    private String cursorName;
+
+    public enum Kind {
+        FETCH, MOVE
+    }
+
+    /** The FROM or IN before the cursor name. */
+    public enum FromKeyword {
+        FROM, IN
+    }
+
+    public FetchCursorStatement() {}
+
+    public FetchCursorStatement(Kind kind, String cursorName) {
+        setKind(kind);
+        this.cursorName = cursorName;
+    }
+
+    public Kind getKind() {
+        return kind;
+    }
+
+    public void setKind(Kind kind) {
+        this.kind = Objects.requireNonNull(kind);
+    }
+
+    /** Returns null when the statement has no direction keyword, as in FETCH 5 c or FETCH c. */
+    public FetchDirection getDirection() {
+        return direction;
+    }
+
+    public void setDirection(FetchDirection direction) {
+        this.direction = direction;
+    }
+
+    /** The signed count of ABSOLUTE, RELATIVE, FORWARD, BACKWARD or of a bare count, or null. */
+    public Long getCount() {
+        return count;
+    }
+
+    /** Setting a count clears {@link #isAll()}. */
+    public void setCount(Long count) {
+        this.count = count;
+        if (count != null) {
+            all = false;
+        }
+    }
+
+    /** Whether the direction is ALL, FORWARD ALL or BACKWARD ALL. */
+    public boolean isAll() {
+        return all;
+    }
+
+    /** Setting true clears {@link #getCount()}. */
+    public void setAll(boolean all) {
+        this.all = all;
+        if (all) {
+            count = null;
+        }
+    }
+
+    /** Returns null when neither FROM nor IN precedes the cursor name. */
+    public FromKeyword getFromKeyword() {
+        return fromKeyword;
+    }
+
+    public void setFromKeyword(FromKeyword fromKeyword) {
+        this.fromKeyword = fromKeyword;
+    }
+
+    public String getCursorName() {
+        return cursorName;
+    }
+
+    public void setCursorName(String cursorName) {
+        this.cursorName = cursorName;
+    }
+
+    @Override
+    public StringBuilder appendTo(StringBuilder builder) {
+        builder.append(kind.name());
+        if (direction != null) {
+            builder.append(' ').append(direction.name());
+        }
+        if (all) {
+            builder.append(" ALL");
+        } else if (count != null) {
+            builder.append(' ').append(count);
+        }
+        if (fromKeyword != null) {
+            builder.append(' ').append(fromKeyword.name());
+        }
+        return builder.append(' ').append(cursorName);
+    }
+
+    @Override
+    public String toString() {
+        return appendTo(new StringBuilder()).toString();
+    }
+
+    @Override
+    public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
+        return statementVisitor.visit(this, context);
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/cursor/FetchDirection.java b/src/main/java/net/sf/jsqlparser/statement/cursor/FetchDirection.java
new file mode 100644
index 000000000..a409acb7d
--- /dev/null
+++ b/src/main/java/net/sf/jsqlparser/statement/cursor/FetchDirection.java
@@ -0,0 +1,31 @@
+/*-
+ * #%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.cursor;
+
+/**
+ * The direction keyword of PostgreSQL's {@code FETCH} and {@code MOVE}. ABSOLUTE and RELATIVE take
+ * a count, FORWARD and BACKWARD take an optional count or ALL, and the others take neither. Without
+ * a keyword, a count or ALL alone fetches forward.
+ *
+ * @see <a href="https://www.postgresql.org/docs/18/sql-fetch.html">PostgreSQL FETCH</a>
+ */
+public enum FetchDirection {
+    NEXT, PRIOR, FIRST, LAST, ABSOLUTE, RELATIVE, FORWARD, BACKWARD;
+
+    /** Whether a count must follow: ABSOLUTE n and RELATIVE n. */
+    public boolean isCountRequired() {
+        return this == ABSOLUTE || this == RELATIVE;
+    }
+
+    /** Whether a count or ALL may follow: FORWARD and BACKWARD. */
+    public boolean isCountOptional() {
+        return this == FORWARD || this == BACKWARD;
+    }
+}
diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
index e1cf00f3f..b5e0591b0 100644
--- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
+++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -173,6 +173,9 @@
 import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping;
 import net.sf.jsqlparser.statement.create.view.AlterView;
 import net.sf.jsqlparser.statement.create.view.CreateView;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.delete.Delete;
 import net.sf.jsqlparser.statement.delete.ParenthesedDelete;
 import net.sf.jsqlparser.statement.drop.Drop;
@@ -3092,6 +3095,25 @@ public <S> Void visit(BackupLockStatement backupLock, S context) {
         return null;
     }
 
+    @Override
+    public <S> Void visit(DeclareCursorStatement declareCursor, S context) {
+        if (declareCursor.getQuery() != null) {
+            visit(declareCursor.getQuery(), context);
+        }
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(FetchCursorStatement fetchCursor, S context) {
+        // FETCH and MOVE name a cursor, not a table
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(CloseCursorStatement closeCursor, S context) {
+        return null;
+    }
+
     @Override
     public <S> Void visit(CreatePolicy createPolicy, S context) {
         if (createPolicy.getTable() != 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 0e9adaba3..2104efe3d 100644
--- a/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
+++ b/src/main/java/net/sf/jsqlparser/util/deparser/StatementDeParser.java
@@ -153,6 +153,9 @@
 import net.sf.jsqlparser.statement.CopyStatement;
 import net.sf.jsqlparser.statement.create.macro.CreateMacro;
 import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.AssertStatement;
 import net.sf.jsqlparser.statement.export.ExportDataStatement;
 import net.sf.jsqlparser.statement.load.LoadDataStatement;
@@ -835,6 +838,22 @@ public <S> StringBuilder visit(BackupLockStatement backupLock, S context) {
         return backupLock.appendTo(builder);
     }
 
+    @Override
+    public <S> StringBuilder visit(DeclareCursorStatement declareCursor, S context) {
+        return declareCursor.appendTo(builder,
+                query -> query.accept((SelectVisitor<?>) selectDeParser, context));
+    }
+
+    @Override
+    public <S> StringBuilder visit(FetchCursorStatement fetchCursor, S context) {
+        return fetchCursor.appendTo(builder);
+    }
+
+    @Override
+    public <S> StringBuilder visit(CloseCursorStatement closeCursor, S context) {
+        return closeCursor.appendTo(builder);
+    }
+
     @Override
     public <S> StringBuilder visit(CreatePolicy createPolicy, S context) {
         new CreatePolicyDeParser(expressionDeParser, builder).deParse(createPolicy);
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 0600b1242..cdc3185e8 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
@@ -154,6 +154,12 @@ public enum PostgresqlVersion implements Version {
                     // https://www.postgresql.org/docs/current/sql-lock.html
                     Feature.copy, Feature.prepare, Feature.deallocate, Feature.lock,
 
+                    // https://www.postgresql.org/docs/current/sql-declare.html
+                    // https://www.postgresql.org/docs/current/sql-fetch.html
+                    // https://www.postgresql.org/docs/current/sql-move.html
+                    // https://www.postgresql.org/docs/current/sql-close.html
+                    Feature.declareCursor, Feature.fetchCursor, Feature.closeCursor,
+
                     // https://www.postgresql.org/docs/current/sql-alterfunction.html
                     // https://www.postgresql.org/docs/current/sql-alterprocedure.html
                     // https://www.postgresql.org/docs/current/sql-alterroutine.html
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 ec1b85f29..05d14658a 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
@@ -158,6 +158,9 @@
 import net.sf.jsqlparser.statement.CopyStatement;
 import net.sf.jsqlparser.statement.create.macro.CreateMacro;
 import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
 import net.sf.jsqlparser.statement.AssertStatement;
 import net.sf.jsqlparser.statement.export.ExportDataStatement;
 import net.sf.jsqlparser.statement.load.LoadDataStatement;
@@ -843,6 +846,27 @@ public <S> Void visit(BackupLockStatement backupLock, S context) {
         return null;
     }
 
+    @Override
+    public <S> Void visit(DeclareCursorStatement declareCursor, S context) {
+        validateFeature(Feature.declareCursor);
+        if (declareCursor.getQuery() != null) {
+            visit(declareCursor.getQuery(), context);
+        }
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(FetchCursorStatement fetchCursor, S context) {
+        validateFeature(Feature.fetchCursor);
+        return null;
+    }
+
+    @Override
+    public <S> Void visit(CloseCursorStatement closeCursor, S context) {
+        validateFeature(Feature.closeCursor);
+        return null;
+    }
+
     public void visit(CreateIndex createIndex) {
         visit(createIndex, null);
     }
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
index 4cf410188..f9e8a2fc2 100644
--- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
+++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -103,6 +103,11 @@ import net.sf.jsqlparser.statement.role.*;
 import net.sf.jsqlparser.statement.imprt.*;
 import net.sf.jsqlparser.statement.export.*;
 import net.sf.jsqlparser.statement.lock.*;
+import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
+import net.sf.jsqlparser.statement.cursor.CursorOption;
+import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
+import net.sf.jsqlparser.statement.cursor.FetchDirection;
 import java.util.*;
 import java.util.AbstractMap.SimpleEntry;
 import java.util.concurrent.CancellationException;
@@ -176,6 +181,8 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
                 return isPostgreSqlMaintenanceAhead();
             case K_UNLOCK:
                 return isUnlockTablesAhead() || isBackupLockAhead();
+            case K_FETCH: case K_MOVE: case K_CLOSE:
+                return isCursorStatementAhead();
             case K_IMPORT: case K_EXPORT:
                 return Dialect.EXASOL.name().equals(getAsString(Feature.dialect))
                     || next.kind == K_EXPORT && getToken(2).kind == K_DATA;
@@ -2616,6 +2623,15 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             "TO", "TRAILING", "TRUE", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", "WHEN", "WHERE",
             "WINDOW", "WITH"));
 
+    /**
+     * PostgreSQL 18's type and function name keywords. Like its reserved keywords, its grammar
+     * takes none of them as a column identifier (ColId).
+     */
+    private static final Set<String> POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS = new HashSet<String>(Arrays.asList(
+            "AUTHORIZATION", "BINARY", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA",
+            "FREEZE", "FULL", "ILIKE", "INNER", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", "NATURAL",
+            "NOTNULL", "OUTER", "OVERLAPS", "RIGHT", "SIMILAR", "TABLESAMPLE", "VERBOSE"));
+
     /** Rejects an unquoted utility option name or word value that PostgreSQL reserves. */
     private void requireUtilityOptionWord(String word, boolean name) throws ParseException {
         String upper = word.toUpperCase(Locale.ROOT);
@@ -2678,6 +2694,163 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
                 || "*".equals(token.image) : token.kind == K_USING || token.kind == K_ON;
     }
 
+    /** The direction words of FETCH and MOVE that the grammar has no token for. */
+    private static final Set<String> FETCH_DIRECTION_WORDS = new HashSet<String>(Arrays.asList(
+            "ABSOLUTE", "RELATIVE", "FORWARD", "BACKWARD"));
+
+    /** The cursor options of DECLARE that the grammar has no token for. */
+    private static final Set<String> CURSOR_OPTION_WORDS = new HashSet<String>(Arrays.asList(
+            "SCROLL", "ASENSITIVE", "INSENSITIVE"));
+
+    /**
+     * Whether a PostgreSQL FETCH, MOVE or CLOSE statement starts here. The PostgreSQL dialect
+     * always reads these words as cursor statements, and other dialects never do. Without a
+     * dialect the whole statement must take the PostgreSQL form, so that other products' variants
+     * such as FETCH NEXT FROM c INTO @x or CLOSE GLOBAL c stay unsupported statements.
+     */
+    private boolean isCursorStatementAhead() {
+        int kind = getToken(1).kind;
+        if (kind != K_FETCH && kind != K_MOVE && kind != K_CLOSE) {
+            return false;
+        }
+        String dialect = getAsString(Feature.dialect);
+        if (dialect != null) {
+            return Dialect.POSTGRESQL.name().equals(dialect);
+        }
+        int offset = 2;
+        if (kind == K_CLOSE && getToken(offset).kind == K_ALL) {
+            return isCursorStatementEnd(getToken(offset + 1));
+        }
+        if (kind != K_CLOSE) {
+            offset = skipFetchDirection(offset);
+            if (offset < 0) {
+                return false;
+            }
+            if (getToken(offset).kind == K_FROM || getToken(offset).kind == K_IN) {
+                offset++;
+            }
+        }
+        return isCursorNameToken(getToken(offset)) && isCursorStatementEnd(getToken(offset + 1));
+    }
+
+    private static boolean isCursorStatementEnd(Token token) {
+        return token.kind == EOF || token.kind == ST_SEMICOLON;
+    }
+
+    /** Whether the token can name a cursor: PostgreSQL takes any column identifier (ColId). */
+    private static boolean isCursorNameToken(Token token) {
+        if (!isIdentifierishNameToken(token)) {
+            return false;
+        }
+        String word = token.image.toUpperCase(Locale.ROOT);
+        return !POSTGRESQL_RESERVED_KEYWORDS.contains(word)
+                && !POSTGRESQL_TYPE_FUNC_NAME_KEYWORDS.contains(word);
+    }
+
+    /**
+     * Whether a FETCH or MOVE direction starts at the offset. As in PostgreSQL's grammar, a
+     * direction word right before the end of the statement is the cursor name, as in FETCH next.
+     */
+    private boolean isFetchDirectionAt(int offset) {
+        Token token = getToken(offset);
+        if (token.kind == K_ALL || isFetchCountAt(offset)) {
+            return true;
+        }
+        boolean word = token.kind == K_NEXT || token.kind == K_PRIOR || token.kind == K_FIRST
+                || token.kind == K_LAST || token.kind == S_IDENTIFIER
+                        && FETCH_DIRECTION_WORDS.contains(token.image.toUpperCase(Locale.ROOT));
+        return word && !isCursorStatementEnd(getToken(offset + 1));
+    }
+
+    /** Whether a FETCH or MOVE count, an integer with an optional sign, starts at the offset. */
+    private boolean isFetchCountAt(int offset) {
+        Token token = getToken(offset);
+        return token.kind == S_LONG || ("+".equals(token.image) || "-".equals(token.image))
+                && getToken(offset + 1).kind == S_LONG;
+    }
+
+    private int skipFetchCount(int offset) {
+        return getToken(offset).kind == S_LONG ? offset + 1 : offset + 2;
+    }
+
+    /**
+     * The offset after the FETCH or MOVE direction at the offset, the offset itself without a
+     * direction, or -1 when ABSOLUTE or RELATIVE lacks its count.
+     */
+    private int skipFetchDirection(int offset) {
+        if (!isFetchDirectionAt(offset)) {
+            return offset;
+        }
+        if (getToken(offset).kind == K_ALL) {
+            return offset + 1;
+        }
+        if (isFetchCountAt(offset)) {
+            return skipFetchCount(offset);
+        }
+        String word = getToken(offset).image.toUpperCase(Locale.ROOT);
+        int next = offset + 1;
+        if ("ABSOLUTE".equals(word) || "RELATIVE".equals(word)) {
+            return isFetchCountAt(next) ? skipFetchCount(next) : -1;
+        }
+        if ("FORWARD".equals(word) || "BACKWARD".equals(word)) {
+            if (getToken(next).kind == K_ALL) {
+                return next + 1;
+            }
+            if (isFetchCountAt(next)) {
+                return skipFetchCount(next);
+            }
+        }
+        return next;
+    }
+
+    /**
+     * A FETCH or MOVE count. PostgreSQL's grammar takes a 32-bit integer; a larger one is a
+     * numeric constant there and a syntax error.
+     */
+    private Long fetchCount(Token sign, Token digits) throws ParseException {
+        String value = digits.image.replaceFirst("^0+(?=.)", "");
+        requireDdlSyntax(value.length() < 10 || value.length() == 10 && value.compareTo("2147483647") <= 0,
+                "A FETCH or MOVE count must be a 32-bit integer: " + digits.image);
+        long count = Long.parseLong(value);
+        return sign != null && "-".equals(sign.image) ? -count : count;
+    }
+
+    /**
+     * Whether a PostgreSQL DECLARE ... CURSOR starts here rather than the SQL Server DECLARE of a
+     * variable. The PostgreSQL dialect reads every DECLARE of a name as a cursor; without a dialect
+     * the name, the cursor options and CURSOR must follow. Other dialects keep their readings.
+     */
+    private boolean isDeclareCursorAhead() {
+        if (getToken(1).kind != K_DECLARE || getToken(2).kind == S_AT_IDENTIFIER) {
+            return false;
+        }
+        String dialect = getAsString(Feature.dialect);
+        if (dialect != null) {
+            return Dialect.POSTGRESQL.name().equals(dialect);
+        }
+        int offset = 3;
+        while (isCursorOptionAt(offset)) {
+            offset += getToken(offset).kind == K_NO ? 2 : 1;
+        }
+        Token cursor = getToken(offset);
+        return isCursorNameToken(getToken(2)) && cursor.kind == S_IDENTIFIER
+                && "CURSOR".equalsIgnoreCase(cursor.image);
+    }
+
+    /** Whether a DECLARE cursor option starts at the offset: BINARY, [NO] SCROLL or a sensitivity. */
+    private boolean isCursorOptionAt(int offset) {
+        Token token = getToken(offset);
+        if (token.kind == K_BINARY) {
+            return true;
+        }
+        if (token.kind == K_NO) {
+            Token next = getToken(offset + 1);
+            return next.kind == S_IDENTIFIER && "SCROLL".equalsIgnoreCase(next.image);
+        }
+        return token.kind == S_IDENTIFIER
+                && CURSOR_OPTION_WORDS.contains(token.image.toUpperCase(Locale.ROOT));
+    }
+
     /**
      * Whether VERBOSE is the PostgreSQL option of ANALYZE. Without a dialect a table name must
      * follow, so ANALYZE verbose still analyzes a table named verbose; other dialects keep that
@@ -4412,6 +4585,7 @@ String NonReservedWordPart2() :
       | tk=<K_MODE: "MODE">
       | tk=<K_MODULUS: "MODULUS">
       | tk=<K_MODIFY: "MODIFY">
+      | tk=<K_MOVE: "MOVE">
       | tk=<K_MOVEMENT: "MOVEMENT">
       | tk=<K_NAMES:"NAMES">
       | tk=<K_NAME:"NAME">
@@ -5283,6 +5457,11 @@ Statement SingleStatement() :
             |
             stm = Explain()
             |
+            LOOKAHEAD({ isDeclareCursorAhead() }) stm = DeclareCursorStatement()
+            |
+            LOOKAHEAD({ isCursorStatementAhead() })
+            ( stm = FetchCursorStatement() | stm = CloseCursorStatement() )
+            |
             stm = Declare()
             |
             stm = Grant()
@@ -6671,6 +6850,134 @@ DeclareStatement Declare(): {
     }
 }
 
+// https://www.postgresql.org/docs/18/sql-declare.html
+DeclareCursorStatement DeclareCursorStatement():
+{
+    DeclareCursorStatement statement = new DeclareCursorStatement();
+    String name;
+    CursorOption option;
+    Select query;
+}
+{
+    <K_DECLARE> name=CursorName() { statement.setCursorName(name); }
+    ( LOOKAHEAD({ isCursorOptionAt(1) }) option=CursorOption() { statement.getOptions().add(option); } )*
+    ContextualKeyword("CURSOR")
+    [
+        <K_WITH> ContextualKeyword("HOLD")
+        { statement.setHoldability(DeclareCursorStatement.Holdability.WITH_HOLD); }
+        |
+        <K_WITHOUT> ContextualKeyword("HOLD")
+        { statement.setHoldability(DeclareCursorStatement.Holdability.WITHOUT_HOLD); }
+    ]
+    <K_FOR> query=Select() { statement.setQuery(query); }
+    { return statement; }
+}
+
+/** Only used where isCursorOptionAt(1) holds, which limits the identifier to the option words. */
+CursorOption CursorOption():
+{ Token token; CursorOption option; }
+{
+    (
+        <K_BINARY> { option = CursorOption.BINARY; }
+        |
+        <K_NO> ContextualKeyword("SCROLL") { option = CursorOption.NO_SCROLL; }
+        |
+        token=<S_IDENTIFIER> { option = CursorOption.valueOf(token.image.toUpperCase(Locale.ROOT)); }
+    )
+    { return option; }
+}
+
+/** A cursor name: any name but the words PostgreSQL reserves or keeps for types and functions. */
+String CursorName():
+{ Token token = getToken(1); String name; }
+{
+    name=RelObjectName()
+    {
+        requireDdlSyntax(isCursorNameToken(token), "Invalid cursor name: " + token.image);
+        return name;
+    }
+}
+
+// https://www.postgresql.org/docs/18/sql-fetch.html
+// https://www.postgresql.org/docs/18/sql-move.html
+FetchCursorStatement FetchCursorStatement():
+{
+    FetchCursorStatement statement = new FetchCursorStatement();
+    String name;
+}
+{
+    ( <K_FETCH> | <K_MOVE> { statement.setKind(FetchCursorStatement.Kind.MOVE); } )
+    [ LOOKAHEAD({ isFetchDirectionAt(1) }) FetchCursorDirection(statement) ]
+    [
+        LOOKAHEAD({ getToken(1).kind == K_FROM || getToken(1).kind == K_IN })
+        (
+            <K_FROM> { statement.setFromKeyword(FetchCursorStatement.FromKeyword.FROM); }
+            |
+            <K_IN> { statement.setFromKeyword(FetchCursorStatement.FromKeyword.IN); }
+        )
+    ]
+    name=CursorName() { statement.setCursorName(name); }
+    { return statement; }
+}
+
+/** Only used where isFetchDirectionAt(1) holds. */
+void FetchCursorDirection(FetchCursorStatement statement):
+{ Token token; Long count; }
+{
+    (
+        <K_NEXT> { statement.setDirection(FetchDirection.NEXT); }
+        |
+        <K_PRIOR> { statement.setDirection(FetchDirection.PRIOR); }
+        |
+        <K_FIRST> { statement.setDirection(FetchDirection.FIRST); }
+        |
+        <K_LAST> { statement.setDirection(FetchDirection.LAST); }
+        |
+        <K_ALL> { statement.setAll(true); }
+        |
+        count=FetchCount() { statement.setCount(count); }
+        |
+        // ABSOLUTE n or RELATIVE n
+        LOOKAHEAD({ isKeywordAhead("ABSOLUTE") || isKeywordAhead("RELATIVE") })
+        token=<S_IDENTIFIER> count=FetchCount()
+        {
+            statement.setDirection(FetchDirection.valueOf(token.image.toUpperCase(Locale.ROOT)));
+            statement.setCount(count);
+        }
+        |
+        // FORWARD or BACKWARD [n | ALL]
+        token=<S_IDENTIFIER>
+        { statement.setDirection(FetchDirection.valueOf(token.image.toUpperCase(Locale.ROOT))); }
+        [
+            LOOKAHEAD({ getToken(1).kind == K_ALL || isFetchCountAt(1) })
+            ( <K_ALL> { statement.setAll(true); } | count=FetchCount() { statement.setCount(count); } )
+        ]
+    )
+}
+
+Long FetchCount():
+{ Token sign = null; Token digits; }
+{
+    [ sign="+" | sign="-" ] digits=<S_LONG>
+    { return fetchCount(sign, digits); }
+}
+
+// https://www.postgresql.org/docs/18/sql-close.html
+CloseCursorStatement CloseCursorStatement():
+{
+    CloseCursorStatement statement = new CloseCursorStatement();
+    String name;
+}
+{
+    <K_CLOSE>
+    (
+        LOOKAHEAD({ getToken(1).kind == K_ALL }) <K_ALL>
+        |
+        name=CursorName() { statement.setCursorName(name); }
+    )
+    { return statement; }
+}
+
 SessionStatement SessionStatement():
 {
     SessionStatement sessionsStatement;
diff --git a/src/site/sphinx/index.rst b/src/site/sphinx/index.rst
index e0ff2d8a4..4202458a3 100644
--- a/src/site/sphinx/index.rst
+++ b/src/site/sphinx/index.rst
@@ -164,6 +164,8 @@ One grammar covers the SQL standard plus all major RDBMS. Missing syntax gets ad
       - ``VACUUM`` · ``ANALYZE`` · ``CLUSTER`` · ``CHECKPOINT``
     * - **MySQL locks**
       - ``LOCK TABLES`` · ``UNLOCK TABLES`` · ``LOCK INSTANCE FOR BACKUP`` · ``UNLOCK INSTANCE``
+    * - **PostgreSQL cursors**
+      - ``DECLARE … CURSOR`` · ``FETCH`` · ``MOVE`` · ``CLOSE``
     * - **MySQL account management**
       - ``CREATE``/``ALTER``/``RENAME USER`` · ``CREATE ROLE`` · ``SET ROLE`` · ``SET DEFAULT ROLE`` · ``SET PASSWORD``
     * - **Tablespaces**
diff --git a/src/site/sphinx/usage.rst b/src/site/sphinx/usage.rst
index 93bee3339..d5622b054 100644
--- a/src/site/sphinx/usage.rst
+++ b/src/site/sphinx/usage.rst
@@ -2606,6 +2606,61 @@ Table visitors report the locked tables but not their aliases. Validators report
 three, MariaDB the first two, and PostgreSQL and Oracle ``lock``. Feature analysis reports
 ``MODIFIES_TRANSACTION``.
 
+PostgreSQL cursors
+------------------
+
+PostgreSQL's cursor statements parse to the ``net.sf.jsqlparser.statement.cursor`` package:
+
+* `DECLARE name [BINARY] [ASENSITIVE | INSENSITIVE] [[NO] SCROLL] CURSOR [{WITH | WITHOUT} HOLD]
+  FOR query <https://www.postgresql.org/docs/18/sql-declare.html>`_ parses to
+  ``DeclareCursorStatement``. ``getOptions()`` lists the ``CursorOption`` values in their
+  order; as in PostgreSQL's grammar they may come in any order and repeat, and PostgreSQL
+  rejects contradicting ones such as ``SCROLL NO SCROLL`` when it runs the statement.
+  ``getHoldability()`` is ``WITH_HOLD``, ``WITHOUT_HOLD`` or null, and ``getQuery()`` is the
+  ``Select``: a SELECT, ``VALUES``, ``TABLE t`` or a query with ``WITH``.
+* `FETCH <https://www.postgresql.org/docs/18/sql-fetch.html>`_ and
+  `MOVE <https://www.postgresql.org/docs/18/sql-move.html>`_
+  ``[direction] [FROM | IN] cursor`` parse to ``FetchCursorStatement``, whose ``getKind()``
+  is ``FETCH`` or ``MOVE``. The direction is an optional ``FetchDirection`` keyword
+  (``NEXT``, ``PRIOR``, ``FIRST``, ``LAST``, ``ABSOLUTE``, ``RELATIVE``, ``FORWARD``,
+  ``BACKWARD``) with ``getCount()`` or ``isAll()``: ``ABSOLUTE`` and ``RELATIVE`` take a
+  count, ``FORWARD`` and ``BACKWARD`` an optional count or ``ALL``, and a count or ``ALL``
+  can stand alone. A count is a signed 32-bit integer, as in PostgreSQL. ``getFromKeyword()``
+  is ``FROM``, ``IN`` or null.
+* `CLOSE {name | ALL} <https://www.postgresql.org/docs/18/sql-close.html>`_ parses to
+  ``CloseCursorStatement``; ``isAll()`` is true when it has no cursor name.
+
+.. code-block:: java
+
+    FetchCursorStatement fetch = (FetchCursorStatement) CCJSqlParserUtil.parse(
+        "FETCH ABSOLUTE -1 FROM c", parser -> parser.withDialect(Dialect.POSTGRESQL));
+    fetch.getDirection();     // ABSOLUTE
+    fetch.getCount();         // -1
+    fetch.getCursorName();    // c
+
+A cursor name is any name PostgreSQL takes as a column identifier, so its reserved words and
+type or function name keywords such as ``table`` or ``binary`` are rejected. As in PostgreSQL,
+a direction word that ends the statement names the cursor: ``FETCH next`` fetches from a
+cursor named ``next``.
+
+``Dialect.POSTGRESQL`` reads ``FETCH``, ``MOVE``, ``CLOSE`` and ``DECLARE`` followed by a
+name as cursor statements. Without a dialect they parse when they take the PostgreSQL form:
+``DECLARE`` needs a name, the cursor options and ``CURSOR``, and ``FETCH``, ``MOVE`` and
+``CLOSE`` must end at a semicolon or the end of the input, so other products' variants such
+as ``FETCH NEXT FROM c INTO @x`` or ``CLOSE GLOBAL c`` remain unsupported statements. Other
+dialects keep their readings, and ``DECLARE @variable`` still parses to the SQL Server
+``DeclareStatement`` in every dialect that read it before. ``MOVE`` becomes a non-reserved
+keyword; it remains usable as a name, as do ``CLOSE``, ``CURSOR`` and the option and
+direction words. ``SELECT ... FETCH FIRST`` is unchanged.
+
+Table visitors report the tables of the query of ``DECLARE`` and none for the other
+statements, whose cursor name is not a table. Validators report the ``declareCursor``,
+``fetchCursor`` (``FETCH`` and ``MOVE``) and ``closeCursor`` features, which the PostgreSQL
+capabilities enable, and validate the query of ``DECLARE`` like a SELECT. Feature analysis
+reports ``MODIFIES_SESSION`` for all of them, ``READS_DATA`` for a ``DECLARE`` whose query
+reads a table, ``RETURNS_RESULT_SET`` for ``FETCH``, and a possible ``READS_DATA`` for
+``FETCH`` and ``MOVE``, which run the query of the cursor.
+
 MySQL account management statements
 -----------------------------------
 
diff --git a/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java b/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java
index 25dd26d38..9fed85350 100644
--- a/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java
+++ b/src/test/java/net/sf/jsqlparser/parser/ASTNodeCoverageTest.java
@@ -149,7 +149,12 @@ public void testStatementsTheCorpusLacks() throws JSQLParserException {
                 "CHECKPOINT",
                 "DROP CAST IF EXISTS (int[] AS public.t) CASCADE",
                 "DROP OPERATOR public.=== (integer, integer), ~ (NONE, bigint)",
-                "DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u"}) {
+                "DROP TRANSFORM FOR public.hstore LANGUAGE plpython3u",
+                "DECLARE c BINARY NO SCROLL CURSOR WITH HOLD FOR WITH x AS (SELECT a FROM t) "
+                        + "SELECT a FROM x",
+                "FETCH FORWARD -2 FROM c",
+                "MOVE ALL IN c",
+                "CLOSE ALL"}) {
             new Walk(sql, sql, problems).check(CCJSqlParserUtil.parseStatements(sql));
         }
         String block = "BEGIN x := 1; NULL; foo(1); END;";
diff --git a/src/test/java/net/sf/jsqlparser/statement/cursor/PostgreSqlCursorTest.java b/src/test/java/net/sf/jsqlparser/statement/cursor/PostgreSqlCursorTest.java
new file mode 100644
index 000000000..1e88d6e57
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/statement/cursor/PostgreSqlCursorTest.java
@@ -0,0 +1,524 @@
+/*-
+ * #%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.cursor;
+
+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.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.parser.ASTNodeAccess;
+import net.sf.jsqlparser.parser.AbstractJSqlParser.Dialect;
+import net.sf.jsqlparser.parser.CCJSqlParser;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.parser.Node;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.DeclareStatement;
+import net.sf.jsqlparser.statement.Statement;
+import net.sf.jsqlparser.statement.StatementFeatures;
+import net.sf.jsqlparser.statement.Statements;
+import net.sf.jsqlparser.statement.StmtFeature;
+import net.sf.jsqlparser.statement.UnsupportedStatement;
+import net.sf.jsqlparser.statement.alter.AlterSession;
+import net.sf.jsqlparser.statement.create.table.CreateTable;
+import net.sf.jsqlparser.statement.select.PlainSelect;
+import net.sf.jsqlparser.statement.select.Select;
+import net.sf.jsqlparser.statement.select.TableStatement;
+import net.sf.jsqlparser.statement.select.Values;
+import net.sf.jsqlparser.util.TablesNamesFinder;
+import net.sf.jsqlparser.util.deparser.StatementDeParser;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class PostgreSqlCursorTest {
+    private static final Consumer<CCJSqlParser> POSTGRESQL =
+            parser -> parser.withDialect(Dialect.POSTGRESQL);
+    private static final Consumer<CCJSqlParser> NO_DIALECT = parser -> {
+    };
+    private static final Consumer<CCJSqlParser> UNSUPPORTED =
+            parser -> parser.withUnsupportedStatements(true);
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "DECLARE c CURSOR FOR SELECT * FROM t",
+            "DECLARE c BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR SELECT 1",
+            "DECLARE c ASENSITIVE SCROLL CURSOR WITHOUT HOLD FOR SELECT a FROM t WHERE a > 0",
+            "DECLARE c CURSOR FOR VALUES (1), (2)",
+            "DECLARE c CURSOR FOR TABLE t",
+            "DECLARE c SCROLL BINARY CURSOR FOR SELECT 1",
+            "DECLARE c SCROLL NO SCROLL CURSOR FOR SELECT 1",
+            "DECLARE c BINARY BINARY CURSOR FOR SELECT 1",
+            "DECLARE c CURSOR WITH HOLD FOR WITH x AS (SELECT a FROM t) SELECT a FROM x",
+            "DECLARE c CURSOR FOR SELECT a FROM t UNION SELECT a FROM u ORDER BY a",
+            "DECLARE c CURSOR FOR SELECT a FROM t FOR UPDATE",
+            "DECLARE c CURSOR FOR (SELECT 1)",
+            "DECLARE \"Cur\" CURSOR FOR SELECT 1",
+            "DECLARE scroll SCROLL CURSOR FOR SELECT 1",
+            "DECLARE cursor CURSOR FOR SELECT 1",
+            "FETCH c",
+            "FETCH NEXT FROM c",
+            "FETCH PRIOR IN c",
+            "FETCH FIRST FROM c",
+            "FETCH LAST c",
+            "FETCH ABSOLUTE -1 FROM c",
+            "FETCH RELATIVE 3 IN c",
+            "FETCH RELATIVE 0 c",
+            "FETCH 5 FROM c",
+            "FETCH -2 c",
+            "FETCH ALL c",
+            "FETCH ALL IN c",
+            "FETCH FORWARD c",
+            "FETCH FORWARD 10 IN c",
+            "FETCH FORWARD ALL FROM c",
+            "FETCH BACKWARD FROM c",
+            "FETCH BACKWARD 2 FROM c",
+            "FETCH BACKWARD ALL c",
+            "FETCH FROM c",
+            "FETCH IN c",
+            "FETCH ABSOLUTE 2147483647 FROM c",
+            "FETCH ABSOLUTE -2147483647 FROM c",
+            "FETCH next",
+            "FETCH NEXT next",
+            "FETCH FROM next",
+            "FETCH forward",
+            "FETCH ABSOLUTE 1 relative",
+            "FETCH \"c\"",
+            "MOVE ABSOLUTE 2 IN c",
+            "MOVE c",
+            "MOVE BACKWARD ALL FROM c",
+            "MOVE NEXT c",
+            "MOVE -1 IN c",
+            "MOVE LAST FROM c",
+            "MOVE absolute",
+            "CLOSE c",
+            "CLOSE ALL",
+            "CLOSE \"all\"",
+            "CLOSE next",
+            "CLOSE move",
+            "CLOSE cursor"})
+    void parsesWithPostgreSqlAndWithoutDialect(String sql) throws JSQLParserException {
+        for (Consumer<CCJSqlParser> dialect : List.of(POSTGRESQL, NO_DIALECT)) {
+            Statement statement = assertSqlCanBeParsedAndDeparsed(sql, false, dialect);
+            assertEquals(sql, deparse(statement));
+            assertEquals(sql, CCJSqlParserUtil.parse(statement.toString(), dialect).toString());
+        }
+    }
+
+    @Test
+    void normalizesSignsLeadingZerosAndKeywordCase() throws JSQLParserException {
+        assertNormalized("FETCH 5 c", "FETCH +5 c");
+        assertNormalized("FETCH -3 c", "FETCH - 3 c");
+        assertNormalized("FETCH ABSOLUTE 7 c", "FETCH ABSOLUTE 007 c");
+        assertNormalized("MOVE FORWARD ALL IN c", "move forward all in c");
+        assertNormalized("DECLARE c NO SCROLL CURSOR WITH HOLD FOR SELECT 1",
+                "declare c no scroll cursor with hold for select 1");
+        assertNormalized("CLOSE ALL", "close all");
+        // PostgreSQL 16 and later take digit separators
+        assertEquals("FETCH 1000 c",
+                CCJSqlParserUtil.parse("FETCH 1_000 c", POSTGRESQL).toString());
+    }
+
+    @Test
+    void keepsTheDeclareOptionsAndTheQuery() throws JSQLParserException {
+        DeclareCursorStatement declare = (DeclareCursorStatement) parse(
+                "DECLARE c BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR SELECT a FROM t");
+        assertEquals("c", declare.getCursorName());
+        assertEquals(Arrays.asList(CursorOption.BINARY, CursorOption.INSENSITIVE,
+                CursorOption.NO_SCROLL), declare.getOptions());
+        assertEquals(DeclareCursorStatement.Holdability.WITH_HOLD, declare.getHoldability());
+        assertInstanceOf(PlainSelect.class, declare.getQuery());
+        assertEquals("SELECT a FROM t", declare.getQuery().toString());
+
+        DeclareCursorStatement plain = (DeclareCursorStatement) parse(
+                "DECLARE c SCROLL SCROLL CURSOR WITHOUT HOLD FOR VALUES (1)");
+        assertEquals(Arrays.asList(CursorOption.SCROLL, CursorOption.SCROLL), plain.getOptions());
+        assertEquals(DeclareCursorStatement.Holdability.WITHOUT_HOLD, plain.getHoldability());
+        assertInstanceOf(Values.class, plain.getQuery());
+
+        DeclareCursorStatement table =
+                (DeclareCursorStatement) parse("DECLARE \"C\" CURSOR FOR TABLE t");
+        assertEquals("\"C\"", table.getCursorName());
+        assertThat(table.getOptions()).isEmpty();
+        assertNull(table.getHoldability());
+        assertInstanceOf(TableStatement.class, table.getQuery());
+    }
+
+    @Test
+    void keepsTheFetchDirection() throws JSQLParserException {
+        assertFetch("FETCH c", FetchCursorStatement.Kind.FETCH, null, null, false, null, "c");
+        assertFetch("FETCH NEXT FROM c", FetchCursorStatement.Kind.FETCH, FetchDirection.NEXT,
+                null, false, FetchCursorStatement.FromKeyword.FROM, "c");
+        assertFetch("FETCH ABSOLUTE -1 IN c", FetchCursorStatement.Kind.FETCH,
+                FetchDirection.ABSOLUTE, -1L, false, FetchCursorStatement.FromKeyword.IN, "c");
+        assertFetch("FETCH RELATIVE 3 c", FetchCursorStatement.Kind.FETCH,
+                FetchDirection.RELATIVE, 3L, false, null, "c");
+        assertFetch("FETCH 5 FROM c", FetchCursorStatement.Kind.FETCH, null, 5L, false,
+                FetchCursorStatement.FromKeyword.FROM, "c");
+        assertFetch("FETCH ALL c", FetchCursorStatement.Kind.FETCH, null, null, true, null, "c");
+        assertFetch("MOVE FORWARD ALL FROM c", FetchCursorStatement.Kind.MOVE,
+                FetchDirection.FORWARD, null, true, FetchCursorStatement.FromKeyword.FROM, "c");
+        assertFetch("MOVE BACKWARD 2 c", FetchCursorStatement.Kind.MOVE, FetchDirection.BACKWARD,
+                2L, false, null, "c");
+        assertFetch("MOVE BACKWARD c", FetchCursorStatement.Kind.MOVE, FetchDirection.BACKWARD,
+                null, false, null, "c");
+        assertFetch("FETCH PRIOR prior", FetchCursorStatement.Kind.FETCH, FetchDirection.PRIOR,
+                null, false, null, "prior");
+        // a direction word that ends the statement names the cursor, as in PostgreSQL
+        assertFetch("FETCH last", FetchCursorStatement.Kind.FETCH, null, null, false, null,
+                "last");
+        assertFetch("MOVE backward", FetchCursorStatement.Kind.MOVE, null, null, false, null,
+                "backward");
+
+        assertTrue(FetchDirection.ABSOLUTE.isCountRequired());
+        assertFalse(FetchDirection.FORWARD.isCountRequired());
+        assertTrue(FetchDirection.BACKWARD.isCountOptional());
+        assertFalse(FetchDirection.NEXT.isCountOptional());
+    }
+
+    @Test
+    void keepsTheClosedCursor() throws JSQLParserException {
+        CloseCursorStatement close = (CloseCursorStatement) parse("CLOSE c");
+        assertEquals("c", close.getCursorName());
+        assertFalse(close.isAll());
+
+        CloseCursorStatement all = (CloseCursorStatement) parse("CLOSE ALL");
+        assertNull(all.getCursorName());
+        assertTrue(all.isAll());
+
+        CloseCursorStatement quoted = (CloseCursorStatement) parse("CLOSE \"all\"");
+        assertEquals("\"all\"", quoted.getCursorName());
+        assertFalse(quoted.isAll());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "DECLARE c",
+            "DECLARE c CURSOR",
+            "DECLARE c CURSOR FOR",
+            "DECLARE c FOR SELECT 1",
+            "DECLARE c NO CURSOR FOR SELECT 1",
+            "DECLARE c SENSITIVE CURSOR FOR SELECT 1",
+            "DECLARE c HOLD CURSOR FOR SELECT 1",
+            "DECLARE c CURSOR WITH FOR SELECT 1",
+            "DECLARE c CURSOR HOLD FOR SELECT 1",
+            "DECLARE c CURSOR WITHOUT HOLD WITH HOLD FOR SELECT 1",
+            "DECLARE c CURSOR SCROLL FOR SELECT 1",
+            "DECLARE c CURSOR FOR INSERT INTO t VALUES (1)",
+            "DECLARE c CURSOR FOR UPDATE t SET a = 1",
+            "DECLARE c CURSOR FOR DELETE FROM t",
+            "DECLARE c CURSOR FOR SELECT 1 FETCH",
+            "DECLARE s.c CURSOR FOR SELECT 1",
+            "DECLARE binary CURSOR FOR SELECT 1",
+            "DECLARE table CURSOR FOR SELECT 1",
+            "DECLARE verbose CURSOR FOR SELECT 1",
+            "FETCH",
+            "FETCH FROM",
+            "FETCH ALL",
+            "FETCH 5",
+            "FETCH FORWARD 5",
+            "FETCH FORWARD ALL",
+            "FETCH NEXT 5 FROM c",
+            "FETCH PRIOR ALL c",
+            "FETCH ABSOLUTE FROM c",
+            "FETCH ABSOLUTE c",
+            "FETCH RELATIVE ALL c",
+            "FETCH 1.5 c",
+            "FETCH ABSOLUTE 2147483648 c",
+            "FETCH ABSOLUTE -2147483648 c",
+            "FETCH c INTO x",
+            "FETCH NEXT FROM c, d",
+            "FETCH NEXT FROM s.c",
+            "FETCH NEXT FROM table",
+            "FETCH NEXT FROM all",
+            "FETCH FROM IN c",
+            "MOVE",
+            "MOVE ALL",
+            "MOVE c INTO x",
+            "CLOSE",
+            "CLOSE c, d",
+            "CLOSE ALL c",
+            "CLOSE s.c",
+            "CLOSE table",
+            "CLOSE binary"})
+    void rejectsWhatPostgreSqlRejects(String sql) {
+        for (Consumer<CCJSqlParser> dialect : List.of(POSTGRESQL, NO_DIALECT)) {
+            assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, dialect),
+                    sql);
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "FETCH NEXT FROM c INTO @x",
+            "FETCH ABSOLUTE @n FROM c",
+            "FETCH NEXT FROM GLOBAL c",
+            "FETCH c INTO x",
+            "MOVE c d",
+            "CLOSE GLOBAL c",
+            "CLOSE table"})
+    void otherProductsVariantsStayUnsupportedWithoutDialect(String sql)
+            throws JSQLParserException {
+        assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, UNSUPPORTED),
+                sql);
+        // the PostgreSQL dialect reads them as cursor statements, which they are not
+        assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql,
+                POSTGRESQL.andThen(UNSUPPORTED)), sql);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "DECLARE c CURSOR FOR SELECT 1",
+            "FETCH NEXT FROM c",
+            "FETCH ALL c",
+            "MOVE c",
+            "CLOSE c",
+            "CLOSE ALL"})
+    void otherDialectsKeepTheirReadings(String sql) {
+        for (Dialect dialect : List.of(Dialect.SQLSERVER, Dialect.MYSQL, Dialect.MARIADB,
+                Dialect.ORACLE, Dialect.H2, Dialect.COCKROACHDB)) {
+            Consumer<CCJSqlParser> consumer = parser -> parser.withDialect(dialect);
+            assertThrows(JSQLParserException.class, () -> CCJSqlParserUtil.parse(sql, consumer),
+                    sql + " " + dialect);
+            if (!sql.startsWith("DECLARE")) {
+                assertDoesParseAsUnsupported(sql, consumer.andThen(UNSUPPORTED));
+            }
+        }
+    }
+
+    @Test
+    void sqlServerDeclareKeepsItsReading() throws JSQLParserException {
+        for (Consumer<CCJSqlParser> dialect : List.of(NO_DIALECT, POSTGRESQL,
+                (Consumer<CCJSqlParser>) parser -> parser.withDialect(Dialect.SQLSERVER))) {
+            for (String sql : new String[] {"DECLARE @x INT", "DECLARE @x INT = 1, @y VARCHAR(10)",
+                    "DECLARE @t TABLE (a INT)", "DECLARE @x AS t"}) {
+                assertInstanceOf(DeclareStatement.class,
+                        assertSqlCanBeParsedAndDeparsed(sql, true, dialect), sql);
+            }
+        }
+        // the cursor forms of other products remain parse errors without a dialect
+        assertThrows(JSQLParserException.class,
+                () -> CCJSqlParserUtil.parse("DECLARE c CURSOR LOCAL FAST_FORWARD FOR SELECT 1"));
+        assertThrows(JSQLParserException.class,
+                () -> CCJSqlParserUtil.parse("DECLARE x INT", UNSUPPORTED));
+    }
+
+    @Test
+    void endsAtStatementBoundaries() throws JSQLParserException {
+        String script = "START TRANSACTION; DECLARE c SCROLL CURSOR FOR SELECT * FROM t;\n"
+                + "FETCH NEXT FROM c;\n"
+                + "MOVE c; FETCH PRIOR c; CLOSE c; COMMIT";
+        for (Consumer<CCJSqlParser> dialect : List.of(POSTGRESQL, NO_DIALECT)) {
+            assertEquals(List.of("StartTransaction", "DeclareCursorStatement",
+                    "FetchCursorStatement", "FetchCursorStatement", "FetchCursorStatement",
+                    "CloseCursorStatement", "Commit"), classes(script, dialect));
+        }
+        // without a semicolon in the PostgreSQL dialect, as other statements may follow
+        assertEquals(List.of("PlainSelect", "Update", "FetchCursorStatement",
+                "FetchCursorStatement", "CloseCursorStatement", "CloseCursorStatement",
+                "FetchCursorStatement", "PlainSelect"),
+                classes("SELECT 0; UPDATE t SET a = 1\nFETCH c\nMOVE ALL IN c\nCLOSE c\n"
+                        + "CLOSE ALL\nFETCH next\n;SELECT 1", POSTGRESQL));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "DECLARE c CURSOR FOR SELECT 1",
+            "FETCH c",
+            "FETCH next",
+            "FETCH FORWARD ALL FROM c",
+            "MOVE ABSOLUTE -1 c",
+            "CLOSE c",
+            "CLOSE ALL"})
+    void isAStatementStart(String sql) throws JSQLParserException {
+        for (Consumer<CCJSqlParser> dialect : List.of(POSTGRESQL, NO_DIALECT)) {
+            Statements statements =
+                    CCJSqlParserUtil.parseStatements("SELECT 1;\n" + sql + ";\nSELECT 2", dialect);
+            assertEquals(3, statements.size(), sql);
+            assertEquals(sql, statements.get(1).toString());
+        }
+        Statements unsupported = CCJSqlParserUtil.parseStatements("FOO BAR; " + sql + "; BAZ",
+                UNSUPPORTED);
+        assertEquals(3, unsupported.size(), sql);
+        assertInstanceOf(UnsupportedStatement.class, unsupported.get(0));
+        assertEquals(sql, unsupported.get(1).toString());
+        assertInstanceOf(UnsupportedStatement.class, unsupported.get(2));
+    }
+
+    @Test
+    void selectFetchAndOtherUsesOfTheWordsAreUnchanged() throws JSQLParserException {
+        for (Consumer<CCJSqlParser> dialect : List.of(POSTGRESQL, NO_DIALECT,
+                (Consumer<CCJSqlParser>) parser -> parser.withDialect(Dialect.MYSQL))) {
+            assertSqlCanBeParsedAndDeparsed("SELECT * FROM t FETCH FIRST 1 ROWS ONLY", true,
+                    dialect);
+            assertSqlCanBeParsedAndDeparsed("SELECT * FROM t OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY",
+                    true, dialect);
+            assertSqlCanBeParsedAndDeparsed(
+                    "SELECT move, close, cursor, scroll, hold, absolute, relative, forward, "
+                            + "backward, prior, insensitive, asensitive FROM move AS move",
+                    true, dialect);
+            assertSqlCanBeParsedAndDeparsed("SELECT move(1), t.move FROM t move", true, dialect);
+            assertInstanceOf(CreateTable.class, assertSqlCanBeParsedAndDeparsed(
+                    "CREATE TABLE move (move INT, close INT, cursor INT)", true, dialect));
+        }
+        assertInstanceOf(AlterSession.class, CCJSqlParserUtil.parse(
+                "ALTER SESSION CLOSE DATABASE LINK x",
+                parser -> parser.withDialect(Dialect.ORACLE)));
+    }
+
+    @Test
+    void findsTheTablesOfTheQueryOnly() throws JSQLParserException {
+        Statement declare = parse("DECLARE c CURSOR FOR WITH x AS (SELECT a FROM t) "
+                + "SELECT x.a FROM x JOIN s.u ON true");
+        assertThat(new TablesNamesFinder<>().getTables(declare))
+                .containsExactlyInAnyOrder("t", "s.u");
+        assertThat(new TablesNamesFinder<>().getTables(parse("DECLARE c CURSOR FOR TABLE t")))
+                .containsExactly("t");
+        for (String sql : new String[] {"FETCH NEXT FROM t", "MOVE t", "CLOSE t", "CLOSE ALL"}) {
+            assertThat(new TablesNamesFinder<>().getTables(parse(sql))).isEmpty();
+        }
+    }
+
+    @Test
+    void reportsSessionFeatures() throws JSQLParserException {
+        StatementFeatures declare = parse("DECLARE c CURSOR FOR SELECT a FROM t").getFeatures();
+        assertThat(declare.getCertain()).containsExactlyInAnyOrder(StmtFeature.MODIFIES_SESSION,
+                StmtFeature.READS_DATA);
+        assertThat(parse("DECLARE c CURSOR FOR SELECT 1").getFeatures().getCertain())
+                .containsExactly(StmtFeature.MODIFIES_SESSION);
+
+        StatementFeatures fetch = parse("FETCH ALL c").getFeatures();
+        assertThat(fetch.getCertain()).containsExactlyInAnyOrder(StmtFeature.RETURNS_RESULT_SET,
+                StmtFeature.MODIFIES_SESSION);
+        assertThat(fetch.getUncertain()).containsExactly(StmtFeature.READS_DATA);
+
+        StatementFeatures move = parse("MOVE ALL c").getFeatures();
+        assertThat(move.getCertain()).containsExactly(StmtFeature.MODIFIES_SESSION);
+        assertThat(move.getUncertain()).containsExactly(StmtFeature.READS_DATA);
+
+        assertThat(parse("CLOSE ALL").getFeatures().getCertain())
+                .containsExactly(StmtFeature.MODIFIES_SESSION);
+    }
+
+    @Test
+    void nodesSpanTheStatementsAndTheQuery() throws JSQLParserException {
+        String sql = "DECLARE c SCROLL CURSOR WITH HOLD FOR SELECT a FROM t";
+        DeclareCursorStatement declare = (DeclareCursorStatement) parse(sql);
+        assertEquals(sql, text(sql, declare));
+        assertEquals("SELECT a FROM t", text(sql, declare.getQuery()));
+        for (String other : new String[] {"FETCH FORWARD 2 FROM c", "MOVE c", "CLOSE ALL"}) {
+            assertEquals(other, text(other, (ASTNodeAccess) parse(other)));
+        }
+    }
+
+    @Test
+    void buildsStatementsInCode() {
+        Select query = new PlainSelect().addSelectItems(new Column(new Table("t"), "a"))
+                .withFromItem(new Table("t"));
+        DeclareCursorStatement declare = new DeclareCursorStatement("c", query)
+                .addOptions(CursorOption.BINARY, CursorOption.NO_SCROLL);
+        declare.setHoldability(DeclareCursorStatement.Holdability.WITH_HOLD);
+        assertEquals("DECLARE c BINARY NO SCROLL CURSOR WITH HOLD FOR SELECT t.a FROM t",
+                declare.toString());
+        assertEquals(declare.toString(), deparse(declare));
+        declare.setOptions(null);
+        declare.setHoldability(null);
+        assertEquals("DECLARE c CURSOR FOR SELECT t.a FROM t", deparse(declare));
+
+        FetchCursorStatement fetch = new FetchCursorStatement(FetchCursorStatement.Kind.MOVE, "c");
+        assertEquals("MOVE c", fetch.toString());
+        fetch.setDirection(FetchDirection.FORWARD);
+        fetch.setCount(3L);
+        fetch.setFromKeyword(FetchCursorStatement.FromKeyword.IN);
+        assertEquals("MOVE FORWARD 3 IN c", deparse(fetch));
+        fetch.setAll(true);
+        assertNull(fetch.getCount());
+        assertEquals("MOVE FORWARD ALL IN c", fetch.toString());
+        fetch.setCount(-1L);
+        assertFalse(fetch.isAll());
+        fetch.setKind(FetchCursorStatement.Kind.FETCH);
+        fetch.setDirection(null);
+        fetch.setFromKeyword(null);
+        assertEquals("FETCH -1 c", deparse(fetch));
+        assertThrows(NullPointerException.class, () -> fetch.setKind(null));
+        FetchCursorStatement plain = new FetchCursorStatement();
+        plain.setCursorName("c");
+        assertEquals("FETCH c", plain.toString());
+
+        CloseCursorStatement close = new CloseCursorStatement();
+        assertTrue(close.isAll());
+        assertEquals("CLOSE ALL", deparse(close));
+        close.setCursorName("c");
+        assertEquals("CLOSE c", close.toString());
+        assertEquals("CLOSE d", deparse(new CloseCursorStatement("d")));
+    }
+
+    private static void assertFetch(String sql, FetchCursorStatement.Kind kind,
+            FetchDirection direction, Long count, boolean all,
+            FetchCursorStatement.FromKeyword fromKeyword, String name) throws JSQLParserException {
+        FetchCursorStatement fetch = (FetchCursorStatement) parse(sql);
+        assertEquals(kind, fetch.getKind(), sql);
+        assertEquals(direction, fetch.getDirection(), sql);
+        assertEquals(count, fetch.getCount(), sql);
+        assertEquals(all, fetch.isAll(), sql);
+        assertEquals(fromKeyword, fetch.getFromKeyword(), sql);
+        assertEquals(name, fetch.getCursorName(), sql);
+    }
+
+    private static void assertNormalized(String expected, String sql) throws JSQLParserException {
+        for (Consumer<CCJSqlParser> dialect : List.of(POSTGRESQL, NO_DIALECT)) {
+            Statement statement = CCJSqlParserUtil.parse(sql, dialect);
+            assertEquals(expected, statement.toString());
+            assertEquals(expected, deparse(statement));
+        }
+    }
+
+    private static void assertDoesParseAsUnsupported(String sql, Consumer<CCJSqlParser> dialect) {
+        try {
+            assertInstanceOf(UnsupportedStatement.class, CCJSqlParserUtil.parse(sql, dialect),
+                    sql);
+        } catch (JSQLParserException e) {
+            throw new AssertionError(sql, e);
+        }
+    }
+
+    private static Statement parse(String sql) throws JSQLParserException {
+        return assertSqlCanBeParsedAndDeparsed(sql, true, POSTGRESQL);
+    }
+
+    private static List<String> classes(String script, Consumer<CCJSqlParser> dialect)
+            throws JSQLParserException {
+        return CCJSqlParserUtil.parseStatements(script, dialect).stream()
+                .map(statement -> statement.getClass().getSimpleName())
+                .collect(Collectors.toList());
+    }
+
+    private static String deparse(Statement statement) {
+        StringBuilder builder = new StringBuilder();
+        statement.accept(new StatementDeParser(builder), null);
+        return builder.toString();
+    }
+
+    private static String text(String sql, ASTNodeAccess access) {
+        Node node = access.getASTNode();
+        return sql.substring(node.jjtGetFirstToken().absoluteBegin - 1,
+                node.jjtGetLastToken().absoluteEnd - 1);
+    }
+}
diff --git a/src/test/java/net/sf/jsqlparser/util/validation/validator/CursorValidatorTest.java b/src/test/java/net/sf/jsqlparser/util/validation/validator/CursorValidatorTest.java
new file mode 100644
index 000000000..0073d4f3b
--- /dev/null
+++ b/src/test/java/net/sf/jsqlparser/util/validation/validator/CursorValidatorTest.java
@@ -0,0 +1,57 @@
+/*-
+ * #%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.util.validation.validator;
+
+import net.sf.jsqlparser.parser.feature.Feature;
+import net.sf.jsqlparser.util.validation.ValidationTestAsserts;
+import net.sf.jsqlparser.util.validation.feature.DatabaseType;
+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 net.sf.jsqlparser.util.validation.feature.SqlServerVersion;
+import org.junit.jupiter.api.Test;
+
+public class CursorValidatorTest extends ValidationTestAsserts {
+
+    @Test
+    public void allowedForPostgresql() {
+        for (String sql : new String[] {"DECLARE c SCROLL CURSOR WITH HOLD FOR SELECT a FROM t",
+                "DECLARE c CURSOR FOR VALUES (1)", "FETCH FORWARD 5 FROM c", "MOVE LAST IN c",
+                "CLOSE c", "CLOSE ALL"}) {
+            validateNoErrors(sql, 1, PostgresqlVersion.V10, PostgresqlVersion.V14,
+                    DatabaseType.POSTGRESQL);
+        }
+    }
+
+    @Test
+    public void notSupportedByMySqlAndSqlServer() {
+        validateNotSupported("DECLARE c CURSOR FOR SELECT 1", 1, 1, MySqlVersion.V8_0,
+                Feature.declareCursor);
+        validateNotSupported("FETCH NEXT FROM c", 1, 1, MySqlVersion.V8_0, Feature.fetchCursor);
+        validateNotSupported("MOVE c", 1, 1, SqlServerVersion.V2019, Feature.fetchCursor);
+        validateNotSupported("CLOSE ALL", 1, 1, MySqlVersion.V8_0, Feature.closeCursor);
+    }
+
+    @Test
+    public void featureNotAllowed() {
+        validateNotAllowed("DECLARE c CURSOR FOR SELECT a FROM t", 1, 1, FeaturesAllowed.SELECT,
+                Feature.declareCursor);
+        validateNotAllowed("FETCH ALL c", 1, 1, FeaturesAllowed.SELECT, Feature.fetchCursor);
+        validateNotAllowed("MOVE c", 1, 1, FeaturesAllowed.DML, Feature.fetchCursor);
+        validateNotAllowed("CLOSE c", 1, 1, FeaturesAllowed.DDL, Feature.closeCursor);
+    }
+
+    @Test
+    public void validatesTheQueryOfTheCursor() {
+        // the query is validated like a SELECT statement
+        validateNotAllowed("DECLARE c CURSOR FOR SELECT a FROM t", 1, 1,
+                new FeaturesAllowed(Feature.declareCursor), Feature.select);
+    }
+}