Executing GraphQL and REST Mutations in a transaction

src/Service.Tests/SqlTests/GraphQLMutationTests/GraphQLMutationTestBase.cs

@@ -677,6 +677,185 @@ public async Task DeleteMutationWithVariablesAndMappings(string dbQuery, string
             Assert.AreEqual(result.RootElement.GetProperty("count").GetInt64(), 0);
         }
 
+        /// <summary>
+        /// Performs concurrent update mutations on the same item and validates that the responses
+        /// returned are consistent
+        /// gQLMutation1 : Updates the title column of Book table to New Title
+        /// gQLMutation2 : Updates the title column of Book table to Updated Title
+        /// The title field in the responses returned for each of the mutations should be
+        /// the same value it had written to the table.
+        /// </summary>
+        [TestMethod]
+        public async Task TestParallelUpdateMutations()
+        {
+            string graphQLMutationName = "updatebook";
+            string gQLMutation1 = @"
+                mutation {
+                    updatebook(id : 1, item: { title: ""New Title"" })
+                    {
+                        title
+                    }
+                }";
+
+            string gQLMutation2 = @"
+                mutation {
+                    updatebook(id : 1, item: { title: ""Updated Title"" })
+                    {
+                        title
+                    }
+                }";
+
+            Task<JsonElement> responeTask1 = ExecuteGraphQLRequestAsync(gQLMutation1, graphQLMutationName, isAuthenticated: true);
+            Task<JsonElement> responseTask2 = ExecuteGraphQLRequestAsync(gQLMutation2, graphQLMutationName, isAuthenticated: true);
+
+            JsonElement response1 = await responeTask1;
+            JsonElement response2 = await responseTask2;
+
+            Assert.AreEqual("{\"title\":\"New Title\"}", response1.ToString());
+            Assert.AreEqual("{\"title\":\"Updated Title\"}", response2.ToString());
+        }
+
+        /// <summary>
+        /// Performs concurrent insert mutation on a table where the PK is auto-generated.
+        /// Since, PK is auto-generated, essentially both the mutations are operating on
+        /// different items. Therefore, both the mutations should succeed.
+        /// </summary>
+        [TestMethod]
+        public async Task TestParallelInsertMutationPKAutoGenerated()
+        {
+            string graphQLMutationName = "createbook";
+            string graphQLMutation1 = @"
+                mutation {
+                    createbook(item: { title: ""Awesome Book"", publisher_id: 1234 }) {
+                        title
+                    }
+                }
+            ";
+
+            string graphQLMutation2 = @"
+                mutation {
+                    createbook(item: { title: ""Another Awesome Book"", publisher_id: 1234 }) {
+                        title
+                    }
+                }
+            ";
+
+            Task<JsonElement> responeTask1 = ExecuteGraphQLRequestAsync(graphQLMutation1, graphQLMutationName, isAuthenticated: true);
+            Task<JsonElement> responseTask2 = ExecuteGraphQLRequestAsync(graphQLMutation2, graphQLMutationName, isAuthenticated: true);
+
+            JsonElement response1 = await responeTask1;
+            JsonElement response2 = await responseTask2;
+
+            Assert.AreEqual("{\"title\":\"Awesome Book\"}", response1.ToString());
+            Assert.AreEqual("{\"title\":\"Another Awesome Book\"}", response2.ToString());
+
+        }
+
+        /// <summary>
+        /// Performs concurrent insert mutation on a table where the PK is not auto-generated and
+        /// validates that only one of the mutations is successful.
+        /// Both the mutations attempt to create an item with the same primary key. The mutation request
+        /// that runs first at the database layer should succeed and the other request should fail with
+        /// primary key violation constraint.
+        /// </summary>
+        [TestMethod]
+        public async Task TestParallelInsertMutationPKNonAutoGenerated()
+        {
+            string graphQLMutationName = "createComic";
+
+            string graphQLMutation1 = @"
+                mutation {
+                    createComic (item: { id : 5001, categoryName: ""Fantasy"", title: ""Harry Potter""}){
+                    id
+                    title    
+                }
+                }
+            ";
+
+            string graphQLMutation2 = @"
+                mutation {
+                    createComic (item: { id : 5001, categoryName: ""Fantasy"", title: ""Lord of the Rings""}){
+                    id
+                    title    
+                }
+                }
+            ";
+
+            Task<JsonElement> responeTask1 = ExecuteGraphQLRequestAsync(graphQLMutation1, graphQLMutationName, isAuthenticated: true);
+            Task<JsonElement> responseTask2 = ExecuteGraphQLRequestAsync(graphQLMutation2, graphQLMutationName, isAuthenticated: true);
+
+            JsonElement response1 = await responeTask1;
+            JsonElement response2 = await responseTask2;
+
+            string responseString1 = response1.ToString();
+            string responseString2 = response2.ToString();
+            string expectedStatusCode = $"{DataApiBuilderException.SubStatusCodes.DatabaseOperationFailed}";
+
+            // It is not possible to know beforehand which mutation created the new item. So, validations
+            // are performed for the cases where either mutation could have succeeded. In each case,
+            // one of the mutation's reponse will contain a valid repsonse and the other mutation's
+            // response would contain DatabaseOperationFailed sub-status code as it would've failed at
+            // the database layer due to primary key violation constraint.
+            if (responseString1.Contains($"\"code\":\"{expectedStatusCode}\""))
+            {
+                Assert.AreEqual("{\"id\":5001,\"title\":\"Lord of the Rings\"}", responseString2);
+            }
+            else if (responseString2.Contains($"\"code\":\"{expectedStatusCode}\""))
+            {
+                Assert.AreEqual("{\"id\":5001,\"title\":\"Harry Potter\"}", responseString1);
+            }
+            else
+            {
+                Assert.Fail("Unexpected error. Atleast one of the mutations should've succeeded");
+            }
+        }
+
+        /// <summary>
+        /// Performs concurrent delete mutations on the same item and validates that only one of the
+        /// requests is successful.
+        /// </summary>
+        [TestMethod]
+        public async Task TestParallelDeleteMutations()
+        {
+            string graphQLMutationName = "deletebook";
+
+            string graphQLMutation1 = @"
+                mutation {
+                  deletebook (id: 1){
+                    id
+                    title
+                  }
+                }
+            ";
+
+            Task<JsonElement> responeTask1 = ExecuteGraphQLRequestAsync(graphQLMutation1, graphQLMutationName, isAuthenticated: true);
+            Task<JsonElement> responseTask2 = ExecuteGraphQLRequestAsync(graphQLMutation1, graphQLMutationName, isAuthenticated: true);
+
+            JsonElement response1 = await responeTask1;
+            JsonElement response2 = await responseTask2;
+
+            string responseString1 = response1.ToString();
+            string responseString2 = response2.ToString();
+            string expectedResponse = "{\"id\":1,\"title\":\"Awesome book\"}";
+
+            // The mutation request that deletes the item is expected to have a valid response
+            // and the other mutation is expected to receive an empty response as it
+            // won't see the item in the table.
+            if (responseString1.Length == 0)
+            {
+                Assert.AreEqual(expectedResponse, responseString2);
+            }
+            else if (responseString2.Length == 0)
+            {
+                Assert.AreEqual(expectedResponse, responseString1);
+            }
+            else
+            {
+                Assert.Fail("Unexpected failure. Atleast one of the delete mutations should've succeeded");
+            }
+
+        }
+
         #endregion
 
         #region Negative Tests

