chore: Resolve Gemini review comments

Author: purvavasudeo

apis/Google.Cloud.Spanner.Data/Google.Cloud.Spanner.Data.IntegrationTests/V1/ManagedSessionTests.cs

@@ -77,8 +77,6 @@ public async Task RunReadWriteTransactionWithMultipleQueries()
         Assert.NotNull(transaction.TransactionId);
         Assert.True(transaction.PrecommitToken.SeqNum >= preCommitTokenSeqNumber);
 
-        preCommitTokenSeqNumber = transaction.PrecommitToken.SeqNum;
-
         // Commit the transaction
         var commitResponse = await transaction.CommitAsync(new CommitRequest(), null);
         Assert.NotNull(commitResponse);
@@ -131,12 +129,10 @@ private async Task IncrementByOneAsync(ManagedTransaction transaction, string un
             retryFilter: ignored => false,
             RetrySettings.RandomJitter);
         TimeSpan nextDelay = TimeSpan.Zero;
-        SpannerException spannerException;
         DateTime deadline = DateTime.UtcNow.AddSeconds(30);
 
         while (true)
         {
-            spannerException = null;
             try
             {
                 // We use manually created transactions here so the tests run on .NET Core.
@@ -154,14 +150,13 @@ private async Task IncrementByOneAsync(ManagedTransaction transaction, string un
                 }
 
 
-                ResultSet result;
                 if (current == 0)
                 {
-                    result = await ExecuteInsertInt64Value(transaction, uniqueRowId, current + 1);
+                    await ExecuteInsertInt64Value(transaction, uniqueRowId, current + 1);
                 }
                 else
                 {
-                    result = await ExecuteUpdateInt64Value(transaction, uniqueRowId, current + 1);
+                    await ExecuteUpdateInt64Value(transaction, uniqueRowId, current + 1);
                 }
 
                 await transaction.CommitAsync(new CommitRequest(), null);
@@ -172,7 +167,6 @@ private async Task IncrementByOneAsync(ManagedTransaction transaction, string un
             {
                 nextDelay = retrySettings.NextBackoff(nextDelay);
                 await Task.Delay(retrySettings.BackoffJitter.GetDelay(nextDelay));
-                spannerException = ex;
             }
         }
     }

apis/Google.Cloud.Spanner.Data/Google.Cloud.Spanner.Data.Tests/V1/DirectedReadTests.cs

@@ -325,7 +325,6 @@ public async Task PooledSession_NonReadOnlyTransaction_IgnoresOptionsFromClient_
         }, logger: null);
 
         ManagedTransaction managedTransaction = await CreateManagedTransaction(spannerClient, s_transactionId, options, false);
-        //managedTransaction = managedTransaction.WithTransaction(s_transactionId, options, singleUseTransaction: false);
 
         await managedTransaction.ReadStreamReaderAsync(new ReadRequest(), callSettings: null).HasDataAsync(default);
         Assert.Null(grpcClient.LastReadRequest.DirectedReadOptions);

apis/Google.Cloud.Spanner.Data/Google.Cloud.Spanner.Data/SessionPoolManager.cs

