Making datasourcename mandatory during executequeryasync for multi-db scenario.

src/Core/Resolvers/IQueryExecutor.cs

@@ -24,15 +24,15 @@ public interface IQueryExecutor
         /// in the DbDataReader obtained after executing the query.</param>
         /// <param name="httpContext">Current request httpContext.</param>
         /// <param name="args">List of string arguments to the DbDataReader handler.</param>
-        /// <param name="dataSourceName">dataSourceName against which to run query.</param>
+        /// <param name="dataSourceName">dataSourceName against which to run query. Can specify null or empty to run against default db.</param>
         /// <returns>An object formed using the results of the query as returned by the given handler.</returns>
         public Task<TResult?> ExecuteQueryAsync<TResult>(
             string sqltext,
             IDictionary<string, DbConnectionParam> parameters,
             Func<DbDataReader, List<string>?, Task<TResult>>? dataReaderHandler,
+            string dataSourceName,
             HttpContext? httpContext = null,
-            List<string>? args = null,
-            string dataSourceName = "");
+            List<string>? args = null);
 
         /// <summary>
         /// Extracts the rows from the given DbDataReader to populate

src/Core/Resolvers/QueryExecutor.cs

@@ -65,9 +65,9 @@ public QueryExecutor(DbExceptionParser dbExceptionParser,
             string sqltext,
             IDictionary<string, DbConnectionParam> parameters,
             Func<DbDataReader, List<string>?, Task<TResult>>? dataReaderHandler,
+            string dataSourceName,
             HttpContext? httpContext = null,
-            List<string>? args = null,
-            string dataSourceName = "")
+            List<string>? args = null)
         {
             if (string.IsNullOrEmpty(dataSourceName))
             {

src/Core/Resolvers/SqlMutationEngine.cs

@@ -277,6 +277,7 @@ await queryExecutor.ExecuteQueryAsync(
                             queryText,
                             executeQueryStructure.Parameters,
                             queryExecutor.GetJsonArrayAsync,
+                            dataSourceName,
                             GetHttpContext());
 
                     transactionScope.Complete();
@@ -840,9 +841,9 @@ await queryExecutor.ExecuteQueryAsync(
                         queryString,
                         queryParameters,
                         queryExecutor.ExtractResultSetFromDbDataReader,
+                        dataSourceName,
                         GetHttpContext(),
-                        primaryKeyExposedColumnNames.Count > 0 ? primaryKeyExposedColumnNames : sourceDefinition.PrimaryKey,
-                        dataSourceName);
+                        primaryKeyExposedColumnNames.Count > 0 ? primaryKeyExposedColumnNames : sourceDefinition.PrimaryKey);
 
                 dbResultSetRow = dbResultSet is not null ?
                     (dbResultSet.Rows.FirstOrDefault() ?? new DbResultSetRow()) : null;
@@ -991,9 +992,9 @@ private async Task<DbResultSet?>
                        queryString,
                        queryParameters,
                        queryExecutor.GetMultipleResultSetsIfAnyAsync,
+                       dataSourceName,
                        GetHttpContext(),
-                       new List<string> { prettyPrintPk, entityName },
-                       dataSourceName);
+                       new List<string> { prettyPrintPk, entityName });
         }
 
         private Dictionary<string, object?> PrepareParameters(RestRequestContext context)

src/Core/Services/MetadataProviders/MsSqlMetadataProvider.cs

@@ -66,7 +66,8 @@ public override async Task PopulateTriggerMetadataForTable(string entityName, st
             JsonArray? resultArray = await QueryExecutor.ExecuteQueryAsync(
                 sqltext: enumerateEnabledTriggers,
                 parameters: parameters,
-                dataReaderHandler: QueryExecutor.GetJsonArrayAsync);
+                dataReaderHandler: QueryExecutor.GetJsonArrayAsync,
+                dataSourceName: _dataSourceName);
             using JsonDocument sqlResult = JsonDocument.Parse(resultArray!.ToJsonString());
 
             foreach (JsonElement element in sqlResult.RootElement.EnumerateArray())

src/Core/Services/MetadataProviders/SqlMetadataProvider.cs

