@@ -209,9 +209,15 @@ def _fetch_available(self, size: int) -> pyarrow.Table:
         return self._take_buffered(min(size, self._buffered_rows()))
 
     @staticmethod
-    def _prepend_buffered(
+    def _concat_buffered_arrow(
         buffered: Optional[pyarrow.Table], rest: pyarrow.Table
     ) -> pyarrow.Table:
+        """Prepend rows drained from the fetchone() buffer to ``rest``.
+
+        Both tables are built against the result set's ``_schema``, so a plain
+        ``pyarrow.concat_tables`` suffices (no ColumnTable / schema
+        promotion handling as in ``ThriftResultSet._prepend_buffered``).
+        """
         if buffered is None:
             return rest
         if rest.num_rows == 0:
@@ -220,7 +226,7 @@ def _prepend_buffered(
 
     def fetchall_arrow(self) -> pyarrow.Table:
         buffered = self._row_buffer_take_raw()
-        return self._prepend_buffered(buffered, self._drain())
+        return self._concat_buffered_arrow(buffered, self._drain())
 
     def fetchmany_arrow(self, size: int) -> pyarrow.Table:
         if size < 0:
@@ -229,7 +235,7 @@ def fetchmany_arrow(self, size: int) -> pyarrow.Table:
         remaining = size - (buffered.num_rows if buffered is not None else 0)
         if buffered is not None and remaining == 0:
             return buffered
-        return self._prepend_buffered(
+        return self._concat_buffered_arrow(
             buffered, self._fetchmany_arrow_unbuffered(remaining)
         )
 
 
@@ -5,6 +5,8 @@
 import unittest
 from unittest.mock import MagicMock, patch
 
+import pytest
+
 from databricks.sql.backend.sea.utils.filters import ResultSetFilter
 
 
@@ -153,5 +155,121 @@ def test_filter_tables_by_type(self):
             )
 
 
+class TestResultSetFilterWithFetchoneBuffer(unittest.TestCase):
+    """Rows buffered by fetchone() on a real SeaResultSet must reach the filter."""
+
+    N_ROWS = 12
+
+    def _row_type(self, i):
+        return "TABLE" if i % 2 == 0 else "VIEW"
+
+    def _make_result_set(self, queue, result_format):
+        from databricks.sql.backend.sea.models.base import ResultData, ResultManifest
+        from databricks.sql.backend.sea.result_set import SeaResultSet
+        from databricks.sql.backend.types import CommandId, CommandState
+
+        connection = MagicMock()
+        connection.open = True
+        connection.disable_pandas = True
+        sea_client = MagicMock()
+        sea_client.max_download_threads = 10
+
+        execute_response = MagicMock()
+        execute_response.command_id = CommandId.from_sea_statement_id("stmt-1")
+        execute_response.status = CommandState.SUCCEEDED
+        execute_response.has_been_closed_server_side = False
+        execute_response.description = [
+            ("table_name", "string", None, None, None, None, None),
+            ("table_type", "string", None, None, None, None, None),
+        ]
+        execute_response.is_staging_operation = False
+        execute_response.lz4_compressed = False
+        execute_response.arrow_schema_bytes = None
+
+        manifest = ResultManifest(
+            format=result_format.value,
+            schema={},
+            total_row_count=self.N_ROWS,
+            total_byte_count=-1,
+            total_chunk_count=-1,
+        )
+        with patch(
+            "databricks.sql.backend.sea.queue.SeaResultSetQueueFactory.build_queue",
+            return_value=queue,
+        ):
+            return SeaResultSet(
+                connection=connection,
+                execute_response=execute_response,
+                sea_client=sea_client,
+                result_data=ResultData(data=None, external_links=None),
+                manifest=manifest,
+                buffer_size_bytes=1000,
+                arraysize=100,
+            )
+
+    def _consume_two_rows(self, rs):
+        # 1st fetchone() refills 1 row, 2nd refills 10: rows 2..10 stay buffered
+        # and row 11 is still in the queue.
+        self.assertEqual(rs.fetchone()[0], "t0")
+        self.assertEqual(rs.fetchone()[0], "t1")
+        self.assertGreater(rs._row_buffer_count(), 0)
+
+    def _expected_names(self):
+        return [
+            "t{}".format(i)
+            for i in range(2, self.N_ROWS)
+            if self._row_type(i) == "TABLE"
+        ]
+
+    def test_json_filter_includes_rows_buffered_by_fetchone(self):
+        from databricks.sql.backend.sea.queue import JsonQueue
+        from databricks.sql.backend.sea.utils.constants import ResultFormat
+
+        data = [["t{}".format(i), self._row_type(i)] for i in range(self.N_ROWS)]
+        rs = self._make_result_set(JsonQueue(data), ResultFormat.JSON_ARRAY)
+        self._consume_two_rows(rs)
+
+        with patch(
+            "databricks.sql.backend.sea.result_set.SeaResultSet"
+        ) as mock_sea_result_set_class:
+            ResultSetFilter._filter_json_result_set(
+                rs, 1, ["TABLE"], case_sensitive=True
+            )
+            result_data = mock_sea_result_set_class.call_args.kwargs["result_data"]
+
+        self.assertEqual([r[0] for r in result_data.data], self._expected_names())
+        self.assertEqual(rs.rownumber, self.N_ROWS)
+
+    def test_arrow_filter_includes_rows_buffered_by_fetchone(self):
+        pyarrow = pytest.importorskip("pyarrow")
+        from databricks.sql.backend.sea.utils.constants import ResultFormat
+        from databricks.sql.utils import ArrowQueue
+
+        table = pyarrow.Table.from_pydict(
+            {
+                "table_name": ["t{}".format(i) for i in range(self.N_ROWS)],
+                "table_type": [self._row_type(i) for i in range(self.N_ROWS)],
+            }
+        )
+        rs = self._make_result_set(
+            ArrowQueue(table, self.N_ROWS), ResultFormat.ARROW_STREAM
+        )
+        self._consume_two_rows(rs)
+
+        with patch(
+            "databricks.sql.backend.sea.result_set.SeaResultSet"
+        ) as mock_sea_result_set_class:
+            ResultSetFilter._filter_arrow_result_set(
+                rs, 1, ["TABLE"], case_sensitive=True
+            )
+            result_data = mock_sea_result_set_class.call_args.kwargs["result_data"]
+
+        filtered = pyarrow.ipc.open_stream(result_data.attachment).read_all()
+        self.assertEqual(
+            filtered.column("table_name").to_pylist(), self._expected_names()
+        )
+        self.assertEqual(rs.rownumber, self.N_ROWS)
+
+
 if __name__ == "__main__":
     unittest.main()