[#28761] DocDB: Prevent requesting new txn when releasing object locks on finish if txn doesn't exist

Summary:
`NextObjectLockingTxnMeta` returns transaction if one exists, else creates a new one and waits in-line. This is used for acquiring/releasing object locks when a distributed docdb transaction doesn't exist.

It could happen that we receive redundant finish transaction calls, and try releasing object locks when both docdb transaction and `next_plain_` don't exist. In that case, the release would request a new transaction, which isn't necessary.

The above causes some tests to fail because of the clean shutdown semantics enforced in [[ https://phorge.dev.yugabyte.com/D46293 | commit ]]. This diff fixes the issue by not requesting a new transaction for release/finish calls.
Jira: DB-18473

Test Plan:
Jenkins

Enabled object locking and ran the following
```
PgAutoAnalyzeTest_CheckTableMutationsCount
PgCatalogPerfTest.CacheRefreshRPCCountWithoutPartitionTables
```

Also triggered a jenkins run with table locks enabled and the changes in this revision, some failures in https://phorge.dev.yugabyte.com/D44416 are resolved.

Reviewers: rthallam, amitanand

Reviewed By: amitanand

Subscribers: yql, ybase

Differential Revision: https://phorge.dev.yugabyte.com/D47342

Author: basavaraj29

src/yb/tserver/pg_client_session.cc

@@ -1173,6 +1173,18 @@ class TransactionProvider {
     }
   }
 
+  std::optional<TransactionMetadata> NextTxnMetaForPlainIfExists(CoarseTimePoint deadline) {
+    if (!next_plain_) {
+      return std::nullopt;
+    }
+    auto res = NextTxnMetaForPlain(deadline, true /* is_for_release */);
+    if (!res.ok()) {
+      LOG(DFATAL) << "Unexpected error while fetching existing plain re-usable txn";
+      return std::nullopt;
+    }
+    return *res;
+  }
+
   Result<TransactionMetadata> NextTxnMetaForPlain(
       CoarseTimePoint deadline, bool is_for_release = false) {
     client::internal::InFlightOpsGroupsWithMetadata ops_info;
@@ -3608,10 +3620,16 @@ class PgClientSession::Impl {
       plain_session_has_exclusive_object_locks_.store(false);
       DEBUG_ONLY_TEST_SYNC_POINT("PlainTxnStateReset");
     }
-    auto txn_id = txn
-        ? txn->id()
-        : VERIFY_RESULT(NextObjectLockingTxnMeta(deadline, is_final_release)).transaction_id;
-    return DoReleaseObjectLocks(txn_id, subtxn_id, deadline, has_exclusive_locks);
+    if (txn) {
+      return DoReleaseObjectLocks(txn->id(), subtxn_id, deadline, has_exclusive_locks);
+    }
+    // It could happen that transaction_provider_.next_plain_ is null when txn finish
+    // calls are redundant. If so, treat it as a no-op instead of setting next_plain_.
+    auto opt_txn_meta = transaction_provider_.NextTxnMetaForPlainIfExists(deadline);
+    return opt_txn_meta
+        ? DoReleaseObjectLocks(
+              opt_txn_meta->transaction_id, subtxn_id, deadline, has_exclusive_locks)
+        : Status::OK();
   }
 
   Status DoReleaseObjectLocks(
@@ -3649,10 +3667,8 @@ class PgClientSession::Impl {
 
   [[nodiscard]] bool IsObjectLockingEnabled() const { return ts_lock_manager() != nullptr; }
 
-  Result<TransactionMetadata> NextObjectLockingTxnMeta(
-      CoarseTimePoint deadline, bool is_final_release = false) {
-    auto txn_meta = VERIFY_RESULT(
-        transaction_provider_.NextTxnMetaForPlain(deadline, is_final_release));
+  Result<TransactionMetadata> NextObjectLockingTxnMeta(CoarseTimePoint deadline) {
+    auto txn_meta = VERIFY_RESULT(transaction_provider_.NextTxnMetaForPlain(deadline));
     RegisterLockOwner(txn_meta.transaction_id, txn_meta.status_tablet);
     return txn_meta;
   }