@@ -197,6 +197,17 @@ def _fetchmany_arrow_unbuffered(self, size: int) -> pyarrow.Table:
         self._ensure_buffered(size)
         return self._take_buffered(size)
 
+    def _fetch_available(self, size: int) -> pyarrow.Table:
+        """Take up to ``size`` rows already buffered, for fetchone() refills.
+
+        Unlike ``_fetchmany_arrow_unbuffered`` this does not keep pulling
+        batches until ``size`` rows are collected: it only pulls from the
+        kernel while the batch FIFO is empty, so latency to the first row
+        matches the pre-buffering behaviour.
+        """
+        self._ensure_buffered(1)
+        return self._take_buffered(min(size, self._buffered_rows()))
+
     @staticmethod
     def _prepend_buffered(
         buffered: Optional[pyarrow.Table], rest: pyarrow.Table
@@ -228,7 +239,7 @@ def fetchone(self) -> Optional[Row]:
         # Rows are converted ``arraysize`` at a time and served from the
         # base-class row buffer; converting one row per call is very slow.
         return self._fetchone_buffered(
-            self._fetchmany_arrow_unbuffered, self._convert_arrow_table
+            self._fetch_available, self._convert_arrow_table
         )
 
     def fetchmany(self, size: int) -> List[Row]:
@@ -258,6 +269,9 @@ def close(self) -> None:
         connection-close would otherwise issue a kernel call into an
         already-disposed session.
         """
+        # Drop rows parked by fetchone() so post-close fetches return
+        # nothing, matching the cleared batch FIFO below.
+        self._row_buffer_clear()
         if self._kernel_handle is None:
             return
         if not self.connection.open:
 
@@ -203,9 +203,9 @@ def _fetchone_buffered(
         """Serve fetchone() from the row buffer, refilling in small batches.
 
         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).