@@ -164,18 +164,7 @@ internal Task<ManagedSession> AcquireManagedSessionAsync(SpannerClientCreationOp
             SessionPoolSegmentKey segmentKey = SessionPoolSegmentKey.Create(dbName).WithDatabaseRole(dbRole);
             GaxPreconditions.CheckNotNull(options, nameof(options));
 
-            if (_targetedSessions.ContainsKey((options, segmentKey)))
-            {
-                return _targetedSessions[(options, segmentKey)];
-            }
-            else
-            {
-                _targetedSessions[(options, segmentKey)] = CreateMultiplexSessionAsync();
-            }
-
-            var muxSession = _targetedSessions[(options, segmentKey)];
-
-            return muxSession;
+            return _targetedSessions.GetOrAdd((options, segmentKey), _ => CreateMultiplexSessionAsync());
 
             async Task<ManagedSession> CreateMultiplexSessionAsync()
             {

apis/Google.Cloud.Spanner.V1/Google.Cloud.Spanner.V1/ManagedSession.cs

@@ -247,7 +247,9 @@ Task TriggerRefresh(double refreshInterval)
                                     if (SessionHasExpired(refreshInterval))
                                     {
                                         // Create/Refresh the session only if it is null or it is older than the refreshInterval
-                                        multiplexSession = await Client.CreateSessionAsync(_createSessionRequestTemplate, callSettings).ConfigureAwait(false);
+                                        multiplexSession = await Client.CreateSessionAsync(_createSessionRequestTemplate, callSettings)
+                                                                       .WithCancellationToken(cancellationToken).ConfigureAwait(false);
+
                                         Interlocked.Exchange(ref _session, multiplexSession);
                                     }
                                 }
@@ -296,12 +298,12 @@ Task TriggerRefresh(double refreshInterval)
     }
 
     /// <summary>
-    /// 
+    /// Builder to build a <see cref="ManagedSession"/>
     /// </summary>
     public sealed partial class SessionBuilder
     {
         /// <summary>
-        /// 
+        /// Constructor with validations on essential parameters needed to build the ManagedSession
         /// </summary>
         public SessionBuilder(DatabaseName databaseName, SpannerClient client)
         {
@@ -330,9 +332,9 @@ public SessionBuilder(DatabaseName databaseName, SpannerClient client)
         public SpannerClient Client { get; set; }
 
         /// <summary>
-        /// 
+        /// Async method to build a managed session. This will fetch a valid session from backend Spanner and wrap it inside the managed session object.
         /// </summary>
-        /// <param name="cancellationToken"></param>
+        /// <param name="cancellationToken">Cancellation token to cancel this call</param>
         /// <returns></returns>
         public async Task<ManagedSession> BuildAsync(CancellationToken cancellationToken = default)
         {

apis/Google.Cloud.Spanner.V1/Google.Cloud.Spanner.V1/ManagedSessionOptions.cs

@@ -17,7 +17,7 @@
 namespace Google.Cloud.Spanner.V1;
 
 /// <summary>
-/// 
+/// Options which can be set on the managed session
 /// </summary>
 public class ManagedSessionOptions
 {

apis/Google.Cloud.Spanner.V1/Google.Cloud.Spanner.V1/ManagedTransaction.cs

@@ -26,7 +26,7 @@
 namespace Google.Cloud.Spanner.V1
 {
     /// <summary>
-    /// 
+    /// Class which manages an underlying Spanner Transaction and operations around it
     /// </summary>
     public partial class ManagedTransaction
     {
@@ -440,23 +440,8 @@ Mutation MaybeFetchMutationKey(Protobuf.Collections.RepeatedField<Mutation> muta
                 // 2. It is a Delete mutation AND Keyset.Keys.Count >= 1
 
                 Mutation filteredMutationKey = mutations.FirstOrDefault(mutation =>
-                {
-                    // Condition 1: Check if it's NOT a Delete mutation
-                    bool isNotDelete = mutation.Delete == null;
-
-                    if (isNotDelete)
-                    {
-                        return true;
-                    }
-
-                    // The mutation MUST be a Delete mutation if we reach this point.
-                    // Condition 2: Check if it's a Delete mutation AND the keyset is not empty
-                    bool isDeleteWithNonEmptyKeySet = mutation.Delete != null &&
-                                            mutation.Delete.KeySet != null &&
-                                            mutation.Delete.KeySet.Keys.Count >= 1;
+                    mutation.Delete is null || (mutation.Delete.KeySet?.Keys.Count ?? 0) >= 1);
 
-                    return isDeleteWithNonEmptyKeySet;
-                });
 
                 return filteredMutationKey;
             }