/// <summary>
/// The execute query simple.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="version">The version.</param>
/// <param name="progress">The progress.</param>
/// <param name="groups">The groups.</param>
/// <returns>
/// The <see cref="QueryInstanceResultInfo" />.
/// </returns>
public QueryInstanceResultInfo ExecuteQuerySimple(
QueryInfo query,
QueryExecutionParams parameters,
InstanceVersion version,
ProgressItem progress,
params GroupDefinition[] groups
)
{
// Log.InfoFormat("73:query:'{0}'",
// query
// );
QueryInstanceResultInfo result = new QueryInstanceResultInfo(this.Instance);
QueryItemInfo queryItem = query.Items.GetQueryItemForVersion(version);
this.PrepareProgress(progress, groups);
this.ExecuteQuery(
query,
parameters,
progress,
groups,
result,
queryItem
);
return(result);
}
/// <summary>
/// The process group.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="result">The result.</param>
/// <param name="queryItem">The query item.</param>
/// <param name="group">The group.</param>
/// <param name="subProgress">The sub progress.</param>
protected virtual void ExecuteQuery(
QueryInfo query,
QueryExecutionParams parameters,
QueryInstanceResultInfo result,
QueryItemInfo queryItem,
GroupDefinition group,
ProgressItem subProgress
)
{
// Log.InfoFormat("146:query:'{0}'",
// query
// );
var qr = this.ExecuteQueryItemFunction.Invoke(
this.Instance,
queryItem,
string.IsNullOrWhiteSpace(group.Name) ? parameters.DefaultDatabase : group.Name,
//group.Name,
group.Id,
query.Parameters,
parameters.Values.ToList(),
subProgress
);
// костыль. Наверное, прибъется вообще после убиения "групп"
qr.Database = group.Name;
result.AddDatabaseResult(qr);
}
/// <summary>
/// The execute query simple.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="version">The version.</param>
/// <param name="progress">The progress.</param>
/// <param name="groups">The groups.</param>
/// <returns>
/// The <see cref="QueryInstanceResultInfo" />.
/// </returns>
public QueryInstanceResultInfo ExecuteQuerySimple(
QueryInfo query,
QueryExecutionParams parameters,
InstanceVersion version,
ProgressItem progress,
params GroupDefinition[] groups
)
{
// Log.InfoFormat("73:query:'{0}'",
// query
// );
QueryInstanceResultInfo result = new QueryInstanceResultInfo(this.Instance);
QueryItemInfo queryItem = query.Items.GetQueryItemForVersion(version);
this.PrepareProgress(progress, groups);
this.ExecuteQuery(
query,
parameters,
progress,
groups,
result,
queryItem
);
return result;
}
/// <inheritdoc />
protected override void ExecuteQuery(
QueryInfo query,
QueryExecutionParams parameters,
QueryInstanceResultInfo result,
QueryItemInfo queryItem,
GroupDefinition group,
ProgressItem subProgress
)
{
var tempValues = new List <ParameterValue>(parameters.Values);
foreach (var parameter in group.GroupParameters)
{
tempValues.Add(new ParameterValue
{
Name = "@" + parameter.Key,
StringValue = parameter.Value
}
);
}
QueryDatabaseResultInfo databaseResult = this.ExecuteQueryItemFunction.Invoke(
this.Instance,
queryItem,
null,
null,
query.Parameters,
tempValues,
subProgress
);
databaseResult.Database = group.Name;
databaseResult.DatabaseId = group.Id;
result.AddDatabaseResult(databaseResult);
}
/// <inheritdoc />
protected override void ExecuteQuery(
QueryInfo query,
QueryExecutionParams parameters,
QueryInstanceResultInfo result,
QueryItemInfo queryItem,
GroupDefinition group,
ProgressItem subProgress
)
{
var tempValues = new List<ParameterValue>(parameters.Values);
foreach (var parameter in group.GroupParameters)
{
tempValues.Add(new ParameterValue
{
Name = "@" + parameter.Key,
StringValue = parameter.Value
}
);
}
QueryDatabaseResultInfo databaseResult = this.ExecuteQueryItemFunction.Invoke(
this.Instance,
queryItem,
null,
null,
query.Parameters,
tempValues,
subProgress
);
databaseResult.Database = group.Name;
databaseResult.DatabaseId = group.Id;
result.AddDatabaseResult(databaseResult);
}
/// <summary>
/// The execute query.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="progress">The progress.</param>
/// <param name="groups">The groups.</param>
/// <param name="result">The result.</param>
/// <param name="queryItem">The query item.</param>
private void ExecuteQuery(
QueryInfo query,
QueryExecutionParams parameters,
ProgressItem progress,
GroupDefinition[] groups,
QueryInstanceResultInfo result,
QueryItemInfo queryItem
)
{
// Log.InfoFormat("query:'{0}'",
// query
// );
Debug.Assert(groups.Length <= 1);
if (groups.Length == 0)
{
this.ExecuteQuery(
query,
parameters,
result,
queryItem,
new GroupDefinition(
this.Instance,
string.Empty,
string.Empty
),
progress
);
ProgressComplete(progress);
}
else
{
foreach (var group in groups)
{
if (group.ChildGroups.Count > 0)
{
var tempParams = parameters.Clone();
tempParams.AddValues(
this.GetGroupsResolver().GetParametersFromDefinition(group)
);
this.ExecuteQuery(
query,
tempParams,
progress,
group.ChildGroups.ToArray(),
result,
queryItem
);
}
ProgressItem subProgress = null;
if (progress != null)
{
try
{
subProgress = progress.GetChild();
}
catch (Exception)
{
}
}
this.ExecuteQuery(
query,
parameters,
result,
queryItem,
@group,
subProgress
);
ProgressComplete(subProgress);
}
}
}
private TemplateNodeResultItem ReadTemplateNodeResult(TemplateNodeQueryInfo templateNodeQueryInfo, MultyQueryResultInfo result)
{
var queryResult = new QueryResultInfo();
List <QueryInfo> queries = MsSqlAuditor.GetQueryByTemplateNodeQueryInfo(templateNodeQueryInfo);
// looking for user settings for parameter values
templateNodeQueryInfo.ReadParametersFrom(Settings);
string connectionsSelectId = templateNodeQueryInfo.ConnectionsSelectId;
if (connectionsSelectId != null)
{
foreach (InstanceInfo instance in this._instances)
{
Int64?queryId = Storage.QueryDirectory.GetQueryId(
templateNodeQueryInfo.TemplateNode,
templateNodeQueryInfo,
instance,
DateTime.Now,
false
);
if (queryId.HasValue)
{
List <DynamicConnection> connections = new List <DynamicConnection>(
Storage.DynamicConnectionDirectory.ReadConnections(queryId.Value)
);
foreach (DynamicConnection connection in connections)
{
if (!connection.QueryId.HasValue)
{
continue;
}
Int64 dynamicQueryId = connection.QueryId.Value;
QuerySource sourceType;
if (!Enum.TryParse(connection.Type, true, out sourceType))
{
_log.ErrorFormat(
@"Unknown ConnectionType:'{0}'",
connection.Type ?? "<Null>"
);
sourceType = QuerySource.MSSQL;
}
InstanceInfo selectConnectionInstance = InstanceInfoResolver.ResolveDynamicInstance(
connection.Name,
sourceType,
connection.IsOdbc
);
selectConnectionInstance.ConnectionGroup = instance.ConnectionGroup;
selectConnectionInstance.LoadServerProperties(Storage);
QueryInstanceResultInfo instanceResult = GetInstanceResult(
result,
selectConnectionInstance,
dynamicQueryId,
templateNodeQueryInfo,
queries
);
if (instanceResult != null)
{
queryResult.AddInstanceResult(instanceResult);
}
}
}
}
}
else
{
foreach (InstanceInfo instance in this._instances)
{
Int64?queryId = Storage.QueryDirectory.GetQueryId(
base.TemplateNode,
templateNodeQueryInfo,
instance,
new DateTime(),
true
);
if (queryId != null)
{
QueryInstanceResultInfo instanceResult = GetInstanceResult(
result,
instance,
queryId.Value,
templateNodeQueryInfo,
queries
);
if (instanceResult != null)
{
queryResult.AddInstanceResult(instanceResult);
}
}
}
}
Tuple <DateTime?, DateTime?> dateTimes =
Storage.NodeInstances.GetTreeNodeLastUpdateAndDuration(base.TemplateNode);
result.NodeLastUpdated = dateTimes.Item1;
result.NodeLastUpdateDuration = dateTimes.Item2;
return(new TemplateNodeResultItem(templateNodeQueryInfo, queryResult));
}
private QueryInstanceResultInfo GetInstanceResult(
MultyQueryResultInfo result,
InstanceInfo instance,
Int64 queryId,
TemplateNodeQueryInfo templateNodeQueryInfo,
List <QueryInfo> queries
)
{
QueryInstanceResultInfo instanceResult = null;
Int64 recordSetCount = 0L;
ITableRow meta = Storage.ReadLastMeta(queryId);
if (meta != null)
{
DateTime timestamp = (DateTime)meta.Values[TableDefinition.DateCreated];
result.RefreshTimestamp(timestamp);
if (!string.IsNullOrEmpty(meta.Values[MetaResultTable.ErrorMessageFieldName].ToString()))
{
instanceResult = new QueryInstanceResultInfo(
new ErrorInfo(
meta.Values[MetaResultTable.ErrorIdFieldName].ToString(),
meta.Values[MetaResultTable.ErrorCodeFieldName].ToString(),
meta.Values[MetaResultTable.ErrorMessageFieldName].ToString(),
(DateTime)meta.Values[TableDefinition.DateCreated]
),
instance
);
}
else
{
instanceResult = new QueryInstanceResultInfo(instance);
}
recordSetCount = (Int64)meta.Values[MetaResultTable.RecordSetCountFieldName];
DataTable[] dataTables = GetDataTables(
recordSetCount,
queryId,
instance,
templateNodeQueryInfo
);
QueryInfo query = queries.FirstOrDefault(x => x.Source == instance.Type || x.Source == QuerySource.SQLite);
if (query != null)
{
QueryDatabaseResultInfo databaseResult = new QueryDatabaseResultInfo(
dataTables,
query.Items.GetQueryItemForVersion(instance.GetServerPropertiesSafe().Version),
base.GroupDefinition.Name,
base.GroupDefinition.Id
);
instanceResult.AddDatabaseResult(databaseResult);
}
}
return(instanceResult);
}
public XmlDocument Transform(QueryResultDataSource dataSource)
{
GroupDefinition database = dataSource.NodeDefinition.Group;
MultyQueryResultInfo queriesResult = dataSource.QueriesResult;
MsSqlAuditorModel model = dataSource.Model;
if (queriesResult == null)
{
return(null);
}
try
{
DateTime timestamp = queriesResult.Timestamp;
XmlDocument xml = new XmlDocument();
xml.AppendChild(xml.CreateXmlDeclaration("1.0", "UTF-8", String.Empty));
XmlElement rootNode = xml.CreateElement(Consts.ResultsTag);
rootNode.SetAttribute(TimestampAttributeName, timestamp.ToInternetString());
xml.AppendChild(rootNode);
foreach (TemplateNodeResultItem tuple in queriesResult.List)
{
TemplateNodeQueryInfo templateNodeQueryInfo = tuple.TemplateNodeQuery;
QueryResultInfo queryResult = tuple.QueryResult;
foreach (
KeyValuePair <InstanceInfo, QueryInstanceResultInfo> instancePair in queryResult.InstancesResult)
{
InstanceInfo instance = instancePair.Key;
QueryInstanceResultInfo queryInstanceResult = instancePair.Value;
if (queryInstanceResult.ErrorInfo == null)
{
try
{
QueryDatabaseResultInfo databaseResult = queryInstanceResult.DatabasesResult[database.Name];
int rowCount = 0;
if (databaseResult != null)
{
rowCount = databaseResult.DataTables != null
? databaseResult.DataTables.Where(x => x != null).Select(x => x.Rows).Sum(x => x.Count)
: 0;
}
GenerateResultDefinition(
rootNode,
templateNodeQueryInfo,
databaseResult.ErrorInfo,
instance,
rowCount,
(databaseResult.DataTables != null ? databaseResult.DataTables.Length : 0)
);
}
catch (Exception ex)
{
log.Error("Error in 'Extracts data from queries and saves it to Xml-files'", ex);
}
}
else
{
GenerateResultDefinition(
rootNode,
templateNodeQueryInfo,
queryInstanceResult.ErrorInfo,
instance,
0,
0
);
}
}
}
foreach (TemplateNodeResultItem tuple in queriesResult.List)
{
TemplateNodeQueryInfo templateNodeQueryInfo = tuple.TemplateNodeQuery;
if (templateNodeQueryInfo.GetType() != typeof(TemplateNodeSqlGuardQueryInfo))
{
model.GetQueryByTemplateNodeQueryInfo(templateNodeQueryInfo);
}
QueryResultInfo queryResult = tuple.QueryResult;
foreach (
KeyValuePair <InstanceInfo, QueryInstanceResultInfo> instancePair in queryResult.InstancesResult)
{
InstanceInfo instance = instancePair.Key;
QueryInstanceResultInfo queryInstanceResult = instancePair.Value;
if (queryInstanceResult.ErrorInfo == null)
{
foreach (KeyValuePair <string, QueryDatabaseResultInfo> namedResult in queryInstanceResult.DatabasesResult)
{
if (namedResult.Key == database.Name)
{
XmlNode parent = rootNode.ChildNodes.OfType <XmlNode>().FirstOrDefault(
x =>
(
x.Attributes["instance"] != null &&
x.Attributes["instance"].Value == instance.Name
)
&&
(
x.Attributes["name"] != null &&
x.Attributes["name"].Value == templateNodeQueryInfo.QueryName
)
&&
(
x.Attributes["hierarchy"] != null &&
x.Attributes["hierarchy"].Value == (templateNodeQueryInfo.ResultHierarchy ?? string.Empty)
)
);
QueryDatabaseResultInfo databaseResult = namedResult.Value;
if (databaseResult.DataTables != null)
{
Int64 recordSet = 1L;
foreach (DataTable curTable in databaseResult.DataTables)
{
if (parent != null)
{
parent.InnerXml = parent.InnerXml +
ProcessDataTableAsStringXml(curTable, recordSet);
}
recordSet++;
}
}
if (databaseResult.QueryItem.ParentQuery.Scope == QueryScope.Database)
{
if (!string.IsNullOrEmpty(databaseResult.Database))
{
XmlAttribute attr = xml.CreateAttribute("database");
attr.Value = databaseResult.Database;
parent.Attributes.Append(attr);
}
if (!string.IsNullOrEmpty(databaseResult.DatabaseId))
{
XmlAttribute attr = xml.CreateAttribute("databaseId");
attr.Value = databaseResult.DatabaseId;
parent.Attributes.Append(attr);
}
}
else if (databaseResult.QueryItem.ParentQuery.Scope == QueryScope.InstanceGroup)
{
if (!string.IsNullOrEmpty(databaseResult.Database))
{
XmlAttribute attr = xml.CreateAttribute("InstanceGroupName");
attr.Value = databaseResult.Database;
parent.Attributes.Append(attr);
}
}
}
}
}
}
}
return(xml);
}
catch (Exception ex)
{
log.Error("Error in 'Extracts data from queries and saves it to Xml-files'", ex);
}
return(null);
}
public ITableRow GetMetaRow(
long requestId,
long sessionId,
DateTime timestamp,
QueryInstanceResultInfo queryInstanceResult,
long?queryId,
long?rowsSaved
)
{
string errorNumber = null;
string errorCode = null;
string errorMessage = null;
Int64 recordSetCount = 0L;
ITableRow row = this.NewRow();
row.Values.Add(QueryDirectory.TableName.AsFk(), queryId);
row.Values.Add(QueryGroupDirectory.TableName.AsFk(), null);
row.Values.Add(RequestIdFieldName, requestId);
row.Values.Add(SessionIdFieldName, sessionId);
row.Values.Add(TableDefinition.DateCreated, timestamp);
if (queryInstanceResult != null)
{
if (queryInstanceResult.ErrorInfo == null)
{
if (queryInstanceResult.DatabasesResult.ContainsKey("")) //group.Name))
{
QueryDatabaseResultInfo databaseResult = queryInstanceResult.DatabasesResult[""]; //group.Name];
if (rowsSaved == null)
{
rowsSaved = databaseResult.DataTables != null
? databaseResult.DataTables.Select(x => x.Rows).Sum(x => x.Count)
: 0L;
}
recordSetCount = (databaseResult.DataTables == null)
? 0L
: databaseResult.DataTables.Length;
if (databaseResult.ErrorInfo != null)
{
errorNumber = databaseResult.ErrorInfo.Number;
errorCode = databaseResult.ErrorInfo.Code;
errorMessage = databaseResult.ErrorInfo.Message;
}
}
}
else
{
errorNumber = queryInstanceResult.ErrorInfo.Number;
errorCode = queryInstanceResult.ErrorInfo.Code;
errorMessage = queryInstanceResult.ErrorInfo.Message;
rowsSaved = 0L;
}
}
row.Values.Add(RowCountFieldName, rowsSaved);
row.Values.Add(RecordSetCountFieldName, recordSetCount);
row.Values.Add(ErrorIdFieldName, errorNumber);
row.Values.Add(ErrorCodeFieldName, errorCode);
row.Values.Add(ErrorMessageFieldName, errorMessage);
return(row);
}
private void ProcessCodeGuardQuery(
MultyQueryResultInfo result,
TemplateNodeSqlGuardQueryInfo guardQueryInfo)
{
var queryResultInfo = result.List.First(item => item.TemplateNodeQuery.Id == guardQueryInfo.SqlQueryId);
var templateNodeQueryInfo = queryResultInfo.TemplateNodeQuery;
var userParams = new List <ParameterValue>();
if (base.Settings != null)
{
var querySettings = base.Settings.Connection.Activity.Parameters
.Where(i => i.Key == guardQueryInfo.IdsHierarchy && i.Value != null);
foreach (var info in querySettings)
{
switch (info.Type)
{
case ParameterInfoType.Attribute:
guardQueryInfo.GetType().GetProperty("User" + info.Parameter)
.SetValue(guardQueryInfo, info.Value, null);
break;
case ParameterInfoType.Parameter:
var parameter =
templateNodeQueryInfo.ParameterValues.FirstOrDefault(p => p.Name == info.Parameter);
if (parameter != null)
{
parameter.UserValue = info.Value;
}
break;
case ParameterInfoType.EditableParameter:
var editparameter = new ParameterValue
{
Name = info.Parameter,
StringValue = info.Default,
UserValue = info.Value
};
userParams.Add(editparameter);
break;
}
}
}
var guardQueryResult = new QueryResultInfo();
foreach (var instanceResult in queryResultInfo.QueryResult.InstancesResult)
{
var instance = instanceResult.Key;
var queryTable = instanceResult.Value.DatabasesResult.First().Value.DataTables.First();
if (!queryTable.Columns.Contains(guardQueryInfo.QueryCodeColumn))
{
continue;
}
//var meta = ReadMeta(connectionGroup, templateNode, instance, database, templateNodeQueryInfo).FirstOrDefault();
var meta = Storage.ReadLastMeta(
base.TemplateNode,
instance,
templateNodeQueryInfo
);
if (meta == null)
{
continue;
}
QueryInstanceResultInfo guardInstanceResult;
var timestamp = (DateTime)meta.Values[TableDefinition.DateCreated];
result.RefreshTimestamp(timestamp);
if (!string.IsNullOrEmpty(meta.Values[MetaResultTable.ErrorMessageFieldName].ToString()))
{
guardInstanceResult = new QueryInstanceResultInfo(
new ErrorInfo(
meta.Values[MetaResultTable.ErrorIdFieldName].ToString(),
meta.Values[MetaResultTable.ErrorCodeFieldName].ToString(),
meta.Values[MetaResultTable.ErrorMessageFieldName].ToString(),
timestamp
),
instance
);
}
else
{
guardInstanceResult = new QueryInstanceResultInfo(instance);
}
var dataTables = Storage.ReadSqlCodeGuardResult(guardQueryInfo, queryTable, userParams);
QueryItemInfo queryItemInfo = new QueryItemInfo
{
ParentQuery = new QueryInfo {
Name = guardQueryInfo.QueryName
}
};
QueryDatabaseResultInfo databaseResult = new QueryDatabaseResultInfo(
dataTables,
queryItemInfo,
base.GroupDefinition.Name,
base.GroupDefinition.Id
);
guardInstanceResult.AddDatabaseResult(databaseResult);
guardQueryResult.AddInstanceResult(guardInstanceResult);
}
var templateNodeResultItem = new TemplateNodeResultItem(guardQueryInfo, guardQueryResult);
result.Add(templateNodeResultItem);
}
/// <summary>
/// The execute query.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="progress">The progress.</param>
/// <param name="groups">The groups.</param>
/// <param name="result">The result.</param>
/// <param name="queryItem">The query item.</param>
private void ExecuteQuery(
QueryInfo query,
QueryExecutionParams parameters,
ProgressItem progress,
GroupDefinition[] groups,
QueryInstanceResultInfo result,
QueryItemInfo queryItem
)
{
// Log.InfoFormat("query:'{0}'",
// query
// );
Debug.Assert(groups.Length <= 1);
if (groups.Length == 0)
{
this.ExecuteQuery(
query,
parameters,
result,
queryItem,
new GroupDefinition(
this.Instance,
string.Empty,
string.Empty
),
progress
);
ProgressComplete(progress);
}
else
{
foreach (var group in groups)
{
if (group.ChildGroups.Count > 0)
{
var tempParams = parameters.Clone();
tempParams.AddValues(
this.GetGroupsResolver().GetParametersFromDefinition(group)
);
this.ExecuteQuery(
query,
tempParams,
progress,
group.ChildGroups.ToArray(),
result,
queryItem
);
}
ProgressItem subProgress = null;
if (progress != null)
{
try
{
subProgress = progress.GetChild();
}
catch (Exception)
{
}
}
this.ExecuteQuery(
query,
parameters,
result,
queryItem,
@group,
subProgress
);
ProgressComplete(subProgress);
}
}
}
/// <summary>
/// The process group.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="result">The result.</param>
/// <param name="queryItem">The query item.</param>
/// <param name="group">The group.</param>
/// <param name="subProgress">The sub progress.</param>
protected virtual void ExecuteQuery(
QueryInfo query,
QueryExecutionParams parameters,
QueryInstanceResultInfo result,
QueryItemInfo queryItem,
GroupDefinition group,
ProgressItem subProgress
)
{
// Log.InfoFormat("146:query:'{0}'",
// query
// );
var qr = this.ExecuteQueryItemFunction.Invoke(
this.Instance,
queryItem,
string.IsNullOrWhiteSpace(group.Name) ? parameters.DefaultDatabase : group.Name,
//group.Name,
group.Id,
query.Parameters,
parameters.Values.ToList(),
subProgress
);
// костыль. Наверное, прибъется вообще после убиения "групп"
qr.Database = group.Name;
result.AddDatabaseResult(qr);
}
public void SaveRequestedData(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo results
)
{
Debug.Assert(templateNodeInfo.IsInstance);
long requestId = this.CurrentStorage.MetaResultTable.GetMaxRequestId() + 1L;
DateTime timestamp = DateTime.Now;
const long sessionId = 1L;
List <ITableRow> metaRows = new List <ITableRow>();
foreach (TemplateNodeResultItem nodeResult in results.List)
{
TemplateNodeQueryInfo templateNodeQuery = nodeResult.TemplateNodeQuery;
QueryResultInfo queryResult = nodeResult.QueryResult;
foreach (KeyValuePair <InstanceInfo, QueryInstanceResultInfo> instancePair in queryResult.InstancesResult)
{
long totalRowsSaved = 0L;
InstanceInfo instance = instancePair.Key;
QueryInstanceResultInfo queryInstanceResult = instancePair.Value;
Int64?queryId = CurrentStorage.QueryDirectory.GetQueryId(
templateNodeInfo,
templateNodeQuery,
instance,
timestamp,
false
);
Log.InfoFormat("Instance:'{0}';QueryId:'{1}'",
instance,
queryId
);
if (queryInstanceResult.ErrorInfo == null)
{
IEnumerable <QueryDatabaseResultInfo> notEmptyResults = queryInstanceResult.DatabasesResult.Values
.Where(d => d != null && d.DataTables != null);
foreach (QueryDatabaseResultInfo databaseResultInfo in notEmptyResults)
{
totalRowsSaved += SaveDatabaseResult(
templateNodeQuery,
instance,
databaseResultInfo,
queryId
);
}
}
ITableRow metaRow = this.CurrentStorage.MetaResultTable.GetMetaRow(
requestId,
sessionId,
timestamp,
queryInstanceResult,
queryId,
totalRowsSaved
);
metaRows.Add(metaRow);
}
}
this.CurrentStorage.MetaResultTable.ReplaceRows(metaRows);
this.CurrentStorage.ResetRowCountCache(templateNodeInfo);
}