+        ``_FETCHONE_BUFFER_MAX_ROWS``. ``fetch_raw`` may return fewer (Thrift and the
+        kernel backend only serve what is already buffered, refilling 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
@@ -283,6 +283,8 @@ def close(self) -> None:
             if isinstance(e.args[1], CursorAlreadyClosedError):
                 logger.info("Operation was canceled by a prior request")
         finally:
+            # Drop rows parked by fetchone() so post-close fetches return nothing.
+            self._row_buffer_clear()
             self.has_been_closed_server_side = True
             self.status = CommandState.CLOSED
 
@@ -411,7 +413,7 @@ def fetchmany_arrow(self, size: int) -> "pyarrow.Table":
         An empty sequence is returned when no more rows are available.
         """
         if size < 0:
-            raise ValueError("size argument for fetchmany is %s but must be >= 0", size)
+            raise ValueError(f"size argument for fetchmany is {size} but must be >= 0")
         buffered = self._row_buffer_take_raw(size)
         remaining = size - (buffered.num_rows if buffered is not None else 0)
         rest = self._fetchmany_arrow_from_queue(remaining) if remaining > 0 else None
@@ -425,7 +427,7 @@ def fetchmany_columnar(self, size: int):
         An empty sequence is returned when no more rows are available.
         """
         if size < 0:
-            raise ValueError("size argument for fetchmany is %s but must be >= 0", size)
+            raise ValueError(f"size argument for fetchmany is {size} but must be >= 0")
         buffered = self._row_buffer_take_raw(size)
         remaining = size - (buffered.num_rows if buffered is not None else 0)
         rest = self._fetchmany_columnar_from_queue(remaining) if remaining > 0 else None
@@ -436,7 +438,7 @@ def fetchmany_columnar(self, size: int):
     def _fetchmany_arrow_from_queue(self, size: int) -> "pyarrow.Table":
         """Fetch up to ``size`` rows from the results queue, bypassing the row buffer."""
         if size < 0:
-            raise ValueError("size argument for fetchmany is %s but must be >= 0", size)
+            raise ValueError(f"size argument for fetchmany is {size} but must be >= 0")
 
         # Hold 0-row chunks aside instead of appending them to ``partial_result_chunks``.
         # CloudFetchQueue may return a placeholder empty table whose schema does not
@@ -473,7 +475,7 @@ def _fetchmany_arrow_from_queue(self, size: int) -> "pyarrow.Table":
     def _fetchmany_columnar_from_queue(self, size: int):
         """Fetch up to ``size`` rows from the results queue, bypassing the row buffer."""
         if size < 0:
-            raise ValueError("size argument for fetchmany is %s but must be >= 0", size)
+            raise ValueError(f"size argument for fetchmany is {size} but must be >= 0")
 
         results = self.results.next_n_rows(size)
         n_remaining_rows = size - results.num_rows
@@ -605,7 +607,7 @@ def fetchmany(self, size: int) -> List[Row]:
         An empty sequence is returned when no more rows are available.
         """
         if size < 0:
-            raise ValueError("size argument for fetchmany is %s but must be >= 0", size)
+            raise ValueError(f"size argument for fetchmany is {size} but must be >= 0")
         buffered = self._row_buffer_take_rows(size)
         remaining = size - len(buffered)
         if buffered and remaining == 0:
 
@@ -212,6 +212,20 @@ def test_mixed_fetches_keep_order_and_rownumber(int_schema):
     assert rs.rownumber == 10
 
 
+def test_fetchone_refill_pulls_at_most_one_batch(int_schema):
+    # First-row latency: a fetchone() refill must not loop fetch_next_batch()
+    # until arraysize rows are buffered.
+    handle = _ten_rows_handle(int_schema)
+    rs = _make_rs(handle, arraysize=100)
+    assert rs.fetchone()[0] == 0
+    assert len(handle._batches) == 2
+    assert rs.fetchone()[0] == 1
+    assert rs.fetchone()[0] == 2
+    assert len(handle._batches) == 2
+    assert rs.fetchone()[0] == 3
+    assert len(handle._batches) == 1
+
+
 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
@@ -224,10 +238,11 @@ def test_fetchone_then_fetchall_arrow_keeps_order(int_schema):
 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).
+    # Served entirely from the fetchone() row buffer (2 rows left in it: the
+    # refill only took the first kernel batch).
     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.
+    # Row buffer is empty; 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
@@ -239,7 +254,7 @@ def test_fetchone_then_fetchmany_arrow_keeps_order(int_schema):
 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.
+    # 2 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]
@@ -264,6 +279,15 @@ def test_close_is_idempotent_and_calls_handle(int_schema):
     rs.close()  # second call is a no-op (kernel handle is None)
 
 
+def test_close_drops_fetchone_row_buffer(int_schema):
+    # Rows parked in the fetchone() buffer must not survive close().
+    rs = _make_rs(_ten_rows_handle(int_schema), arraysize=4)
+    assert rs.fetchone()[0] == 0
+    rs.close()
+    assert rs.fetchone() is None
+    assert rs.fetchall() == []
+
+
 def test_empty_stream(int_schema):
     rs = _make_rs(_FakeKernelHandle(int_schema, []))
     assert rs.fetchone() is None
 
@@ -579,6 +579,85 @@ def test_json_fetchone_then_fetchall_arrow_keeps_order(
         assert table.column(1).to_pylist() == list(range(1, 10))
         assert rs.rownumber == 10
 
+    def _make_arrow_result_set(
+        self, mock_connection, mock_sea_client, execute_response, n_rows, arraysize
+    ):
+        from databricks.sql.utils import ArrowQueue
+
+        mock_connection.disable_pandas = True
+        table = pyarrow.Table.from_pydict(
+            {
+                "col1": ["v{}".format(i) for i in range(n_rows)],
+                "col2": list(range(n_rows)),
+                "col3": [True] * n_rows,
+            }
+        )
+        result_data = ResultData(data=None, external_links=None, row_count=n_rows)
+        with patch(
+            "databricks.sql.backend.sea.queue.SeaResultSetQueueFactory.build_queue",
+            return_value=ArrowQueue(table, n_rows),
+        ):
+            return SeaResultSet(
+                connection=mock_connection,
+                execute_response=execute_response,
+                sea_client=mock_sea_client,
+                result_data=result_data,
+                manifest=self._create_empty_manifest(ResultFormat.ARROW_STREAM),
+                buffer_size_bytes=1000,
+                arraysize=arraysize,
+            )
+
+    @pytest.mark.skipif(pyarrow is None, reason="PyArrow is not installed")
+    def test_arrow_mixed_fetches_keep_order_and_rownumber(
+        self, mock_connection, mock_sea_client, execute_response
+    ):
+        """Buffered Arrow slice joined with the queue's next chunk via concat."""
+        rs = self._make_arrow_result_set(
+            mock_connection, mock_sea_client, execute_response, 10, arraysize=4
+        )
+        assert rs.fetchone().col2 == 0
+        assert rs.rownumber == 1
+        # 3 rows left in the buffer; ask for 5 so 2 must come from the queue.
+        table = rs.fetchmany_arrow(5)
+        assert isinstance(table, pyarrow.Table)
+        assert table.column(1).to_pylist() == [1, 2, 3, 4, 5]
+        assert rs.rownumber == 6
+        assert rs.fetchone().col2 == 6
+        assert rs.rownumber == 7
+        # Fully served from the buffer (remaining == 0 path).
+        assert rs.fetchmany_arrow(1).column(1).to_pylist() == [7]
+        assert rs.rownumber == 8
+        assert [r.col2 for r in rs.fetchall()] == [8, 9]
+        assert rs.rownumber == 10
+        assert rs.fetchone() is None
+
+    @pytest.mark.skipif(pyarrow is None, reason="PyArrow is not installed")
+    def test_arrow_buffer_with_exhausted_queue_returns_buffer(
+        self, mock_connection, mock_sea_client, execute_response
+    ):
+        """Queue returns a 0-row slice after the buffer drains: buffered rows only."""
+        rs = self._make_arrow_result_set(
+            mock_connection, mock_sea_client, execute_response, 3, arraysize=10
+        )
+        assert rs.fetchone().col2 == 0
+        table = rs.fetchmany_arrow(5)
+        assert table.column(1).to_pylist() == [1, 2]
+        assert rs.rownumber == 3
+        assert rs.fetchall_arrow().num_rows == 0
+        assert rs.rownumber == 3
+
+    @pytest.mark.skipif(pyarrow is None, reason="PyArrow is not installed")
+    def test_arrow_fetchone_then_fetchall_arrow_keeps_order(
+        self, mock_connection, mock_sea_client, execute_response
+    ):
+        rs = self._make_arrow_result_set(
+            mock_connection, mock_sea_client, execute_response, 10, arraysize=4
+        )
+        assert rs.fetchone().col2 == 0
+        table = rs.fetchall_arrow()
+        assert table.column(1).to_pylist() == list(range(1, 10))
+        assert rs.rownumber == 10
+
     def test_is_staging_operation(
         self, mock_connection, mock_sea_client, execute_response
     ):