@@ -1183,7 +1183,8 @@ private async Task PopulateColumnDefinitionsWithReadOnlyFlag(string tableName, s
             List<string>? readOnlyFields = await QueryExecutor.ExecuteQueryAsync(
                 sqltext: queryToGetReadOnlyColumns,
                 parameters: parameters,
-                dataReaderHandler: SummarizeReadOnlyFieldsMetadata);
+                dataReaderHandler: SummarizeReadOnlyFieldsMetadata,
+                dataSourceName: _dataSourceName);
 
             if (readOnlyFields is not null && readOnlyFields.Count > 0)
             {
@@ -1496,7 +1497,7 @@ private async Task PopulateForeignKeyDefinitionAsync()
             // Gather all the referencing and referenced columns for each pair
             // of referencing and referenced tables.
             PairToFkDefinition = await QueryExecutor.ExecuteQueryAsync(
-                queryForForeignKeyInfo, parameters, SummarizeFkMetadata, httpContext: null, args: null, _dataSourceName);
+                queryForForeignKeyInfo, parameters, SummarizeFkMetadata, _dataSourceName, httpContext: null, args: null);
 
             if (PairToFkDefinition is not null)
             {

src/Service.Tests/Caching/DabCacheServiceIntegrationTests.cs

@@ -74,7 +74,7 @@ public async Task FirstCacheServiceInvocationCallsFactory()
             IReadOnlyList<object> actualExecuteQueryAsyncArguments = mockQueryExecutor.Invocations[0].Arguments;
             Assert.AreEqual(expected: queryMetadata.QueryText, actual: actualExecuteQueryAsyncArguments[0], message: "QueryText " + ERROR_FAILED_ARG_PASSTHROUGH);
             Assert.AreEqual(expected: queryMetadata.QueryParameters, actual: actualExecuteQueryAsyncArguments[1], message: "Query parameters " + ERROR_FAILED_ARG_PASSTHROUGH);
-            Assert.AreEqual(expected: queryMetadata.DataSource, actual: actualExecuteQueryAsyncArguments[5], message: "Data source " + ERROR_FAILED_ARG_PASSTHROUGH);
+            Assert.AreEqual(expected: queryMetadata.DataSource, actual: actualExecuteQueryAsyncArguments[3], message: "Data source " + ERROR_FAILED_ARG_PASSTHROUGH);
         }
 
         /// <summary>
@@ -217,7 +217,7 @@ public async Task CacheServiceFactoryInvocationReturnsNull()
             IReadOnlyList<object> actualExecuteQueryAsyncArguments = mockQueryExecutor.Invocations[0].Arguments;
             Assert.AreEqual(expected: queryMetadata.QueryText, actual: actualExecuteQueryAsyncArguments[0], message: "QueryText " + ERROR_FAILED_ARG_PASSTHROUGH);
             Assert.AreEqual(expected: queryMetadata.QueryParameters, actual: actualExecuteQueryAsyncArguments[1], message: "Query parameters " + ERROR_FAILED_ARG_PASSTHROUGH);
-            Assert.AreEqual(expected: queryMetadata.DataSource, actual: actualExecuteQueryAsyncArguments[5], message: "Data source " + ERROR_FAILED_ARG_PASSTHROUGH);
+            Assert.AreEqual(expected: queryMetadata.DataSource, actual: actualExecuteQueryAsyncArguments[3], message: "Data source " + ERROR_FAILED_ARG_PASSTHROUGH);
 
             // Validate that the null value retrned by the factory method is propogated through to and returned by the cache service.
             Assert.AreEqual(expected: null, actual: result, message: "Expected factory to return a null result.");
@@ -422,19 +422,19 @@ private static Mock<IQueryExecutor> CreateMockQueryExecutor(string rawJsonRespon
                         It.IsAny<string>(),
                         It.IsAny<IDictionary<string, DbConnectionParam>>(),
                         It.IsAny<Func<DbDataReader?, List<string>?, Task<JsonElement?>>>(),
+                        It.IsAny<string>(),
                         httpContext,
-                        args,
-                        It.IsAny<string>()).Result)
+                        args).Result)
                         .Returns((JsonElement?)null);
                     break;
                 case ExecutorReturnType.Exception:
                     mockQueryExecutor.Setup(x => x.ExecuteQueryAsync(
                         It.IsAny<string>(),
                         It.IsAny<IDictionary<string, DbConnectionParam>>(),
                         It.IsAny<Func<DbDataReader?, List<string>?, Task<JsonElement?>>>(),
+                        It.IsAny<string>(),
                         httpContext,
-                        args,
-                        It.IsAny<string>()).Result)
+                        args).Result)
                         .Throws(new DataApiBuilderException(
                             message: "DB ERROR",
                             statusCode: HttpStatusCode.InternalServerError,
@@ -446,9 +446,9 @@ private static Mock<IQueryExecutor> CreateMockQueryExecutor(string rawJsonRespon
                         It.IsAny<string>(),
                         It.IsAny<IDictionary<string, DbConnectionParam>>(),
                         It.IsAny<Func<DbDataReader?, List<string>?, Task<JsonElement?>>>(),
+                        It.IsAny<string>(),
                         httpContext,
-                        args,
-                        It.IsAny<string>()).Result)
+                        args).Result)
                         .Returns(executorJsonResponse.RootElement.Clone());
                     break;
             }

