Reject COPY ... FROM STDIN / TO STDOUT with HYC00 instead of poisoning the transaction

COPY ... FROM STDIN and COPY ... TO STDOUT hand the connection over to
libpq's COPY streaming sub-protocol, which this driver does not implement.
handle_execution_result had no case for the PGRES_COPY_IN/OUT/BOTH result
statuses, so a COPY fell into the default branch: we PQclear'd the result
and returned SQL_ERROR while the connection was still in copy mode. The
next command the driver issued (the per-statement SAVEPOINT teardown) then
terminated the copy abnormally ("COPY terminated by new PQexec"), aborting
the whole transaction so every following statement failed with 25P02.

Add connection_abort_active_copy(): end a copy-in with a non-NULL error
string, drain and discard a copy-out, then consume the trailing result(s)
so the connection leaves copy mode. When the unwind leaves the transaction
aborted, mark it FAILED so connection_handle_statement_error rewinds to the
per-statement savepoint and keeps the transaction usable. handle_execution_result
now has explicit PGRES_COPY_IN/OUT/BOTH cases returning HYC00 ("optional
feature not implemented"), covering both the SQLExecDirect and
SQLPrepare/SQLExecute paths.

Detection keys off the libpq result status, not the SQL text, so a
file-based COPY (COPY ... TO '/path', which returns PGRES_COMMAND_OK) or a
column literally named "stdin" is never mistaken for a client-stream COPY.

This restores upstream regression parity: commands-test.c gained a COPY
section in upstream commit bc439e8. Full suite now 60/60 on PostgreSQL 17
and 20.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: davecramer

src/connection.c

@@ -758,3 +758,51 @@ void connection_handle_statement_error(OdbcConnection *connection)
      * leave the transaction FAILED for the application to resolve with its own
      * SQLEndTran(ROLLBACK). */
 }
+
+void connection_abort_active_copy(OdbcConnection *connection, ExecStatusType copy_status)
+{
+    if (!connection || !connection->libpq_connection) {
+        return;
+    }
+    PGconn *libpq_connection = connection->libpq_connection;
+
+    /* A COPY ... FROM STDIN leaves libpq waiting to stream CopyData we will
+     * never produce. End it with a non-NULL error string so the server fails
+     * the COPY immediately instead of blocking in ClientRead forever. */
+    if (copy_status == PGRES_COPY_IN || copy_status == PGRES_COPY_BOTH) {
+        PQputCopyEnd(libpq_connection,
+                     "COPY ... FROM STDIN / TO STDOUT is not supported in ODBC");
+    }
+
+    /* A COPY ... TO STDOUT streams rows to the client. There is no "abort"
+     * primitive for copy-out, so drain and discard the data until the stream
+     * ends, which returns the connection to a normal command state. */
+    if (copy_status == PGRES_COPY_OUT || copy_status == PGRES_COPY_BOTH) {
+        char *copy_row = NULL;
+        int copy_bytes;
+        /* >0 = a row (must be freed), -1 = copy done, -2 = error. */
+        while ((copy_bytes = PQgetCopyData(libpq_connection, &copy_row, 0)) > 0) {
+            if (copy_row) {
+                PQfreemem(copy_row);
+                copy_row = NULL;
+            }
+        }
+        if (copy_row) {
+            PQfreemem(copy_row);
+        }
+    }
+
+    /* Consume the trailing result(s) so the connection leaves copy mode and is
+     * usable again. Aborting a copy-in makes the server report the COPY as
+     * failed, which poisons the surrounding transaction — mark it FAILED so the
+     * caller's statement-error handler rewinds to the per-statement savepoint
+     * and keeps the transaction (and its earlier work) usable. */
+    PGresult *trailing_result;
+    while ((trailing_result = PQgetResult(libpq_connection)) != NULL) {
+        if (PQresultStatus(trailing_result) == PGRES_FATAL_ERROR &&
+            connection->transaction_state == TRANSACTION_STATE_ACTIVE) {
+            connection->transaction_state = TRANSACTION_STATE_FAILED;
+        }
+        PQclear(trailing_result);
+    }
+}

src/connection.h

@@ -415,4 +415,17 @@ void connection_begin_statement_savepoint(OdbcConnection *connection);
  */
 void connection_handle_statement_error(OdbcConnection *connection);
 
+/*
+ * Unwind an in-progress COPY that libpq handed back as PGRES_COPY_IN,
+ * PGRES_COPY_OUT, or PGRES_COPY_BOTH. This driver does not implement the COPY
+ * streaming sub-protocol, so a COPY ... FROM STDIN / TO STDOUT must not be left
+ * mid-stream: doing so would block the backend (copy-in) and cause the next
+ * command the driver issues to terminate the copy abnormally, poisoning the
+ * whole transaction. Ends copy-in with an error, drains copy-out, and consumes
+ * the trailing result(s) so the connection returns to a usable state. When the
+ * unwound copy left the transaction aborted, the connection is marked FAILED so
+ * connection_handle_statement_error can rewind to the per-statement savepoint.
+ */
+void connection_abort_active_copy(OdbcConnection *connection, ExecStatusType copy_status);
+
 #endif /* PSQLODBC2_CONNECTION_H */

src/statement.c

@@ -403,6 +403,35 @@ static SQLRETURN handle_execution_result(OdbcStatement *statement, PGresult *res
         return SQL_ERROR;
     }
 
+    case PGRES_COPY_IN:
+    case PGRES_COPY_OUT:
+    case PGRES_COPY_BOTH: {
+        /* COPY ... FROM STDIN / TO STDOUT hands the connection over to libpq's
+         * COPY streaming sub-protocol, which this driver does not implement.
+         * If left in copy mode, the server would wait forever for CopyData we
+         * never send, and the next command the driver issues (e.g. the
+         * per-statement SAVEPOINT teardown) would terminate the copy abnormally
+         * and abort the whole transaction. Unwind the copy so the connection is
+         * usable again, then report it as an unimplemented optional feature.
+         *
+         * Detection keys off the libpq result STATUS, not the SQL text, so a
+         * file-based COPY (COPY ... TO '/path', which returns PGRES_COMMAND_OK)
+         * or a column literally named "stdin" is never mistaken for a
+         * client-stream COPY. */
+        connection_abort_active_copy(statement->parent_connection, status);
+        PQclear(result);
+
+        /* Match the original driver's wording exactly — the regression suite
+         * compares against "<context>;\n<detail>". */
+        diagnostics_clear(&statement->diagnostics);
+        diagnostics_add_record(&statement->diagnostics,
+                               "HYC00",  /* Optional feature not implemented */
+                               0,
+                               "Error while executing the query;\n"
+                               "COPY ... FROM STDIN / TO STDOUT is not supported in ODBC");
+        return SQL_ERROR;
+    }
+
     default: {
         /* Unexpected result status — extract whatever error info is available */
         diagnostics_clear(&statement->diagnostics);