public async Task ExecuteAsync(IQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
await queryExecutor.ExecuteQueryAsync(query, async command =>
{
await command.ExecuteNonQueryAsync();
return(0);
});
}
/// <summary>
/// Internal implementation of the search API logic.
/// Mainly used to improve testability (as certain parameters needs to be extracted from the body).
/// </summary>
/// <param name="header">The header of the query request that includes the index to be queried.</param>
/// <param name="query">The actual query that will be executed.</param>
/// <param name="requestContext">An object that represents properties of the entire request process.</param>
/// <param name="isSingleDocument">True if this is part of a flow which requires a single response.</param>
/// <returns>An ElasticResponse object.</returns>
internal async Task <IActionResult> SearchInternalAsync(
string header,
string query,
RequestContext requestContext,
bool isSingleDocument = false)
{
var sw = new Stopwatch();
sw.Start();
Ensure.IsNotNullOrEmpty(header, nameof(header), "Invalid request body. header is null or empty.", logger);
Ensure.IsNotNullOrEmpty(query, nameof(query), "Invalid request body. query is null or empty.", logger);
CheckEncodingHeader();
// Translate Query
var(translationResult, translationError) = TryFuncReturnsElasticError(
() => translator.TranslateQuery(header, query),
UnknownIndexName); // At this point we don't know the index name.
if (translationError != null)
{
return(Ok(translationError));
}
logger.LogDebug("Translated query:\n{@QueryCommandText}", translationResult.QueryCommandText.ToSensitiveData());
// Execute Query
var((timeTaken, dataReader), queryError) = await TryAsyncFuncReturnsElasticError(
async() => await queryExecutor.ExecuteQueryAsync(translationResult, requestContext),
translationResult.IndexName);
if (queryError != null)
{
return(Ok(queryError));
}
// Parse Response
var(parsingResult, parsingError) = TryFuncReturnsElasticError(
() =>
{
var elasticResponse = responseParser.Parse(dataReader, translationResult, timeTaken);
return(isSingleDocument ? (object)elasticResponse.Responses.First() : elasticResponse);
},
translationResult.IndexName);
if (parsingError != null)
{
return(Ok(parsingError));
}
sw.Stop();
logger.LogDebug($"[metric] search request duration: {sw.Elapsed}");
return(Ok(parsingResult));
}
public async Task <T> ExecuteQueryAsync <T>(IQuery query, Func <NpgsqlCommand, Task <T> > functionAsync)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
if (functionAsync == null)
{
throw new ArgumentNullException(nameof(functionAsync));
}
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await queryExecutor.ExecuteQueryAsync(query, functionAsync);
stopwatch.Stop();
await OnQueryCompletionAsync(query, stopwatch.Elapsed);
return(result);
}
/// <summary>
/// Internal implementation of the search API logic.
/// Mainly used to improve testability (as certain parameters needs to be extracted from the body).
/// </summary>
/// <param name="totalHits">totalHits parameter coming from Kibana (currently not used).</param>
/// <param name="ignoreThrottled">ignoreThrottled parameter coming from Kibana (currently not used).</param>
/// <param name="rawQueryData">Body Payload.</param>
/// <param name="requestContext">An object that represents properties of the entire request process.</param>
/// <returns>An ElasticResponse object.</returns>
internal async Task <IActionResult> SearchInternalAsync(
bool totalHits,
bool ignoreThrottled,
string rawQueryData,
RequestContext requestContext)
{
var sw = new Stopwatch();
sw.Start();
Ensure.IsNotNull(rawQueryData, nameof(rawQueryData), "Invalid request body. rawQueryData is null.", logger);
// Extract Query
(string header, string query) = ControllerExtractMethods.SplitQueryBody(rawQueryData);
Ensure.IsNotNullOrEmpty(header, nameof(header), "Invalid request body. header is null or empty.", logger);
Ensure.IsNotNullOrEmpty(query, nameof(query), "Invalid request body. query is null or empty.", logger);
// Translate Query
(QueryData translatedQuery, bool error, ElasticErrorResponse errorResponse)translateResponse = TryFuncReturnsElasticError(
() =>
{
return(translator.Translate(header, query));
},
UnknownIndexName); // At this point we don't know the index name.
if (translateResponse.error)
{
return(Ok(translateResponse.errorResponse));
}
logger.LogDebug("Translated query:\n{@QueryCommandText}", translateResponse.translatedQuery.QueryCommandText.ToSensitiveData());
// Execute Query
((TimeSpan timeTaken, IDataReader dataReader)response, bool error, ElasticErrorResponse errorResponse)queryResponse = await TryAsyncFuncReturnsElasticError(
async() =>
{
return(await queryExecutor.ExecuteQueryAsync(translateResponse.translatedQuery, requestContext));
},
translateResponse.translatedQuery.IndexName);
if (queryResponse.error)
{
return(Ok(queryResponse.errorResponse));
}
// Parse Response
(ElasticResponse elasticResponse, bool error, ElasticErrorResponse errorResponse)parseResponse = TryFuncReturnsElasticError(
() =>
{
return(responseParser.Parse(queryResponse.response.dataReader, translateResponse.translatedQuery, queryResponse.response.timeTaken));
},
translateResponse.translatedQuery.IndexName);
if (parseResponse.error)
{
return(Ok(parseResponse.errorResponse));
}
sw.Stop();
logger.LogDebug($"[metric] search request duration: {sw.Elapsed}");
return(Ok(parseResponse.elasticResponse));
}
