private Dictionary <TemplateNodeQueryInfo, DataTable> PrepareHistoryData(
MultyQueryResultInfo results
)
{
Dictionary <TemplateNodeQueryInfo, DataTable> result =
new Dictionary <TemplateNodeQueryInfo, DataTable>();
foreach (QueryDatabaseResult queryDatabaseResult in results.GetDatabaseResults())
{
QueryDatabaseResultInfo dbResult = queryDatabaseResult.Result;
if (dbResult == null || dbResult.DataTables == null)
{
continue;
}
TemplateNodeQueryInfo templateNodeQuery = queryDatabaseResult.TemplateNodeQuery;
foreach (DataTable table in dbResult.DataTables)
{
Debug.Assert(table != null);
if (!result.ContainsKey(templateNodeQuery))
{
result.Add(templateNodeQuery, table);
}
}
}
return(result);
}
public override void ReadTo(MultyQueryResultInfo result)
{
foreach (var guardQueryInfo in base.TemplateNode.SqlCodeGuardQueries)
{
this.ProcessCodeGuardQuery(result, guardQueryInfo);
}
}
public void SaveRequestedData(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo results
)
{
this._storageManager.SaveRequestedData(templateNodeInfo, results);
}
public QueryResultDataSource(
MsSqlAuditorModel model,
ConcreteTemplateNodeDefinition nodeDefinition
)
{
this._model = model;
this._nodeDefinition = nodeDefinition;
this._queriesResult = ReadQueriesResult();
}
public override void ReadTo(MultyQueryResultInfo result)
{
foreach (TemplateNodeResultItem templateNodeResultItem in base.TemplateNode.Queries.Select(
templateNodeQueryInfo => ReadTemplateNodeResult(templateNodeQueryInfo, result))
)
{
result.Add(templateNodeResultItem);
}
}
private void SaveDynamicConnections(
TemplateNodeInfo templateNode,
MultyQueryResultInfo queriesResult
)
{
foreach (TemplateNodeResultItem templateNodeResultItem in queriesResult.List)
{
TemplateNodeQueryInfo queryInfo = templateNodeResultItem.TemplateNodeQuery;
TemplateNodeInfo templateNodeClone = templateNode;
if (queryInfo.ConnectionsSelectId != null)
{
QueryResultInfo queryResult = templateNodeResultItem.QueryResult;
foreach (InstanceInfo instanceInfo in templateNodeClone.ConnectionGroup.Connections)
{
Int64?destParentQueryId = this.CurrentStorage.QueryDirectory.GetQueryId(
templateNode,
queryInfo,
instanceInfo,
DateTime.Now,
false
);
foreach (KeyValuePair <InstanceInfo, QueryInstanceResultInfo> queryInstanceResultInfo in queryResult.InstancesResult)
{
InstanceInfo selectConnectionInstance = queryInstanceResultInfo.Key;
Int64?dynamicQueryId = this.CurrentStorage.QueryDirectory.GetQueryId(
templateNodeClone,
queryInfo,
selectConnectionInstance,
DateTime.Now,
false
);
if (destParentQueryId == null)
{
continue;
}
DynamicConnection dynamicConnection = new DynamicConnection(
selectConnectionInstance.Name,
selectConnectionInstance.Type.ToString(),
selectConnectionInstance.IsODBC,
dynamicQueryId
);
this.CurrentStorage.DynamicConnectionDirectory.UpdateConnection(
destParentQueryId.Value,
dynamicConnection
);
}
}
}
}
}
public void UpdateTreeNodeTimings(
TemplateNodeInfo node,
MultyQueryResultInfo results
)
{
UpdateTreeNodeTimings(
node,
results.NodeLastUpdated,
results.NodeLastUpdateDuration
);
}
public MultyQueryResultInfo Read(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
var result = new MultyQueryResultInfo();
this.ReadFromMeta(connectionGroup, concreteTemplateNode, result);
this.ReadFromCodeGuard(concreteTemplateNode, result);
return(result);
}
private void ReadFromCodeGuard(
ConcreteTemplateNodeDefinition concreteTemplateNode,
MultyQueryResultInfo result
)
{
NodeResultReader nodeResultReader = new CodeGuardResultReader(
this._msSqlAuditor,
this._storageManager,
concreteTemplateNode
);
nodeResultReader.ReadTo(result);
}
private List <Tuple <TemplateNodeQueryInfo, Int64, DataTable> > GetResultTables(
ConcreteTemplateNodeDefinition nodeDefinition,
MultyQueryResultInfo queriesResult
)
{
List <Tuple <TemplateNodeQueryInfo, Int64, DataTable> > resultTables =
new List <Tuple <TemplateNodeQueryInfo, Int64, DataTable> >();
try
{
GroupDefinition database = nodeDefinition.Group;
if (database != null)
{
foreach (QueryDatabaseResult queryDatabaseResult in queriesResult.GetDatabaseResults())
{
QueryDatabaseResultInfo dbResult = queryDatabaseResult.Result;
if (dbResult == null || dbResult.DataTables == null)
{
continue;
}
if (database.Name == dbResult.Database)
{
Int64 recordSet = 1L;
foreach (DataTable curTable in dbResult.DataTables)
{
resultTables.Add(
new Tuple <TemplateNodeQueryInfo, Int64, DataTable>(
queryDatabaseResult.TemplateNodeQuery,
recordSet,
curTable
)
);
recordSet++;
}
}
}
}
}
catch (Exception ex)
{
log.Error("Error in 'Extracts data from queries and saves it to table for RDLC.'", ex);
throw;
}
return(resultTables);
}
public void SerializeData(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo queriesResult
)
{
SaveDynamicConnections(templateNodeInfo, queriesResult);
SaveRequestedData(templateNodeInfo, queriesResult);
this.CurrentStorage.UpdateTreeNodeTimings(
templateNodeInfo,
queriesResult
);
}
internal void SaveMeta(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo results,
long requestId,
DateTime timestamp
)
{
Debug.Assert(templateNodeInfo.IsInstance);
Int64 sessionId = 1L;
List <ITableRow> metaRows = new List <ITableRow>();
foreach (TemplateNodeResultItem tuple in results.List)
{
TemplateNodeQueryInfo templateNodeQuery = tuple.TemplateNodeQuery;
QueryResultInfo queryResult = tuple.QueryResult;
foreach (QueryInstanceResultInfo queryInstanceResult in queryResult.InstancesResult.Values)
{
InstanceInfo instance = queryInstanceResult.Instance;
Int64?queryId = this.QueryDirectory.GetQueryId(
templateNodeInfo,
templateNodeQuery,
instance,
timestamp,
false);
Log.InfoFormat("Instance:'{0}';QueryId:'{1}'",
instance,
queryId
);
ITableRow row = this.MetaResultTable.GetMetaRow(
requestId,
sessionId,
timestamp,
queryInstanceResult,
queryId,
null
);
metaRows.Add(row);
}
}
this.MetaResultTable.ReplaceRows(metaRows);
this.ResetRowCountCache(templateNodeInfo);
}
private void ReadFromMeta(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode,
MultyQueryResultInfo result
)
{
NodeResultReader nodeResultReader = new MetaResultReader(
this._msSqlAuditor,
this._storageManager,
connectionGroup,
concreteTemplateNode
);
nodeResultReader.ReadTo(result);
}
private Dictionary <TemplateNodeQueryInfo, DataTable> ReadHistTable(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
Dictionary <TemplateNodeQueryInfo, DataTable> histTable = new Dictionary <TemplateNodeQueryInfo, DataTable>();
TemplateNodeInfo templateNodeInfo = concreteTemplateNode.TemplateNode;
ProgressItem progress = new ProgressItem();
using (SqlProcessor sqlProcessor = MsSqlAuditor.GetNewSqlProcessor(new CancellationToken()))
{
progress.SetPromisedChildCount(1);
MultyQueryResultInfo resultQuery = sqlProcessor.ExecuteMultyQuery(
connectionGroup,
templateNodeInfo.Queries,
progress.GetChild(),
Program.Model.Settings.SystemSettings.MaximumDBRequestsThreadCount,
true
);
if (resultQuery != null)
{
if (resultQuery.List != null)
{
if (resultQuery.List.Count != 0)
{
long requestId = this.Storage.MetaResultTable.GetMaxRequestId() + 1L;
DateTime timestamp = DateTime.Now;
histTable = PrepareHistoryData(resultQuery);
this.Storage.SaveMeta(
templateNodeInfo,
resultQuery,
requestId,
timestamp
);
}
}
}
}
return(histTable);
}
/// <summary>
/// Append errors to log
/// </summary>
/// <param name="multyQueryResultInfo">from multyquery result</param>
public void AppendErrorLog(MultyQueryResultInfo multyQueryResultInfo)
{
foreach (TemplateNodeResultItem item in multyQueryResultInfo.List)
{
if (item.QueryResult.ErrorInfo == null)
{
AppendErrorLog(item.QueryResult);
}
else
{
this._errorItems.Add(new ErrorLogItem(item.QueryResult.ErrorInfo.DateTime, null,
new QueryItemInfo()
{
Text = item.TemplateNodeQuery.QueryName
},
item.QueryResult.ErrorInfo.Exception)
);
}
}
}
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);
}
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);
}
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));
}
public VisualizeData GetVisualizeData(
NodeDataProvider dataProvider,
GraphicsInfo graphicsInfo
)
{
XmlDocument xmlData = dataProvider.XmlDocument;
MultyQueryResultInfo queriesResult = dataProvider.QueryResult;
VisualizeData result = new VisualizeData
{
NodeLastUpdated = queriesResult.NodeLastUpdated,
NodeLastUpdateDuration = queriesResult.NodeLastUpdateDuration
};
if (xmlData != null && xmlData.DocumentElement != null)
{
result.SourceXml = xmlData.FormatXml();
}
ConcreteTemplateNodeDefinition nodeDefinition = dataProvider.NodeDefinition;
string xslFileName = GetXslFileName(nodeDefinition);
if (xslFileName != null && File.Exists(xslFileName))
{
XmlDocument xslDoc = new XmlDocument();
xslDoc.Load(xslFileName);
ConnectionGroupInfo connectionGroup = nodeDefinition.Connection;
if (AppVersionHelper.IsNotDebug() && !connectionGroup.IsExternal)
{
CryptoProcessor cryptoProcessor = new CryptoProcessor(
this._model.Settings.SystemSettings.PublicKeyXmlSign,
this._model.Settings.SystemSettings.PrivateKeyXmlDecrypt
);
cryptoProcessor.DecryptXmlDocument(xslDoc);
}
try
{
XslPreprocessManager preprocessManager = GetManager(
dataProvider,
graphicsInfo
);
List <PreprocessorAreaData> datas;
using (preprocessManager.ExecuteXslPreprocessing(xslDoc, out datas))
{
}
foreach (PreprocessorAreaData preprocessorAreaData in datas)
{
preprocessorAreaData.CheckPreprocessors();
}
result.PreprocessorAreas = datas.ToList();
}
catch (Exception ex)
{
log.ErrorFormat(
"nodeDefinition.TemplateNode.Queries(.Name)='{0}';xslFileName='{1}';Exception:'{2}'",
nodeDefinition.TemplateNode.Queries.Select(q => q.QueryName).Join(", "),
xslFileName,
ex
);
}
}
return(result);
}
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 abstract void ReadTo(MultyQueryResultInfo result);
private void SaveSrcData(
string currentDb,
string reportDb,
ISerializationCancellationToken canceller
)
{
ConnectionData connectionData;
StorageManager backupStorageManager = new StorageManager(
this._model, false, currentDb, null, reportDb);
backupStorageManager.InitializeDataBases();
CheckCancellation(canceller);
IEnumerable <ConcreteTemplateNodeDefinition> nodes =
this._connectionTabControl.GetCurrentTree(out connectionData);
if (nodes != null)
{
IList <ConcreteTemplateNodeDefinition> nodeList = nodes as IList <ConcreteTemplateNodeDefinition> ?? nodes.ToList();
if (nodeList.Any())
{
ConnectionGroupInfo sourceConnection = connectionData.ConnectionGroup;
ConnectionGroupInfo destConnection = sourceConnection.CopyXmlContent();
destConnection.Identity = backupStorageManager.CurrentStorage.ConnectionGroupDirectory.GetId(destConnection);
Dictionary <TemplateNodeInfo, TemplateNodeInfo> clonesDict = new Dictionary <TemplateNodeInfo, TemplateNodeInfo>();
ConnectionData destConnectionData = new ConnectionData(this._model, destConnection);
TemplateNodeInfo nodesRoot = nodeList.First().TemplateNode.GetRootPatent();
TemplateNodeInfo clonedNodesRoot = nodesRoot.CloneNotSavedTree(clonesDict, destConnectionData);
CheckCancellation(canceller);
backupStorageManager.CurrentStorage.NodeInstances.SaveTree(clonedNodesRoot);
CheckCancellation(canceller);
foreach (ConcreteTemplateNodeDefinition concreteTemplateNode in nodeList)
{
CheckCancellation(canceller);
MultyQueryResultInfo queriesResult = this._model.DefaultVaultProcessor.ReadCurrentResult(
sourceConnection,
concreteTemplateNode
);
CheckCancellation(canceller);
TemplateNodeInfo templateNode = concreteTemplateNode.TemplateNode;
if (queriesResult != null)
{
backupStorageManager.SerializeData(
clonesDict[templateNode],
queriesResult
);
}
}
}
}
}
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);
}
