Fix INSERT EXEC stale OID errors by closing target table before clearing context

During major version upgrade tests, BABEL-1944 was failing with could not
open relation with OID errors. The root cause was that error cleanup paths
were calling pltsql_clear_insert_exec_context() WITHOUT first calling
pltsql_insert_exec_close_target_table(), leaving insert_exec_target_rel_oid
set to a stale OID.

When a subsequent INSERT EXEC operation tried to use this stale OID, it
would fail because the relation no longer existed with that OID (tables
get recreated with new OIDs during major version upgrades).

Changes:
1. Add early INSERT EXEC context cleanup at the start of error handling
   (dispatch_stmt_handle_error), before any transaction state checks.
   This ensures the INSERT EXEC state is cleared regardless of transaction
   state, preventing stale OID issues.

2. Add pltsql_insert_exec_close_target_table() calls before
   pltsql_clear_insert_exec_context() in all error cleanup paths:
   - iterative_exec.c: TRY-CATCH cleanup path
   - pl_exec-2.c: exec_stmt_try_catch cleanup

3. Simplify the !IsTransactionBlockActive() branch since INSERT EXEC
   context is now cleaned up earlier. The skip_abort logic now only
   checks pltsql_insert_exec_in_trycatch() without the nested
   pltsql_insert_exec_active() check.

Author: monk0707

contrib/babelfishpg_tsql/src/iterative_exec.c

@@ -1490,6 +1490,25 @@ dispatch_stmt_handle_error(PLtsql_execstate *estate,
 		edata = CopyErrorData();
 		error_mapped = get_tsql_error_code(edata, &last_error);
 		exec_set_error(estate, last_error, edata->sqlerrcode, !error_mapped);
+
+		/*
+		 * Clean up INSERT EXEC context on error.
+		 * This must be done early, before any transaction handling, to ensure
+		 * the INSERT EXEC state is cleared regardless of the transaction state.
+		 * 
+		 * Without this cleanup, if INSERT EXEC fails inside an explicit transaction
+		 * (e.g., BEGIN TRAN; INSERT INTO t EXEC proc; where proc does COMMIT without
+		 * BEGIN TRAN), the INSERT EXEC context remains set. Subsequent queries then
+		 * see pltsql_insert_exec_active() as true and try to use stale OIDs, causing
+		 * "could not open relation with OID" errors.
+		 */
+		if (pltsql_insert_exec_active())
+		{
+			elog(DEBUG1, "TSQL TXN TSQL semantics : Cleaning up INSERT EXEC context on error");
+			pltsql_insert_exec_close_target_table();
+			pltsql_clear_insert_exec_context();
+		}
+
 		if (internal_sp_started &&
 			before_lxid == MyProc->vxid.lxid &&
 			before_subtxn_id == GetCurrentSubTransactionId())
@@ -1515,37 +1534,22 @@ dispatch_stmt_handle_error(PLtsql_execstate *estate,
 			 * 3. The error will be caught by TRY-CATCH and the transaction
 			 *    state will be handled properly when INSERT EXEC completes
 			 *
-			 * IMPORTANT: We only skip the abort if there's a TRY-CATCH that
-			 * will catch the error. If there's no TRY-CATCH, we should clean
-			 * up the INSERT EXEC context and let the transaction abort normally.
-			 * Otherwise, the temp table will be left behind and cause
-			 * "relation already exists" errors on subsequent INSERT EXEC.
+			 * NOTE: The INSERT EXEC context is now cleaned up earlier in the
+			 * error handling path (before the transaction state checks), so
+			 * pltsql_insert_exec_active() will return false here. We keep
+			 * the skip_abort logic for TRY-CATCH handling, but the INSERT EXEC
+			 * cleanup is no longer needed here.
 			 */
 			bool skip_abort = false;
 
 			/*
-			 * Only skip abort for INSERT EXEC if there's a TRY-CATCH that
-			 * will catch the error. If no TRY-CATCH, clean up INSERT EXEC
-			 * context and let the transaction abort.
+			 * Skip abort if there's a TRY-CATCH that will catch the error.
+			 * The INSERT EXEC context has already been cleaned up earlier.
 			 */
-			if (pltsql_insert_exec_active())
+			if (pltsql_insert_exec_in_trycatch())
 			{
-				if (pltsql_insert_exec_in_trycatch())
-				{
-					skip_abort = true;
-					elog(DEBUG1, "TSQL TXN TSQL semantics : Skip transaction rollback during INSERT EXEC (TRY-CATCH will handle)");
-				}
-				else
-				{
-					/*
-					 * No TRY-CATCH to catch the error. Clean up INSERT EXEC
-					 * context so the temp table is dropped when transaction
-					 * aborts. We just clear the context here - the temp table
-					 * will be dropped by the transaction abort.
-					 */
-					elog(DEBUG1, "TSQL TXN TSQL semantics : INSERT EXEC active but no TRY-CATCH, clearing context for cleanup");
-					pltsql_clear_insert_exec_context();
-				}
+				skip_abort = true;
+				elog(DEBUG1, "TSQL TXN TSQL semantics : Skip transaction rollback (TRY-CATCH will handle)");
 			}
 
 			if (!skip_abort)
@@ -1791,7 +1795,10 @@ exec_stmt_iterative(PLtsql_execstate *estate, ExecCodes *exec_codes, ExecConfig_
 
 						elog(DEBUG1, "INSERT-EXEC: Cleaning up after error caught by TRY-CATCH, temp_oid=%u", temp_oid);
 
-						/* Clear the INSERT EXEC context first */
+						/* Close target table and release lock first */
+						pltsql_insert_exec_close_target_table();
+						
+						/* Clear the INSERT EXEC context */
 						pltsql_clear_insert_exec_context();
 
 						/* Drop the temp table if it exists */

contrib/babelfishpg_tsql/src/pl_exec-2.c

@@ -2922,6 +2922,9 @@ exec_stmt_try_catch(PLtsql_execstate *estate, PLtsql_stmt_try_catch *stmt)
 			elog(LOG, "INSERT-EXEC TRY-CATCH cleanup: is_stmt_terminating=%d, insert_exec_was_active=%d, temp_oid=%u",
 				 is_stmt_terminating, insert_exec_was_active, temp_oid);
 
+			/* Close target table and release lock first */
+			pltsql_insert_exec_close_target_table();
+			
 			/* Clear the INSERT EXEC context */
 			pltsql_clear_insert_exec_context();