@@ -300,6 +300,8 @@ function Export-DbaCsv {
 
             # The finally makes sure the connection is also closed when the export fails and the catch
             # continues with the next instance, and when -WhatIf skips the export altogether.
+            $cmd = $null
+            $reader = $null
             try {
                 $sqlToExecute = $null
 
@@ -355,6 +357,19 @@ function Export-DbaCsv {
                     }
                 }
             } finally {
+                # The reader is only closed inside the try after a successful write. When the writer fails, the reader
+                # stays open on the connection with the rest of the rows unread. A connection the caller passed in is
+                # not disconnected below, so their next query on it fails because of the open reader.
+                if ($reader -and -not $reader.IsClosed) {
+                    try {
+                        # Cancel the command first: closing a reader with unread rows would otherwise drain the whole
+                        # remaining result set from the server before it returns.
+                        $cmd.Cancel()
+                        $reader.Close()
+                    } catch {
+                        Write-Message -Level Debug -Message "Failed to close the reader: $PSItem"
+                    }
+                }
                 if ($isNewConnection) {
                     # -WhatIf:$false because this is ownership bookkeeping, not the user's operation:
                     # Disconnect-DbaInstance supports ShouldProcess, so a propagated $WhatIfPreference
 
@@ -386,6 +386,63 @@ where program_name like 'dbatools%'
         }
     }
 
+    Context "When writing the file fails on a connection of the caller" {
+        BeforeAll {
+            $PSDefaultParameterValues["*-Dba*:EnableException"] = $true
+            # The command does not disconnect a server object it was given, so only its own cleanup can close the
+            # reader on that connection. Connect-DbaInstance hands back that object itself when it already is in the
+            # database the command asks for, master here; for any other database the command works on a copy of its
+            # own, which it disconnects. The second connection checks the server from outside.
+            $callerServer = Connect-DbaInstance -SqlInstance $TestConfig.InstanceSingle -NonPooledConnection
+            $checkServer = Connect-DbaInstance -SqlInstance $TestConfig.InstanceSingle -NonPooledConnection
+            $PSDefaultParameterValues.Remove("*-Dba*:EnableException")
+
+            # The file is held open without sharing, so the CSV writer cannot open it. The writer is created after
+            # the query has started, and the cross join makes sure the server has far more rows to send than the
+            # client has read by then. The marker in the SELECT finds the request afterwards, the session of the
+            # check is excluded because the text of the check contains the marker too.
+            $lockedPath = "$testExportPath\locked-$(Get-Random).csv"
+            $lockedFile = [System.IO.File]::Open($lockedPath, [System.IO.FileMode]::Create, [System.IO.FileAccess]::ReadWrite, [System.IO.FileShare]::None)
+            $readerQuery = "SELECT 'dbatoolsci_csvreader_marker' AS id FROM sys.all_objects AS a CROSS JOIN sys.all_objects AS b"
+            $readerRequestQuery = "SELECT r.session_id FROM sys.dm_exec_requests AS r CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) AS t WHERE t.text LIKE '%dbatoolsci_csvreader_marker%' AND r.session_id <> @@SPID"
+            try {
+                $splatLockedExport = @{
+                    SqlInstance   = $callerServer
+                    Database      = "master"
+                    Query         = $readerQuery
+                    Path          = $lockedPath
+                    WarningAction = "SilentlyContinue"
+                }
+                $lockedResult = Export-DbaCsv @splatLockedExport
+                $lockedWarning = $WarnVar
+            } finally {
+                $lockedFile.Dispose()
+            }
+        }
+
+        AfterAll {
+            # A request left behind by the old code would keep running until its session is gone.
+            foreach ($leakedRequest in $checkServer.Query($readerRequestQuery)) {
+                $null = $checkServer.Query("KILL $($leakedRequest.session_id)")
+            }
+            $callerServer.ConnectionContext.Disconnect()
+            $checkServer.ConnectionContext.Disconnect()
+        }
+
+        It "Warns and returns nothing" {
+            $lockedResult | Should -BeNullOrEmpty
+            ($lockedWarning -join " ") | Should -BeLike "*Failed to export data from*"
+        }
+
+        It "Stops the query on the server" {
+            @($checkServer.Query($readerRequestQuery)).Count | Should -Be 0
+        }
+
+        It "Leaves the connection of the caller usable" {
+            $callerServer.Query("SELECT 1 AS one").one | Should -Be 1
+        }
+    }
+
     Context "Compression options (issue #8646)" {
         It "exports with each compression type" {
             $compressionTypes = @("None", "GZip", "Deflate")