@@ -13,8 +13,12 @@
 
 use Cycle\Database\Driver\Driver;
 use Cycle\Database\Driver\DriverInterface;
+use Cycle\Database\Driver\CursorableInterface;
+use Cycle\Database\Driver\CursorOptions;
+use Cycle\Database\Exception\DriverException;
 use Cycle\Database\Query\DeleteQuery;
 use Cycle\Database\Query\InsertQuery;
+use Cycle\Database\Query\QueryParameters;
 use Cycle\Database\Query\SelectQuery;
 use Cycle\Database\Query\UpdateQuery;
 
@@ -131,6 +135,40 @@ public function query(string $query, array $parameters = []): StatementInterface
             ->query($query, $parameters);
     }
 
+    /**
+     * Open a server-side cursor for a compiled SELECT query and yield rows lazily.
+     *
+     * Not on {@see DatabaseInterface} for BC; exposed via `@method` annotation.
+     * The read driver must implement {@see CursorableInterface} (Postgres, SQLite,
+     * SQL Server); otherwise a {@see DriverException} is thrown. Cursor semantics —
+     * including snapshot consistency within the transaction — are preserved:
+     * this method intentionally has no fallback strategy.
+     *
+     * Driver-specific knobs are passed via {@see CursorOptions} subclasses
+     * (e.g. {@see \Cycle\Database\Driver\Postgres\PostgresCursorOptions},
+     * {@see \Cycle\Database\Driver\SQLServer\SQLServerCursorOptions}).
+     *
+     * @return \Generator<int, array<array-key, mixed>>
+     */
+    public function cursor(
+        SelectQuery $query,
+        CursorOptions $options = new CursorOptions(),
+        int $mode = StatementInterface::FETCH_ASSOC,
+    ): \Generator {
+        $driver = $this->getDriver(self::READ);
+        if (!$driver instanceof CursorableInterface) {
+            throw new DriverException(\sprintf(
+                'Server-side cursors are not supported for driver `%s`.',
+                $driver->getType(),
+            ));
+        }
+
+        $parameters = new QueryParameters();
+        $sql = $query->sqlStatement($parameters);
+
+        return $driver->cursor($sql, $parameters->getParameters(), $options, $mode);
+    }
+
     public function insert(?string $table = null): InsertQuery
     {
         return $this->getDriver(self::WRITE)
 
@@ -25,6 +25,14 @@
  *
  * @method DatabaseInterface withoutCache() Get a new Database instance without query cache or the same instance
  *         if no cache is used. Will be added the next major release.
+ * @method \Generator cursor(SelectQuery $query, \Cycle\Database\Driver\CursorOptions $options = new \Cycle\Database\Driver\CursorOptions(), int $mode = StatementInterface::FETCH_ASSOC)
+ *         Open a server-side cursor for the SELECT query and yield rows lazily, with snapshot
+ *         consistency for the duration of the enclosing transaction. Requires the read driver to
+ *         implement {@see \Cycle\Database\Driver\CursorableInterface} (Postgres, SQLite, SQL Server)
+ *         and an active transaction. Driver-specific knobs (FETCH FORWARD batch, WITH HOLD,
+ *         SQL Server cursor type, …) are passed via driver-specific {@see CursorOptions} subclasses.
+ *         Throws {@see \Cycle\Database\Exception\DriverException} when the driver lacks cursor
+ *         support. Will be added to the interface in the next major release.
  */
 interface DatabaseInterface
 {
 
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Database\Driver;
+
+/**
+ * Cross-driver options for {@see CursorableInterface::cursor()}.
+ *
+ * The base class is intentionally empty — it serves as a typed null-object for
+ * drivers that have no extra knobs (SQLite) and as a marker for the
+ * polymorphic parameter accepted by {@see CursorableInterface::cursor()}.
+ * Drivers that need additional configuration (FETCH FORWARD batch size,
+ * snapshot type, WITH HOLD, etc.) extend this class with their own option
+ * DTOs and narrow the generic instance via their `from()` factory.
+ */
+class CursorOptions
+{
+    public function __construct() {}
+}
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Database\Driver;
+
+use Cycle\Database\Exception\DriverException;
+use Cycle\Database\Exception\StatementException;
+use Cycle\Database\StatementInterface;
+
+/**
+ * Implemented by drivers capable of opening a true server-side cursor over a
+ * SELECT result set.
+ *
+ * Unlike a generic "lazy iterator" abstraction, a server-side cursor offers
+ * **snapshot consistency** for the duration of its enclosing transaction:
+ * rows inserted or modified after the cursor is opened do not appear in the
+ * stream, regardless of how long iteration takes. This is the property that
+ * distinguishes a cursor from a paginator or an unbuffered fetch — and the
+ * reason this interface exposes the feature **without any fallback**.
+ *
+ * Drivers that cannot offer those guarantees must not implement this
+ * interface. Callers that want a portable lazy iterator should build their
+ * own (e.g. keyset pagination) on top of plain queries instead.
+ */
+interface CursorableInterface extends DriverInterface
+{
+    /**
+     * Open a server-side cursor for the given SELECT statement and yield rows
+     * from it lazily.
+     *
+     * Implementations require an active transaction on the connection for the
+     * cursor's lifetime; they must throw a {@see DriverException} when the
+     * preconditions are not met. The cursor is released when the generator is
+     * fully consumed, garbage-collected, or the consumer breaks out of the
+     * iteration.
+     *
+     * @param iterable $parameters Query parameters (positional or named) bound to the SELECT.
+     * @param CursorOptions $options Driver-specific cursor configuration. Drivers narrow the
+     *        type internally via their own `from()` factory (e.g.
+     *        {@see Postgres\PostgresCursorOptions::from()}).
+     * @param int $mode Row representation mode, one of {@see StatementInterface}::FETCH_*.
+     * @psalm-param non-empty-string $statement
+     *
+     * @return \Generator<int, array<array-key, mixed>>
+     *
+     * @throws DriverException
+     * @throws StatementException
+     */
+    public function cursor(
+        string $statement,
+        iterable $parameters = [],
+        CursorOptions $options = new CursorOptions(),
+        int $mode = StatementInterface::FETCH_ASSOC,
+    ): \Generator;
+}
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Database\Driver\Postgres;
+
+use Cycle\Database\Driver\CursorOptions;
+
+/**
+ * Postgres-specific cursor options.
+ *
+ * Maps to clauses of `DECLARE … CURSOR …` syntax.
+ */
+final class PostgresCursorOptions extends CursorOptions
+{
+    /**
+     * @param int<1, max> $chunkSize Number of rows pulled by each `FETCH FORWARD N FROM cursor`
+     *        round-trip. Higher values reduce network overhead at the cost of buffering
+     *        a larger result chunk in client memory between yields.
+     * @param bool $withHold When true, declares the cursor `WITH HOLD`. The cursor materializes
+     *        the rest of its result on the server at `COMMIT` time and remains open for further
+     *        `FETCH` calls outside the transaction. Use for long-running exports that should
+     *        not keep a write-blocking transaction alive.
+     */
+    public function __construct(
+        public readonly int $chunkSize = 1000,
+        public readonly bool $withHold = false,
+    ) {
+        parent::__construct();
+    }
+
+    public static function from(CursorOptions $options): self
+    {
+        return $options instanceof self ? $options : new self();
+    }
+}
@@ -19,14 +19,17 @@
 use Cycle\Database\Driver\Postgres\Query\PostgresInsertQuery;
 use Cycle\Database\Driver\Postgres\Query\PostgresSelectQuery;
 use Cycle\Database\Driver\Postgres\Query\PostgresUpdateQuery;
+use Cycle\Database\Driver\CursorableInterface;
+use Cycle\Database\Driver\CursorOptions;
 use Cycle\Database\Exception\DriverException;
 use Cycle\Database\Exception\StatementException;
 use Cycle\Database\Query\QueryBuilder;
+use Cycle\Database\StatementInterface;
 
 /**
  * Talks to postgres databases.
  */
-class PostgresDriver extends Driver
+class PostgresDriver extends Driver implements CursorableInterface
 {
     /**
      * Cached list of primary keys associated with their table names. Used by InsertBuilder to
@@ -196,6 +199,74 @@ public function beginTransaction(?string $isolationLevel = null): bool
         return true;
     }
 
+    /**
+     * Open a Postgres server-side cursor for the given SELECT and yield rows
+     * lazily. Provides snapshot consistency within the enclosing transaction.
+     *
+     * Requires an active transaction (cursor lifetime is bound to it unless
+     * {@see PostgresCursorOptions::$withHold} is set, in which case the cursor
+     * survives `COMMIT` and the result is materialized on the server). The
+     * cursor is declared with NO SCROLL — only forward fetches are performed.
+     * The cursor is closed when the generator is fully consumed or
+     * garbage-collected.
+     *
+     * @return \Generator<int, array<array-key, mixed>>
+     *
+     * @throws DriverException
+     */
+    public function cursor(
+        string $statement,
+        iterable $parameters = [],
+        CursorOptions $options = new CursorOptions(),
+        int $mode = StatementInterface::FETCH_ASSOC,
+    ): \Generator {
+        $opts = PostgresCursorOptions::from($options);
+
+        if ($opts->chunkSize < 1) {
+            throw new DriverException('Chunk size must be a positive integer.');
+        }
+
+        if ($this->getTransactionLevel() === 0) {
+            throw new DriverException(
+                'Postgres server-side cursor requires an active transaction. '
+                . 'Wrap the cursor iteration in Database::transaction() or call beginTransaction() before cursor().',
+            );
+        }
+
+        $cursorName = '"c_' . \bin2hex(\random_bytes(8)) . '"';
+        $holdClause = $opts->withHold ? ' WITH HOLD' : '';
+        $declareSql = "DECLARE {$cursorName} NO SCROLL CURSOR{$holdClause} FOR {$statement}";
+        $fetchSql = "FETCH FORWARD {$opts->chunkSize} FROM {$cursorName}";
+        $closeSql = "CLOSE {$cursorName}";
+
+        try {
+            $this->statement($declareSql, $parameters);
+
+            do {
+                $chunkStatement = $this->statement($fetchSql);
+                $rows = $chunkStatement->fetchAll($mode);
+                $chunkStatement->close();
+
+                foreach ($rows as $row) {
+                    yield $row;
+                }
+            } while (\count($rows) === $opts->chunkSize);
+        } finally {
+            try {
+                $this->statement($closeSql);
+            } catch (\Throwable) {
+                // Cursor may already be gone (e.g. transaction was rolled back) — swallow.
+            }
+
+            // Avoid polluting the prepared-statement cache with single-use SQL strings.
+            unset(
+                $this->queryCache[$declareSql],
+                $this->queryCache[$fetchSql],
+                $this->queryCache[$closeSql],
+            );
+        }
+    }
+
     /**
      * Parse the table name and extract the schema and table.
      *
 
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Database\Driver\SQLServer;
+
+use Cycle\Database\Driver\CursorOptions;
+
+/**
+ * SQL Server-specific cursor options.
+ *
+ * Maps to clauses of T-SQL `DECLARE … CURSOR …` syntax.
+ */
+final class SQLServerCursorOptions extends CursorOptions
+{
+    /**
+     * @param SQLServerCursorType $type Cursor flavor (snapshot semantics — see {@see SQLServerCursorType}).
+     *        The default {@see SQLServerCursorType::Static} fulfills the snapshot-consistency
+     *        contract of {@see \Cycle\Database\Driver\CursorableInterface}; other modes
+     *        trade snapshot guarantees for different visibility semantics.
+     */
+    public function __construct(
+        public readonly SQLServerCursorType $type = SQLServerCursorType::Static,
+    ) {
+        parent::__construct();
+    }
+
+    public static function from(CursorOptions $options): self
+    {
+        return $options instanceof self ? $options : new self();
+    }
+}
@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Database\Driver\SQLServer;
+
+/**
+ * Type of SQL Server server-side cursor.
+ *
+ * Controls what the cursor sees over its lifetime versus the underlying table state.
+ * Only {@see self::Static} fulfills the snapshot-consistency contract of
+ * {@see \Cycle\Database\Driver\CursorableInterface}; other modes are exposed for
+ * advanced use cases that accept different consistency trade-offs.
+ */
+enum SQLServerCursorType: string
+{
+    /**
+     * `STATIC` — SQL Server copies the result set into `tempdb` at `OPEN` time;
+     * the cursor reads from that snapshot and is unaffected by concurrent
+     * INSERTs / UPDATEs / DELETEs.
+     */
+    case Static = 'STATIC';
+
+    /**
+     * `KEYSET` — keys are frozen at `OPEN` time, but column values are
+     * re-read on each `FETCH`. Updates to existing rows ARE visible; inserts
+     * are not. Deleted rows show up as missing.
+     *
+     * Not snapshot-consistent in the strict sense.
+     */
+    case Keyset = 'KEYSET';
+
+    /**
+     * `DYNAMIC` — the result set is fully re-evaluated on every `FETCH`. Inserts,
+     * updates, and deletes by other transactions are all visible. No snapshot.
+     */
+    case Dynamic = 'DYNAMIC';
+
+    /**
+     * `FAST_FORWARD` — performance-optimized forward-only read-only cursor. Implemented
+     * as a dynamic cursor under the hood, so it offers no snapshot. Useful only when
+     * you trade consistency for throughput.
+     */
+    case FastForward = 'FAST_FORWARD';
+}