src/Service/Resolvers/MsSqlQueryBuilder.cs

@@ -105,12 +105,7 @@ public string Build(SqlExecuteStructure structure)
                 $"{BuildProcedureParameterList(structure.ProcedureParameters)}";
         }
 
-        /// <summary>
-        /// Avoid redundant check, wrap the sequence in a transaction,
-        /// and protect the first table access with appropriate locking.
-        /// </summary>
-        /// <param name="structure"></param>
-        /// <returns>Query generated for the PUT(upsert)/PATCH(upsertIncremental) operation.</returns>
+        /// <inheritdoc />
         public string Build(SqlUpsertQueryStructure structure)
         {
             string tableName = $"{QuoteIdentifier(structure.DatabaseObject.SchemaName)}.{QuoteIdentifier(structure.DatabaseObject.Name)}";
@@ -125,10 +120,8 @@ public string Build(SqlUpsertQueryStructure structure)
             string outputColumns = MakeOutputColumns(structure.OutputColumns, OutputQualifier.Inserted);
             string queryToGetCountOfRecordWithPK = $"SELECT COUNT(*) as {COUNT_ROWS_WITH_GIVEN_PK} FROM {tableName} WHERE {pkPredicates}";
 
-            // Query to initiate transaction and get number of records with given PK.
-            string prefixQuery = $"SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;" +
-                $"BEGIN TRANSACTION;" +
-                $"DECLARE @ROWS_TO_UPDATE int;" +
+            // Query to get the number of records with a given PK.
+            string prefixQuery = $"DECLARE @ROWS_TO_UPDATE int;" +
                 $"SET @ROWS_TO_UPDATE = ({queryToGetCountOfRecordWithPK}); " +
                 $"{queryToGetCountOfRecordWithPK};";
 
@@ -137,8 +130,8 @@ public string Build(SqlUpsertQueryStructure structure)
 
             // Query to update record (if there exists one for given PK).
             StringBuilder updateQuery = new(
-                $"IF @ROWS_TO_UPDATE = 1" +
-                $"UPDATE {tableName} WITH(UPDLOCK) " +
+                $"IF @ROWS_TO_UPDATE = 1 " +
+                $"UPDATE {tableName} " +
                 $"SET {updateOperations} " +
                 $"OUTPUT {outputColumns} " +
                 $"WHERE {updatePredicates};");
@@ -172,9 +165,6 @@ public string Build(SqlUpsertQueryStructure structure)
                 upsertQuery.Append(insertQuery.ToString());
             }
 
-            // Commit the transaction.
-            upsertQuery.Append("COMMIT TRANSACTION");
-
             return upsertQuery.ToString();
         }