@@ -202,8 +202,10 @@ def _fetchone_buffered(
     ) -> Optional[Row]:
         """Serve fetchone() from the row buffer, refilling in small batches.
 
-        Each refill fetches ``arraysize`` rows, capped at
-        ``_FETCHONE_BUFFER_MAX_ROWS``.
+        Each refill asks ``fetch_raw`` for up to ``arraysize`` rows, capped at
+        ``_FETCHONE_BUFFER_MAX_ROWS``. ``fetch_raw`` may return fewer (Thrift only
+        serves what its current queue holds, refilling it at most until one row is
+        available, so latency to the first row is unchanged).
 
         ``_next_row_index`` keeps counting rows handed to the caller: rows parked in
         the buffer are subtracted on refill and added back as they are taken. The
@@ -484,6 +486,26 @@ def _fetchmany_columnar_from_queue(self, size: int):
 
         return concat_table_chunks(partial_result_chunks)
 
+    def _fetch_available_from_queue(self, size: int):
+        """Fetch up to ``size`` rows the queue already holds, for fetchone() refills.
+
+        Unlike ``_fetchmany_*_from_queue``, this does not keep calling the server
+        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).
+        Only called while the fetchone() row buffer is empty.
+        """
+        results = self.results.next_n_rows(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)
+        self._next_row_index += results.num_rows
+        return results
+
     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()
@@ -553,9 +575,11 @@ def fetchone(self) -> Optional[Row]:
         """
         if isinstance(self.results, ColumnQueue):
             return self._fetchone_buffered(
-                self.fetchmany_columnar, self._convert_columnar_table
+                self._fetch_available_from_queue, self._convert_columnar_table
             )