src/Service.Tests/SqlTests/RestBootstrapTests/PrimaryKeyTestsForCompositeViews.cs

@@ -133,7 +133,7 @@ await SetupAndRunRestApiTest(
         public async Task TestCleanup()
         {
             string dropViewQuery = $"DROP VIEW IF EXISTS {_compositeViewName}";
-            await _queryExecutor.ExecuteQueryAsync<object>(dropViewQuery, parameters: null, dataReaderHandler: null);
+            await _queryExecutor.ExecuteQueryAsync<object>(dropViewQuery, parameters: null, dataReaderHandler: null, dataSourceName: string.Empty);
         }
     }
 }

src/Service.Tests/SqlTests/SqlTestBase.cs

@@ -238,7 +238,7 @@ private static async Task ExecuteQueriesOnDbAsync(List<string> customQueries)
             {
                 foreach (string query in customQueries)
                 {
-                    await _queryExecutor.ExecuteQueryAsync<object>(query, parameters: null, dataReaderHandler: null);
+                    await _queryExecutor.ExecuteQueryAsync<object>(query, dataSourceName: string.Empty, parameters: null, dataReaderHandler: null);
                 }
             }
         }
@@ -367,6 +367,7 @@ protected static async Task ResetDbStateAsync()
         {
             await _queryExecutor.ExecuteQueryAsync<object>(
                 File.ReadAllText($"DatabaseSchema-{DatabaseEngine}.sql"),
+                dataSourceName: string.Empty,
                 parameters: null,
                 dataReaderHandler: null);
         }
@@ -388,7 +389,8 @@ protected static async Task<string> GetDatabaseResultAsync(
                     await _queryExecutor.ExecuteQueryAsync(
                         queryText,
                         parameters: null,
-                        _queryExecutor.GetJsonResultAsync<JsonDocument>);
+                        _queryExecutor.GetJsonResultAsync<JsonDocument>,
+                        string.Empty);
 
                 result = sqlResult is not null ?
                     sqlResult.RootElement.ToString() :
@@ -400,7 +402,8 @@ await _queryExecutor.ExecuteQueryAsync(
                     await _queryExecutor.ExecuteQueryAsync(
                         queryText,
                         parameters: null,
-                        _queryExecutor.GetJsonArrayAsync);
+                        _queryExecutor.GetJsonArrayAsync,
+                        string.Empty);
                 using JsonDocument sqlResult = resultArray is not null ? JsonDocument.Parse(resultArray.ToJsonString()) : null;
                 result = sqlResult is not null ? sqlResult.RootElement.ToString() : null;
             }

src/Service.Tests/Unittests/SqlQueryExecutorUnitTests.cs

@@ -184,16 +184,17 @@ Mock<MsSqlQueryExecutor> queryExecutor
                 It.IsAny<string>(),
                 It.IsAny<IDictionary<string, DbConnectionParam>>(),
                 It.IsAny<Func<DbDataReader, List<string>, Task<object>>>(),
+                It.IsAny<string>(),
                 It.IsAny<HttpContext>(),
-                It.IsAny<List<string>>(),
-                It.IsAny<string>())).CallBase();
+                It.IsAny<List<string>>())).CallBase();
 
             DataApiBuilderException ex = await Assert.ThrowsExceptionAsync<DataApiBuilderException>(async () =>
             {
                 await queryExecutor.Object.ExecuteQueryAsync<object>(
                     sqltext: string.Empty,
                     parameters: new Dictionary<string, DbConnectionParam>(),
                     dataReaderHandler: null,
+                    dataSourceName: String.Empty,
                     httpContext: null,
                     args: null);
             });
@@ -242,14 +243,15 @@ Mock<MsSqlQueryExecutor> queryExecutor
                 It.IsAny<string>(),
                 It.IsAny<IDictionary<string, DbConnectionParam>>(),
                 It.IsAny<Func<DbDataReader, List<string>, Task<object>>>(),
+                It.IsAny<string>(),
                 It.IsAny<HttpContext>(),
-                It.IsAny<List<string>>(),
-                It.IsAny<string>())).CallBase();
+                It.IsAny<List<string>>())).CallBase();
 
             string sqltext = "SELECT * from books";
 
             await queryExecutor.Object.ExecuteQueryAsync<object>(
                     sqltext: sqltext,
+                    dataSourceName: String.Empty,
                     parameters: new Dictionary<string, DbConnectionParam>(),
                     dataReaderHandler: null,
                     args: null);