DataTable FromQueryComposerQueryResult(DTO.QueryComposer.QueryComposerResponseQueryResultDTO queryResult)
{
var table = new DataTable();
foreach (var property in queryResult.Properties)
{
var column = new DataColumn();
column.ColumnName = property.As;
column.DataType = Nullable.GetUnderlyingType(property.AsType()) ?? property.AsType();
column.Caption = property.As;
table.Columns.Add(column);
}
foreach (var row in queryResult.Results.First())
{
var datarow = table.NewRow();
foreach (DataColumn column in table.Columns)
{
var obj = row[column.ColumnName];
datarow[column.ColumnName] = obj == null ? DBNull.Value : obj;
}
table.Rows.Add(datarow);
}
return(table);
}
protected override string[] LowThresholdColumns(DTO.QueryComposer.QueryComposerResponseQueryResultDTO response)
{
List <string> ltCols = new List <string>();
foreach (IEnumerable <Dictionary <string, object> > table in response.Results)
{
Dictionary <string, object> row = table.FirstOrDefault();
if (row != null && row.Count > 0)
{
try
{
foreach (string column in row.Keys)
{
if (SummaryQueryUtil.IsCheckedColumn(column))
{
ltCols.Add(column);
var depCols = SummaryQueryUtil.GetDependentComputedColumns(column, row);
if (depCols != null && depCols.Count > 0)
{
ltCols.AddRange(depCols);
}
}
}
}
catch { }
}
}
return(ltCols.ToArray());
}
public virtual void PostProcess(DTO.QueryComposer.QueryComposerResponseQueryResultDTO response)
{
string[] columnNames = LowThresholdColumns(response);
if (columnNames == null || columnNames.Length == 0)
{
return;
}
if (!response.Properties.Any(p => p.Name == LowThresholdColumnName))
{
//add a LowThreshold property to the definition
response.Properties = response.Properties.Concat(new[] { new DTO.QueryComposer.QueryComposerResponsePropertyDefinitionDTO {
Name = LowThresholdColumnName, As = LowThresholdColumnName, Type = "System.Boolean"
} });
}
foreach (IEnumerable <Dictionary <string, object> > result in response.Results)
{
var table = result;
foreach (Dictionary <string, object> row in table)
{
try
{
if (!row.ContainsKey(LowThresholdColumnName))
{
row.Add(LowThresholdColumnName, false);
}
foreach (string column in columnNames)
{
object currentValue;
if (row.TryGetValue(column, out currentValue))
{
double value;
if (currentValue != null && double.TryParse(currentValue.ToString(), out value))
{
if (value > 0 && value < _lowThresholdValue)
{
row[column] = 0;
row[LowThresholdColumnName] = true;
}
}
}
}
}
catch { }
}
}
}
public virtual bool CanPostProcess(DTO.QueryComposer.QueryComposerResponseQueryResultDTO response, out string message)
{
message = string.Empty;
bool hasErrors = response.Errors != null && response.Errors.Any();
//NOTE: Need to declare hasLowThreshold with a value because at this point in time response doesnt have the LowThreshold Column added to the response yet.
if (response.Results != null && !hasErrors && _lowThresholdValue.HasValue && response.Results.Any())
{
Func <KeyValuePair <string, object>, double?> parseDouble = (KeyValuePair <string, object> v) => {
if (v.Value == null)
{
return(null);
}
double result;
return(double.TryParse(v.Value.ToString(), out result) ? result : new Nullable <double>());
};
var xx = from result in response.Results
from row in result
from col in row
let val = parseDouble(col)
where col.Value != null && col.Value.GetType() != typeof(string) &&
val.HasValue &&
val.Value > 0 &&
val.Value < _lowThresholdValue
select col;
if (xx.Any())
{
//at least one cell has a value that falls below the low threshold value.
message = "The query results may have rows with low cell counts. You can choose to set the low cell count data to 0 by clicking the [Suppress Low Cell] button.";
}
}
return(_lowThresholdValue.HasValue);
}
public void Start(string requestId, bool viewSQL = false)
{
if (_request == null && !IsDistributedRegressionRequest)
{
throw new NullReferenceException("The deserialized request is null, please make sure that RequestDocument is called first and that the request document is not null.");
}
var queryResults = new List <DTO.QueryComposer.QueryComposerResponseQueryResultDTO>();
var queryCanPostProcess = new List <Tuple <Guid, bool, string> >();
_request.SyncHeaders();
foreach (var query in _request.Queries)
{
using (QueryComposer.IModelAdapter adapter = GetModelAdapter(query))
{
adapter.Initialize(Settings, requestId);
if (viewSQL && !adapter.CanViewSQL)
{
queryResults.Add(
new DTO.QueryComposer.QueryComposerResponseQueryResultDTO {
ID = query.Header.ID,
QueryStart = DateTimeOffset.UtcNow,
QueryEnd = DateTimeOffset.UtcNow,
Errors = new[] {
new DTO.QueryComposer.QueryComposerResponseErrorDTO {
QueryID = query.Header.ID,
Code = "-1",
Description = $"The adapter \"{ adapter.GetType().FullName }\" does not support providing the SQL of a query."
}
}
}
);
queryCanPostProcess.Add(new Tuple <Guid, bool, string>(query.Header.ID, false, string.Empty));
continue;
}
if (IsDistributedRegressionRequest)
{
var drAdapter = adapter as QueryComposer.Adapters.DistributedRegression.DistributedRegressionModelAdapter;
var queryResult = new DTO.QueryComposer.QueryComposerResponseQueryResultDTO {
ID = query.Header.ID, QueryStart = DateTimeOffset.UtcNow
};
try
{
DocumentEx[] outputDocuments = drAdapter.StartRequest(_drDocuments).ToArray();
if (outputDocuments != null && outputDocuments.Length > 0)
{
_responseDocuments.AddRange(outputDocuments);
}
}
catch (Exception ex)
{
queryResult.Errors = new[] {
new DTO.QueryComposer.QueryComposerResponseErrorDTO {
QueryID = query.Header.ID,
Code = "-1",
Description = QueryComposer.ExceptionHelpers.UnwindException(ex)
}
};
}
queryResult.QueryEnd = DateTimeOffset.UtcNow;
queryResults.Add(queryResult);
queryCanPostProcess.Add(new Tuple <Guid, bool, string>(query.Header.ID, false, string.Empty));
continue;
}
DateTimeOffset queryStart = DateTimeOffset.UtcNow;
try
{
foreach (var result in adapter.Execute(query, viewSQL))
{
queryResults.Add(result);
if (adapter.CanPostProcess(result, out string postProcessMessage))
{
queryCanPostProcess.Add(new Tuple <Guid, bool, string>(query.Header.ID, true, postProcessMessage));
}
else
{
queryCanPostProcess.Add(new Tuple <Guid, bool, string>(query.Header.ID, false, string.Empty));
}
}
}
catch (Exception ex)
{
queryResults.Add(
new DTO.QueryComposer.QueryComposerResponseQueryResultDTO {
ID = query.Header.ID,
QueryStart = queryStart,
QueryEnd = DateTimeOffset.UtcNow,
Errors = new[] {
new DTO.QueryComposer.QueryComposerResponseErrorDTO {
QueryID = query.Header.ID,
Code = "-1",
Description = QueryComposer.ExceptionHelpers.UnwindException(ex)
}
}
}
);
queryCanPostProcess.Add(new Tuple <Guid, bool, string>(query.Header.ID, false, string.Empty));
}
} //end of adapter using
} //end of processing each query
var response = new DTO.QueryComposer.QueryComposerResponseDTO {
Header = new DTO.QueryComposer.QueryComposerResponseHeaderDTO {
DocumentID = viewSQL ? SqlResponseDocumentID : QueryComposerModelProcessor.NewGuid(),
RequestID = _request.Header.ID
},
Queries = queryResults
};
response.RefreshQueryDates();
response.RefreshErrors();
string serializedResponse = Newtonsoft.Json.JsonConvert.SerializeObject(response, Newtonsoft.Json.Formatting.None);
byte[] resultContent = System.Text.Encoding.UTF8.GetBytes(serializedResponse);
Document resultDocument = new Document(response.Header.DocumentID.Value.ToString("D"), "application/json", "response.json");
resultDocument.Size = resultContent.Length;
resultDocument.IsViewable = true;
resultDocument.Kind = "MultiQuery.JSON";
if (viewSQL)
{
_SqlResponseDocument = new DocumentEx {
ID = SqlResponseDocumentID, Document = resultDocument, Content = resultContent
};
}
else
{
_SqlResponseDocument = null;
_responseDocuments.Clear();
_responseDocuments.Add(new DocumentEx {
ID = response.Header.DocumentID.Value, Document = resultDocument, Content = resultContent
});
_currentResponse = response;
}
status.PostProcess = queryCanPostProcess.Any(q => q.Item2 == true);
status.Message = queryCanPostProcess.Where(q => !string.IsNullOrEmpty(q.Item3)).Any() ? string.Join("\r\n", queryCanPostProcess.Where(q => !string.IsNullOrEmpty(q.Item3)).Select(q => q.Item3).ToArray()) : string.Empty;
status.Code = (response.Errors != null && response.Errors.Any()) ? RequestStatus.StatusCode.Error : (string.IsNullOrEmpty(status.Message) ? RequestStatus.StatusCode.Complete : RequestStatus.StatusCode.CompleteWithMessage);
}
protected virtual string[] LowThresholdColumns(DTO.QueryComposer.QueryComposerResponseQueryResultDTO response)
{
return(new string[0]);
}
