From bc9607311c36e26f03beeae049a30df599e33075 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Feb 2026 15:59:53 +0000
Subject: [PATCH 1/5] Initial plan


From acd1f4ec4822f071ebe54cc0dec0a64006215d8d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Feb 2026 16:06:35 +0000
Subject: [PATCH 2/5] Fix SessionPool client return bug on reconnection failure

- Add shouldReturnClient flag to track reconnection status
- Set flag to false when reconnection fails to prevent returning closed clients
- Prevents pool from accumulating dead clients when operations fail

Co-authored-by: CritasWang <19721744+CritasWang@users.noreply.github.com>
---
 src/Apache.IoTDB/SessionPool.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Apache.IoTDB/SessionPool.cs b/src/Apache.IoTDB/SessionPool.cs
index fc2eca0..d0e22af 100644
--- a/src/Apache.IoTDB/SessionPool.cs
+++ b/src/Apache.IoTDB/SessionPool.cs
@@ -157,6 +157,7 @@ protected internal SessionPool(List<string> nodeUrls, string username, string pa
         public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<TResult> operation, string errMsg, bool retryOnFailure = true, bool putClientBack = true)
         {
             Client client = _clients.Take();
+            bool shouldReturnClient = true;
             try
             {
                 var resp = await operation(client);
@@ -173,6 +174,8 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                     }
                     catch (TException retryEx)
                     {
+                        // Reconnection failed, client is closed and should not be returned to pool
+                        shouldReturnClient = false;
                         throw new TException(errMsg, retryEx);
                     }
                 }
@@ -192,6 +195,8 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                     }
                     catch (TException retryEx)
                     {
+                        // Reconnection failed, client is closed and should not be returned to pool
+                        shouldReturnClient = false;
                         throw new TException(errMsg, retryEx);
                     }
                 }
@@ -202,7 +207,7 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
             }
             finally
             {
-                if (putClientBack)
+                if (putClientBack && shouldReturnClient)
                 {
                     _clients.Add(client);
                 }

From fb8feb5a64d8f92750ec65bbc838fa7812ae8b12 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Feb 2026 16:17:14 +0000
Subject: [PATCH 3/5] Fix client leak when query operations throw exceptions

- When putClientBack=false (query ops), return client if operation fails
- Added operationSucceeded flag to track success/failure
- Catch all exception types from Reconnect to prevent closed client return
- Ensures clients are returned when SessionDataSet isn't created

Co-authored-by: CritasWang <19721744+CritasWang@users.noreply.github.com>
---
 src/Apache.IoTDB/SessionPool.cs | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/Apache.IoTDB/SessionPool.cs b/src/Apache.IoTDB/SessionPool.cs
index d0e22af..4d26c8c 100644
--- a/src/Apache.IoTDB/SessionPool.cs
+++ b/src/Apache.IoTDB/SessionPool.cs
@@ -158,9 +158,11 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
         {
             Client client = _clients.Take();
             bool shouldReturnClient = true;
+            bool operationSucceeded = false;
             try
             {
                 var resp = await operation(client);
+                operationSucceeded = true;
                 return resp;
             }
             catch (TException ex)
@@ -170,7 +172,9 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                     try
                     {
                         client = await Reconnect(client);
-                        return await operation(client);
+                        var resp = await operation(client);
+                        operationSucceeded = true;
+                        return resp;
                     }
                     catch (TException retryEx)
                     {
@@ -178,6 +182,12 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                         shouldReturnClient = false;
                         throw new TException(errMsg, retryEx);
                     }
+                    catch (Exception retryEx)
+                    {
+                        // Reconnection failed with non-TException, client is closed and should not be returned to pool
+                        shouldReturnClient = false;
+                        throw new TException(errMsg, retryEx);
+                    }
                 }
                 else
                 {
@@ -191,7 +201,9 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                     try
                     {
                         client = await Reconnect(client);
-                        return await operation(client);
+                        var resp = await operation(client);
+                        operationSucceeded = true;
+                        return resp;
                     }
                     catch (TException retryEx)
                     {
@@ -199,6 +211,12 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                         shouldReturnClient = false;
                         throw new TException(errMsg, retryEx);
                     }
+                    catch (Exception retryEx)
+                    {
+                        // Reconnection failed with non-TException, client is closed and should not be returned to pool
+                        shouldReturnClient = false;
+                        throw new TException(errMsg, retryEx);
+                    }
                 }
                 else
                 {
@@ -207,7 +225,11 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
             }
             finally
             {
-                if (putClientBack && shouldReturnClient)
+                // Return client to pool if:
+                // 1. putClientBack is true (normal operations), OR
+                // 2. putClientBack is false BUT operation failed (query operations where SessionDataSet wasn't created)
+                // Do NOT return if reconnection failed (shouldReturnClient is false) because client was closed
+                if (shouldReturnClient && (putClientBack || !operationSucceeded))
                 {
                     _clients.Add(client);
                 }

From 1b3408da98f809435759afa052e13860d3ac1ad3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Feb 2026 16:18:53 +0000
Subject: [PATCH 4/5] Improve exception handling clarity and reduce duplication

- Consolidated duplicate catch blocks into single Exception catch
- Added shouldReturnForQueryFailure variable for clearer logic
- Enhanced comments to explain client return conditions

Co-authored-by: CritasWang <19721744+CritasWang@users.noreply.github.com>
---
 src/Apache.IoTDB/SessionPool.cs | 28 ++++++++++------------------
 1 file changed, 10 insertions(+), 18 deletions(-)

diff --git a/src/Apache.IoTDB/SessionPool.cs b/src/Apache.IoTDB/SessionPool.cs
index 4d26c8c..489fbd8 100644
--- a/src/Apache.IoTDB/SessionPool.cs
+++ b/src/Apache.IoTDB/SessionPool.cs
@@ -176,15 +176,10 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                         operationSucceeded = true;
                         return resp;
                     }
-                    catch (TException retryEx)
-                    {
-                        // Reconnection failed, client is closed and should not be returned to pool
-                        shouldReturnClient = false;
-                        throw new TException(errMsg, retryEx);
-                    }
                     catch (Exception retryEx)
                     {
-                        // Reconnection failed with non-TException, client is closed and should not be returned to pool
+                        // Reconnection failed or retry operation failed
+                        // Client is closed by Reconnect, should not be returned to pool
                         shouldReturnClient = false;
                         throw new TException(errMsg, retryEx);
                     }
@@ -205,15 +200,10 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                         operationSucceeded = true;
                         return resp;
                     }