-        return self._fetchone_buffered(self.fetchmany_arrow, self._convert_arrow_table)
+        return self._fetchone_buffered(
+            self._fetch_available_from_queue, self._convert_arrow_table
+        )
 
     def fetchall(self) -> List[Row]:
         """
 
@@ -95,7 +95,8 @@ def make_dummy_result_set_from_initial_results(initial_results):
         return rs
 
     @staticmethod
-    def make_dummy_result_set_from_batch_list(batch_list):
+    def make_dummy_result_set_from_batch_list(batch_list, offsets=None):
+        """``offsets``, if given, records ``expected_row_start_offset`` per refill."""
         batch_index = 0
 
         def fetch_results(
@@ -110,6 +111,8 @@ def fetch_results(
             chunk_id=0,
         ):
             nonlocal batch_index
+            if offsets is not None:
+                offsets.append(expected_row_start_offset)
             results = FetchTests.make_arrow_queue(batch_list[batch_index])
             batch_index += 1
 
@@ -328,6 +331,67 @@ def test_fetchone_without_initial_results(self):
         dummy_result_set = self.make_dummy_result_set_from_batch_list(batch_list_2)
         self.assertEqual(dummy_result_set.fetchone(), None)
 
+    def test_mixed_fetches_across_pages_keep_order_and_refill_offsets(self):
+        # Issue #981: rows parked in the fetchone() buffer must not skew
+        # ``_next_row_index``, which Thrift sends as ``expected_row_start_offset``
+        # on every refill. Pages are 3 rows; fetchone() refills 2 rows at a time,
+        # so buffer refills and server page boundaries interleave.
+        batch_list = [[[0], [1], [2]], [[3], [4], [5]], [[6], [7], [8]], [[9]]]
+        offsets = []
+        rs = self.make_dummy_result_set_from_batch_list(batch_list, offsets=offsets)
+        rs.arraysize = 2
+        self.assertEqual(offsets, [0])
+
+        self.assertSequenceEqual(rs.fetchone(), [0])
+        self.assertEqual(rs.rownumber, 1)
+
+        # Drains the buffered row, the rest of page 0, then refills page 1.
+        table = rs.fetchmany_arrow(3)
+        self.assertEqual(table.column(0).to_pylist(), [1, 2, 3])
+        self.assertEqual(rs.rownumber, 4)
+        self.assertEqual(offsets, [0, 3])
+
+        self.assertSequenceEqual(rs.fetchone(), [4])
+        self.assertSequenceEqual(rs.fetchone(), [5])
+        self.assertEqual(rs.rownumber, 6)
+        self.assertEqual(offsets, [0, 3])
+
+        # Buffer empty and page 1 exhausted: the refill crosses into page 2.
+        self.assertSequenceEqual(rs.fetchone(), [6])
+        self.assertEqual(rs.rownumber, 7)
+        self.assertEqual(offsets, [0, 3, 6])
+
+        # Drains the buffered row [7], the rest of page 2, then page 3.
+        self.assertEqualRowValues(rs.fetchall(), [[7], [8], [9]])
+        self.assertEqual(rs.rownumber, 10)
+        self.assertEqual(offsets, [0, 3, 6, 9])
+
+        self.assertIsNone(rs.fetchone())
+        self.assertEqual(rs.rownumber, 10)
+        self.assertEqual(offsets, [0, 3, 6, 9])
+
+    def test_fetchone_refill_does_not_fetch_extra_pages(self):
+        # A refill must not make extra round-trips to fill ``arraysize`` when
+        # server pages are smaller (e.g. byte-limited): it serves what the current
+        # queue holds and only fetches a new page once the queue is empty.
+        batch_list = [[[0], [1]], [[2], [3]], [[4]]]
+        offsets = []
+        rs = self.make_dummy_result_set_from_batch_list(batch_list, offsets=offsets)
+        rs.arraysize = 100
+        self.assertEqual(offsets, [0])
+
+        self.assertSequenceEqual(rs.fetchone(), [0])
+        self.assertEqual(offsets, [0])
+        self.assertSequenceEqual(rs.fetchone(), [1])
+        self.assertEqual(offsets, [0])
+        self.assertSequenceEqual(rs.fetchone(), [2])
+        self.assertEqual(offsets, [0, 2])
+        self.assertEqual(rs.rownumber, 3)
+        self.assertEqualRowValues(rs.fetchall(), [[3], [4]])
+        self.assertEqual(offsets, [0, 2, 4])
+        self.assertIsNone(rs.fetchone())
+        self.assertEqual(rs.rownumber, 5)
+
     # Regression tests for fetchmany_arrow / fetchall_arrow handling of
     # the schemaless CloudFetch placeholder.
     def test_fetchall_arrow_drops_mismatched_empty_placeholder(self):
 
@@ -43,7 +43,7 @@ def close(self):
         self.closed = True
 
 
-def _make_rs(handle, *, disable_pandas=False) -> KernelResultSet:
+def _make_rs(handle, *, disable_pandas=False, arraysize=100) -> KernelResultSet:
     # The base ResultSet __init__ takes a `connection` ref it never
     # actually dereferences during these buffer tests, so a Mock is
     # fine.
@@ -55,7 +55,7 @@ def _make_rs(handle, *, disable_pandas=False) -> KernelResultSet:
         backend=backend,
         kernel_handle=handle,
         command_id=CommandId.from_sea_statement_id("smoke-test"),
-        arraysize=100,
+        arraysize=arraysize,
         buffer_size_bytes=1024,
     )
 
@@ -184,6 +184,69 @@ def test_fetchall_rows(int_schema):
     assert [r[0] for r in rows] == [1, 2, 3]
 
 
+def _ten_rows_handle(int_schema):
+    # Batch boundaries (3/4/3) deliberately don't line up with arraysize=4
+    # so fetchone() refills span kernel batches.
+    return _FakeKernelHandle(
+        int_schema,
+        [
+            _batch(int_schema, [0, 1, 2]),
+            _batch(int_schema, [3, 4, 5, 6]),
+            _batch(int_schema, [7, 8, 9]),
+        ],
+    )
+
+
+def test_mixed_fetches_keep_order_and_rownumber(int_schema):
+    rs = _make_rs(_ten_rows_handle(int_schema), arraysize=4)
+    assert rs.fetchone()[0] == 0
+    assert rs.fetchone()[0] == 1
+    assert rs.rownumber == 2
+    assert [r[0] for r in rs.fetchmany(3)] == [2, 3, 4]
+    assert rs.rownumber == 5
+    assert rs.fetchone()[0] == 5
+    assert rs.rownumber == 6
+    assert [r[0] for r in rs.fetchall()] == [6, 7, 8, 9]
+    assert rs.rownumber == 10
+    assert rs.fetchone() is None
+    assert rs.rownumber == 10
+
+
+def test_fetchone_then_fetchall_arrow_keeps_order(int_schema):
+    rs = _make_rs(_ten_rows_handle(int_schema), arraysize=4)
+    assert rs.fetchone()[0] == 0
+    assert rs.rownumber == 1
+    table = rs.fetchall_arrow()
+    assert table.column(0).to_pylist() == list(range(1, 10))
+    assert rs.rownumber == 10
+
+
+def test_fetchone_then_fetchmany_arrow_keeps_order(int_schema):
+    rs = _make_rs(_ten_rows_handle(int_schema), arraysize=4)
+    assert rs.fetchone()[0] == 0
+    # Served entirely from the fetchone() row buffer (3 rows left in it).
+    assert rs.fetchmany_arrow(2).column(0).to_pylist() == [1, 2]
+    assert rs.rownumber == 3
+    # Drains the last buffered row, then continues from the batch FIFO.
+    assert rs.fetchmany_arrow(3).column(0).to_pylist() == [3, 4, 5]
+    assert rs.rownumber == 6
+    assert rs.fetchmany_arrow(0).num_rows == 0
+    assert rs.rownumber == 6
+    assert rs.fetchmany_arrow(10).column(0).to_pylist() == [6, 7, 8, 9]
+    assert rs.rownumber == 10
+
+
+def test_fetchone_then_fetchmany_rows_spans_buffer(int_schema):
+    rs = _make_rs(_ten_rows_handle(int_schema), arraysize=4)
+    assert rs.fetchone()[0] == 0
+    # 3 rows come from the row buffer, the rest from the batch FIFO.
+    assert [r[0] for r in rs.fetchmany(6)] == [1, 2, 3, 4, 5, 6]
+    assert rs.rownumber == 7
+    assert [r[0] for r in rs.fetchmany(10)] == [7, 8, 9]
+    assert rs.rownumber == 10
+    assert rs.fetchmany(1) == []
+
+
 def test_fetchmany_negative_raises(int_schema):
     rs = _make_rs(_FakeKernelHandle(int_schema, []))
     with pytest.raises(ValueError):