@@ -189,12 +189,11 @@ def _fetch_raw_from_queue(self, size: Optional[int]) -> Any:
     def _fetch_available_from_queue(self, size: int) -> Any:
         """Fetch up to ``size`` rows the queue already holds, for Arrow fetchone() refills.
 
-        On CloudFetch, ``next_n_rows`` keeps walking downloaded links until it has
-        ``size`` rows, so a refill that starts near the end of the current chunk
-        would block on the next download before returning a row that is already
-        available. Cap the request at what the current chunk still holds (matching
-        Thrift and the kernel's ``_fetch_available``) via the shared
-        ``ResultSet._cap_to_current_chunk``.
+        On CloudFetch, the request is capped at what the current chunk still holds
+        (matching Thrift) via the shared ``ResultSet._cap_to_current_chunk``, so a
+        refill is limited to one chunk rather than stitching several links into one
+        batch. It does not avoid waiting on the next download: reading to the end of
+        a chunk still makes ``next_n_rows`` advance to the next link in that call.
         Only called while the fetchone() row buffer is empty.
         """
         return self._fetch_raw_from_queue(self._cap_to_current_chunk(size))
 
@@ -257,6 +257,9 @@ def _convert_rows_individually(
     def _cap_to_current_chunk(self, size: int) -> int:
         """Cap ``size`` at the rows left in the current CloudFetch chunk, if any.
 
+        Limits each fetchone() refill to a single CloudFetch chunk. It does not
+        avoid waiting on the next download: ``next_n_rows`` advances to the next
+        file as soon as the current one is fully read, inside the same call.
         Shared by the Thrift and SEA fetchone() refills so the CloudFetchQueue
         internals (``table`` / ``table_row_index``) are read in one place.
         """
@@ -604,10 +607,11 @@ def _fetch_available_from_queue(self, size: int):
         until ``size`` rows are collected: it only refills the queue while it is
         empty, so fetchone() makes no more round-trips than it needs to return one
         row (server pages can be smaller than ``size`` when they hit the byte limit).
-        On CloudFetch, ``next_n_rows`` keeps walking downloaded files until it has
-        ``size`` rows, so the request is also capped at what the current chunk still
-        holds; otherwise a refill near a chunk boundary would block on the next
-        download before returning a row that is already available.
+        On CloudFetch, the request is also capped at what the current chunk still
+        holds (see ``_cap_to_current_chunk``), so a refill never stitches rows from
+        several downloaded files into one batch. This only bounds the batch: reading
+        to the end of a chunk still makes ``next_n_rows`` advance to (and wait for)
+        the next file before it returns, exactly as the uncapped path did.
         Only called while the fetchone() row buffer is empty.
         """
         results = self.results.next_n_rows(self._cap_to_current_chunk(size))
 
@@ -393,8 +393,9 @@ def test_fetchone_refill_does_not_fetch_extra_pages(self):
         self.assertEqual(rs.rownumber, 5)
 
     def test_cloudfetch_fetchone_refill_capped_to_current_chunk(self):
-        # fetchone() must not block on the next CloudFetch file while the current
-        # chunk still holds rows: the refill is capped at what the chunk has left.
+        # The fetchone() refill is capped at the rows left in the current CloudFetch
+        # chunk, so one refill never spans several files. (This only bounds the
+        # batch size; the mock queue does not model advancing to the next file.)
         from databricks.sql.utils import ThriftCloudFetchQueue
 
         _, chunk = self.make_arrow_table([[i] for i in range(10)])
 
@@ -662,7 +662,7 @@ def test_arrow_fetchone_then_fetchall_arrow_keeps_order(
     def test_cloudfetch_fetchone_refill_capped_to_current_chunk(
         self, mock_connection, mock_sea_client, execute_response
     ):
-        """fetchone() must not block on the next link while the current chunk has rows."""
+        """fetchone() refill is capped at the rows left in the current chunk (batch size only)."""
         from databricks.sql.backend.sea.queue import SeaCloudFetchQueue
 
         chunk = pyarrow.Table.from_pydict(