-                    catch (TException retryEx)
-                    {
-                        // Reconnection failed, client is closed and should not be returned to pool
-                        shouldReturnClient = false;
-                        throw new TException(errMsg, retryEx);
-                    }
                     catch (Exception retryEx)
                     {
-                        // Reconnection failed with non-TException, client is closed and should not be returned to pool
+                        // Reconnection failed or retry operation failed
+                        // Client is closed by Reconnect, should not be returned to pool
                         shouldReturnClient = false;
                         throw new TException(errMsg, retryEx);
                     }
@@ -226,10 +216,12 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
             finally
             {
                 // Return client to pool if:
-                // 1. putClientBack is true (normal operations), OR
-                // 2. putClientBack is false BUT operation failed (query operations where SessionDataSet wasn't created)
-                // Do NOT return if reconnection failed (shouldReturnClient is false) because client was closed
-                if (shouldReturnClient && (putClientBack || !operationSucceeded))
+                // 1. putClientBack is true (normal operations - client should always be returned), OR
+                // 2. putClientBack is false (query operations) BUT operation failed, meaning SessionDataSet 
+                //    wasn't created and won't manage the client
+                // Do NOT return if reconnection failed (shouldReturnClient is false) because client was closed by Reconnect
+                bool shouldReturnForQueryFailure = !putClientBack && !operationSucceeded;
+                if (shouldReturnClient && (putClientBack || shouldReturnForQueryFailure))
                 {
                     _clients.Add(client);
                 }

From 2721efd23cda3fd19f45d7fb1ef705139566e3a9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Thu, 5 Feb 2026 16:39:46 +0000
Subject: [PATCH 5/5] Preserve server error messages in exception handling

- Concatenate original error message with context in all exception wrapping
- Ensures server-side error details are visible to callers
- Applied to all exception handling paths in ExecuteClientOperationAsync

Co-authored-by: CritasWang <19721744+CritasWang@users.noreply.github.com>
---
 src/Apache.IoTDB/SessionPool.cs | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/Apache.IoTDB/SessionPool.cs b/src/Apache.IoTDB/SessionPool.cs
index 489fbd8..13a05fc 100644
--- a/src/Apache.IoTDB/SessionPool.cs
+++ b/src/Apache.IoTDB/SessionPool.cs
@@ -181,12 +181,16 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                         // Reconnection failed or retry operation failed
                         // Client is closed by Reconnect, should not be returned to pool
                         shouldReturnClient = false;
-                        throw new TException(errMsg, retryEx);
+                        // Preserve original error message from server
+                        string detailedMsg = $"{errMsg}. {retryEx.Message}";
+                        throw new TException(detailedMsg, retryEx);
                     }
                 }
                 else
                 {
-                    throw new TException(errMsg, ex);
+                    // Preserve original error message from server
+                    string detailedMsg = $"{errMsg}. {ex.Message}";
+                    throw new TException(detailedMsg, ex);
                 }
             }
             catch (Exception ex)
@@ -205,12 +209,16 @@ public async Task<TResult> ExecuteClientOperationAsync<TResult>(AsyncOperation<T
                         // Reconnection failed or retry operation failed
                         // Client is closed by Reconnect, should not be returned to pool
                         shouldReturnClient = false;
-                        throw new TException(errMsg, retryEx);
+                        // Preserve original error message from server
+                        string detailedMsg = $"{errMsg}. {retryEx.Message}";
+                        throw new TException(detailedMsg, retryEx);
                     }
                 }
                 else
                 {
-                    throw new TException(errMsg, ex);
+                    // Preserve original error message from server
+                    string detailedMsg = $"{errMsg}. {ex.Message}";
+                    throw new TException(detailedMsg, ex);
                 }
             }
             finally