@@ -2,6 +2,7 @@
 
 # Unreleased
 - Fix inline parameters (`use_inline_params=True`) so a sequence directly after `IN` renders as a list again: `x IN %(ids)s` renders as `x IN (1,2,3)` instead of `x IN ARRAY(1,2,3)`, which Spark rejects. Inside the list, tuples render as rows for a multi-column `IN`, and a `set` or `frozenset` is accepted again. Sequences anywhere else still render as `ARRAY(...)` ([#629](https://github.com/databricks/databricks-sql-python/issues/629))
+- Speed up Thrift response handling: decode replies from a buffered body with Thrift's C-accelerated protocol, and stop stringifying every request/response for the default no-op debug logger. Wide result schemas, metadata calls with many rows, and inline Arrow results benefit most.
 
 # 4.9.0 (2026-11-04)
 - Upgrade Databricks SQL Kernel to 1.4.0, which keeps Lakehouse Real-Time session affinity and flushes shared telemetry only after the final session closes.
 
@@ -11,6 +11,7 @@
 from http.client import HTTPResponse
 from io import BytesIO
 
+from thrift.transport.TTransport import CReadableTransport
 from urllib3 import HTTPConnectionPool, HTTPSConnectionPool, ProxyManager
 from urllib3.util import make_headers
 from databricks.sql.auth.retry import CommandType, DatabricksRetryPolicy
@@ -22,7 +23,7 @@
 logger = logging.getLogger(__name__)
 
 
-class THttpClient(thrift.transport.THttpClient.THttpClient):
+class THttpClient(thrift.transport.THttpClient.THttpClient, CReadableTransport):
     realhost: Optional[str]
     realport: Optional[int]
     proxy_uri: Optional[str]
@@ -94,6 +95,7 @@ def __init__(
         self.retry_policy = retry_policy
 
         self.__wbuf = BytesIO()
+        self.__rbuf = BytesIO()
         self.__resp: Union[None, HTTPResponse] = None
         self.__timeout = None
         self.__custom_headers = None
@@ -153,9 +155,19 @@ def close(self):
         self.__resp and self.__resp.drain_conn()
         self.__resp and self.__resp.release_conn()
         self.__resp = None
+        self.__rbuf = BytesIO()
 
     def read(self, sz):
-        return self.__resp.read(sz)
+        return self.__rbuf.read(sz)
+
+    # CReadableTransport: lets TBinaryProtocolAccelerated decode the buffered body in C.
+    @property
+    def cstringio_buf(self):
+        return self.__rbuf
+
+    def cstringio_refill(self, partialread, reqlen):
+        # The whole response body is already buffered, so a refill means it was truncated.
+        raise EOFError()
 
     def isOpen(self):
         return self.__resp is not None
@@ -207,6 +219,10 @@ def flush(self):
         self.message = self.__resp.reason
         self.headers = self.__resp.headers
 
+        # Thrift decodes the reply one field at a time; reading each field
+        # straight from urllib3 costs far more than the decode itself.
+        self.__rbuf = BytesIO(self.__resp.read())
+
         logger.info(
             "HTTP Response with status code {}, message: {}".format(
                 self.code, self.message
 
@@ -253,7 +253,8 @@ def __init__(
         self._transport.setTimeout(timeout and (float(timeout) * 1000.0))
 
         self._transport.setCustomHeaders(dict(http_headers))
-        protocol = thrift.protocol.TBinaryProtocol.TBinaryProtocol(
+        # Uses thrift's C extension when available, else the pure-Python protocol.
+        protocol = thrift.protocol.TBinaryProtocol.TBinaryProtocolAccelerated(
             self._transport,
             string_length_limit=THRIFT_BINARY_PROTOCOL_STRING_LENGTH_LIMIT,
             container_length_limit=THRIFT_BINARY_PROTOCOL_CONTAINER_LENGTH_LIMIT,
@@ -443,7 +444,9 @@ def attempt_request(attempt):
                 this_method_name = getattr(method, "__name__")
 
                 logger.debug("Sending request: {}(<REDACTED>)".format(this_method_name))
-                unsafe_logger.debug("Sending request: {}".format(request))
+                # Lazy %s args: unsafe_logger is DEBUG-level with a NullHandler by
+                # default, so eager formatting would stringify every payload.
+                unsafe_logger.debug("Sending request: %s", request)
 
                 # These three lines are no-ops if the v3 retry policy is not in use
                 if self.enable_v3_retries:
@@ -457,7 +460,7 @@ def attempt_request(attempt):
                 logger.debug(
                     "Received response: {}(<REDACTED>)".format(type(response).__name__)
                 )
-                unsafe_logger.debug("Received response: {}".format(response))
+                unsafe_logger.debug("Received response: %s", response)
                 return response
 
             except urllib3.exceptions.HTTPError as err:
 
@@ -1,6 +1,7 @@
 from collections import OrderedDict
 from decimal import Decimal
 import itertools
+import logging
 import unittest
 import pytest
 from unittest.mock import patch, MagicMock, Mock
@@ -320,7 +321,7 @@ def test_binary_protocol_preserves_unbounded_string_and_container_limits(
         import thrift.protocol.TBinaryProtocol
 
         with patch(
-            "thrift.protocol.TBinaryProtocol.TBinaryProtocol"
+            "thrift.protocol.TBinaryProtocol.TBinaryProtocolAccelerated"
         ) as mock_protocol_class:
             ThriftDatabricksClient(
                 "foo",
@@ -367,6 +368,108 @@ def test_binary_protocol_reads_result_larger_than_thrift_default_limit(self):
 
         self.assertEqual(protocol.readBinary(), oversized_payload)
 
+    @staticmethod
+    def _http_client_with_reply(reply_bytes):
+        """A real THttpClient whose connection pool returns ``reply_bytes``."""
+        from databricks.sql.auth.thrift_http_client import THttpClient
+
+        http_client = THttpClient(
+            auth_provider=Mock(),
+            uri_or_host="https://example.com/cliservice",
+            ssl_options=SSLOptions(),
+        )
+        http_client.setCustomHeaders({"User-Agent": "test"})
+        http_client.open()
+        mock_resp = Mock(status=200, reason="OK", headers={})
+        mock_resp.read.return_value = reply_bytes
+        http_client._THttpClient__pool = Mock()
+        http_client._THttpClient__pool.request.return_value = mock_resp
+        return http_client, mock_resp
+
+    def test_http_client_buffers_reply_and_decodes_with_accelerated_protocol(self):
+        """The reply body is read from urllib3 once, then decoded from memory,
+        including by the C-accelerated protocol (the transport is a
+        CReadableTransport) for payloads above thrift's ~15.6 MiB default limit."""
+        from thrift.protocol import TBinaryProtocol
+        from thrift.transport import TTransport
+        from databricks.sql.thrift_api.TCLIService import TCLIService
+        from databricks.sql.backend.thrift_backend import (
+            THRIFT_BINARY_PROTOCOL_STRING_LENGTH_LIMIT,
+            THRIFT_BINARY_PROTOCOL_CONTAINER_LENGTH_LIMIT,
+        )
+
+        batch = b"x" * (20 * 1024 * 1024)
+        resp = ttypes.TFetchResultsResp(
+            status=ttypes.TStatus(statusCode=ttypes.TStatusCode.SUCCESS_STATUS),
+            hasMoreRows=False,
+            results=ttypes.TRowSet(
+                startRowOffset=0,
+                rows=[],
+                arrowBatches=[ttypes.TSparkArrowBatch(batch=batch, rowCount=1)],
+            ),
+        )
+        reply = TTransport.TMemoryBuffer()
+        reply_proto = TBinaryProtocol.TBinaryProtocol(reply)
+        reply_proto.writeMessageBegin("FetchResults", 2, 0)  # REPLY
+        TCLIService.FetchResults_result(success=resp).write(reply_proto)
+        reply_proto.writeMessageEnd()
+
+        http_client, mock_resp = self._http_client_with_reply(reply.getvalue())
+        self.assertIsInstance(http_client, TTransport.CReadableTransport)
+        protocol = TBinaryProtocol.TBinaryProtocolAccelerated(
+            http_client,
+            string_length_limit=THRIFT_BINARY_PROTOCOL_STRING_LENGTH_LIMIT,
+            container_length_limit=THRIFT_BINARY_PROTOCOL_CONTAINER_LENGTH_LIMIT,
+        )
+        client = TCLIService.Client(protocol)
+
+        op_handle = ttypes.TOperationHandle(
+            operationId=ttypes.THandleIdentifier(guid=b"g" * 16, secret=b"s" * 16),
+            operationType=ttypes.TOperationType.EXECUTE_STATEMENT,
+            hasResultSet=True,
+        )
+        result = client.FetchResults(
+            ttypes.TFetchResultsReq(operationHandle=op_handle, orientation=0, maxRows=1)
+        )
+
+        self.assertEqual(result.results.arrowBatches[0].batch, batch)
+        mock_resp.read.assert_called_once_with()
+
+        http_client.close()
+        self.assertEqual(http_client.read(1), b"")
+
+    def test_http_client_cstringio_refill_on_truncated_reply_raises(self):
+        http_client, _ = self._http_client_with_reply(b"")
+        with self.assertRaises(EOFError):
+            http_client.cstringio_refill(b"", 4)
+
+    @patch("databricks.sql.backend.thrift_backend.unsafe_logger")
+    @patch("databricks.sql.auth.thrift_http_client.THttpClient")
+    def test_unsafe_logger_formats_payloads_lazily(
+        self, t_http_client_class, mock_unsafe_logger
+    ):
+        """unsafe_logger is DEBUG-level with only a NullHandler by default, so
+        payloads must be passed as %s args rather than pre-formatted strings."""
+        thrift_backend = ThriftDatabricksClient(
+            "foobar",
+            443,
+            "path",
+            [],
+            auth_provider=AuthProvider(),
+            ssl_options=SSLOptions(),
+            http_client=MagicMock(),
+        )
+        request = Mock()
+        response = Mock()
+        response.status.statusCode = ttypes.TStatusCode.SUCCESS_STATUS
+        method = Mock(return_value=response)
+        method.__name__ = "method name"
+
+        thrift_backend.make_request(method, request)
+
+        mock_unsafe_logger.debug.assert_any_call("Sending request: %s", request)
+        mock_unsafe_logger.debug.assert_any_call("Received response: %s", response)
+
     def test_proxy_headers_are_set(self):
 
         from databricks.sql.common.http_utils import create_basic_proxy_auth_headers