@@ -193,7 +193,7 @@ def _fetch_available_from_queue(self, size: int) -> Any:
         ``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's ``_fetch_available_from_queue`` and the kernel's ``_fetch_available``).
+        Thrift's ``_cap_to_current_chunk`` and the kernel's ``_fetch_available``).
         Only called while the fetchone() row buffer is empty.
         """
         if isinstance(self.results, CloudFetchQueue) and self.results.table:
 
@@ -16,8 +16,9 @@
     from databricks.sql.client import Connection
 from databricks.sql.backend.databricks_client import DatabricksClient
 from databricks.sql.types import Row
-from databricks.sql.exc import RequestError, CursorAlreadyClosedError
+from databricks.sql.exc import InternalError, RequestError, CursorAlreadyClosedError
 from databricks.sql.utils import (
+    CloudFetchQueue,
     ColumnTable,
     ColumnQueue,
     concat_table_chunks,
@@ -196,6 +197,14 @@ def _row_buffer_take_rows(self, n: Optional[int] = None) -> List[Row]:
                 raise row.error
         return taken
 
+    @staticmethod
+    def _raw_row_count(raw: Any) -> Optional[int]:
+        """Row count of a raw chunk (Arrow table, ColumnTable or list); None if unknown."""
+        if raw is None:
+            return 0
+        n = len(raw) if isinstance(raw, list) else getattr(raw, "num_rows", None)
+        return n if isinstance(n, int) else None
+
     @staticmethod
     def _convert_rows_individually(
         raw: Any, convert: Callable[[Any], List[Row]]
@@ -206,9 +215,7 @@ def _convert_rows_individually(
         raised only when that row is handed out. Returns None if ``raw`` has no rows
         to split, in which case the caller re-raises the batch error.
         """
-        if raw is None:
-            return None
-        n = len(raw) if isinstance(raw, list) else getattr(raw, "num_rows", 0)
+        n = ResultSet._raw_row_count(raw)
         if not n:
             return None
         rows: List[Any] = []
@@ -275,6 +282,16 @@ def _fetchone_buffered(
                 rows = fallback
             if not rows:
                 return None
+            raw_count = self._raw_row_count(raw)
+            if raw_count is not None and raw_count != len(rows):
+                # fetch_raw advanced _next_row_index (and the Thrift fetch offset)
+                # by raw_count; the buffer must line up 1:1 with the raw chunk or
+                # rownumber and fetchmany_arrow slicing would silently drift.
+                raise InternalError(
+                    "fetchone(): converted {} row(s) from a chunk of {} raw row(s)".format(
+                        len(rows), raw_count
+                    )
+                )
             self._row_buffer_raw = raw
             self._row_buffer_rows = rows
             self._row_buffer_pos = 0
@@ -552,19 +569,31 @@ 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.
         Only called while the fetchone() row buffer is empty.
         """
-        results = self.results.next_n_rows(size)
+        results = self.results.next_n_rows(self._cap_to_current_chunk(size))
         while (
             results.num_rows == 0
             and not self.has_been_closed_server_side
             and self.has_more_rows
         ):
             self._fill_results_buffer()
-            results = self.results.next_n_rows(size)
+            results = self.results.next_n_rows(self._cap_to_current_chunk(size))
         self._next_row_index += results.num_rows
         return results
 
+    def _cap_to_current_chunk(self, size: int) -> int:
+        """Cap ``size`` at the rows left in the current CloudFetch chunk, if any."""
+        if isinstance(self.results, CloudFetchQueue) and self.results.table:
+            available = self.results.table.num_rows - self.results.table_row_index
+            if available > 0:
+                return min(size, available)
+        return size
+
     def fetchall_arrow(self) -> "pyarrow.Table":
         """Fetch all (remaining) rows of a query result, returning them as a PyArrow table."""
         buffered = self._row_buffer_take_raw()
 
@@ -392,6 +392,27 @@ def test_fetchone_refill_does_not_fetch_extra_pages(self):
         self.assertIsNone(rs.fetchone())
         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.
+        from databricks.sql.utils import ThriftCloudFetchQueue
+
+        _, chunk = self.make_arrow_table([[i] for i in range(10)])
+        queue = Mock(spec=ThriftCloudFetchQueue)
+        queue.table = chunk
+        queue.table_row_index = 8
+        queue.next_n_rows.side_effect = lambda n: chunk.slice(8, n)
+        rs = self.make_dummy_result_set_from_queue_list(
+            [queue],
+            description=[("col0", "integer", None, None, None, None, None)],
+        )
+        rs.arraysize = 100
+
+        self.assertSequenceEqual(rs.fetchone(), [8])
+        queue.next_n_rows.assert_called_once_with(2)
+        self.assertSequenceEqual(rs.fetchone(), [9])
+        self.assertEqual(rs.rownumber, 2)
+
     # Regression tests for fetchmany_arrow / fetchall_arrow handling of
     # the schemaless CloudFetch placeholder.
     def test_fetchall_arrow_drops_mismatched_empty_placeholder(self):
@@ -579,6 +600,25 @@ def test_fetchone_convert_failure_on_every_row_reraises_per_row(self):
         self.assertEqual(rs._row_buffer_count(), 0)
         self.assertEqual(rs.fetchone()[0], 4)
 
+    def test_fetchone_raw_converted_count_mismatch_fails_loudly(self):
+        from unittest.mock import patch
+        from databricks.sql.exc import InternalError
+
+        real_convert = ThriftResultSet._convert_columnar_table
+
+        def convert_dropping_a_row(self_, table):
+            return real_convert(self_, table)[:-1]
+
+        rs = self.make_columnar_result_set(10, arraysize=4)
+        with patch.object(
+            ThriftResultSet,
+            "_convert_columnar_table",
+            autospec=True,
+            side_effect=convert_dropping_a_row,
+        ):
+            with self.assertRaises(InternalError):
+                rs.fetchone()
+
     @pytest.mark.skipif(pa is None, reason="PyArrow is not installed")
     def test_fetchone_then_fetchall_arrow_keeps_order(self):
         rs = self.make_columnar_result_set(10, arraysize=4)