/// <summary>
/// Default constructor
/// </summary>
/// <param name="date">DateTime of error</param>
/// <param name="instance">Server instance of error</param>
/// <param name="queryItem">Query</param>
/// <param name="error">Thrown exception</param>
public ErrorLogItem(DateTime date, InstanceInfo instance, QueryItemInfo queryItem, Exception error)
{
this._date = date;
this._instance = instance;
this._queryItem = queryItem;
this._error = error;
}
public abstract long? GetQueryId( TemplateNodeInfo node, TemplateNodeQueryInfo templateNodeQuery, InstanceInfo instance, DateTime dateCreated, bool onlyFind );
/// <summary>
/// Get Id for data
/// </summary>
/// <param name="connectionGroup">Connection group</param>
/// <param name="instance">Instance</param>
/// <returns></returns>
public Int64? GetId(ConnectionGroupInfo connectionGroup, InstanceInfo instance)
{
connectionGroup.ReadGroupIdFrom(Storage.ConnectionGroupDirectory);
Int64? loginId = Storage.LoginDirectory.GetId(instance);
ServerProperties props = instance.ServerProperties;
string serverName = null;
string serverVers = null;
if (props != null)
{
serverName = props.Name;
serverVers = props.Version.ToString();
}
return this.GetRecordIdByFields(
this.CreateField(ConnectionGroupIdFn, connectionGroup.Identity),
this.CreateField(LoginIdFn, loginId),
this.CreateField(ConnectionNameFn, instance.Name),
this.CreateField(ServerInstanceNameFn, serverName),
this.CreateField(ServerInstanceVersionFn, serverVers),
this.CreateField(DbTypeFn, instance.DbType),
this.CreateField(IsOdbcFn, instance.IsODBC),
this.CreateField(IsDynamicConnectionFn, instance.IsDynamicConnection)
);
}
public static Func<InstanceInfo, bool> MatchesTo(InstanceInfo instance)
{
Func<InstanceInfo, bool> matchingPredicate =
x => x.GetConnectionString() == instance.GetConnectionString();
return matchingPredicate;
}
public static ServerProperties Load(
InstanceInfo instance,
CurrentStorage storage
)
{
ServerProperties storedProps = storage.ServerInstanceDirectory
.GetServerProperties(instance);
return storedProps;
}
private static ServerProperties QueryMssql(
InstanceInfo instance,
int timeout = 0
)
{
string sqlString = string.Empty;
string serverName = string.Empty;
DateTime serverDate = DateTime.MaxValue;
using (DbConnection dbConnection = CreateMssqlConnection(instance))
{
dbConnection.Open();
InstanceVersion version = new InstanceVersion(dbConnection.ServerVersion);
bool isNewServer = version.Major >= 8; // MS SQL Server 2000
if (isNewServer)
{
sqlString = "SELECT SERVERPROPERTY(N'ServerName') AS [ServerName], " +
"SERVERPROPERTY(N'InstanceName') AS [InstanceName], " +
"GetDate() AS [InstanceDate];";
}
else
{
sqlString = "SELECT GetDate() AS [InstanceDate];";
}
using (DbCommand command = dbConnection.CreateCommand())
{
command.CommandText = sqlString;
if (timeout != 0)
{
command.CommandTimeout = timeout;
}
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.Read())
{
serverName = isNewServer
? reader["ServerName"].ToString()
: dbConnection.DataSource;
serverDate = DateTime.Parse(reader["InstanceDate"].ToString());
}
}
}
return new ServerProperties(version, serverName, serverDate);
}
}
/// <summary>
/// Get Row id for data
/// </summary>
/// <param name="instance">Instance</param>
/// <returns></returns>
public Int64? GetId(InstanceInfo instance)
{
AuthenticationInfo auth = instance.Authentication;
ICryptoService cipher = this.Storage.CryptoService;
return this.GetRecordIdByFields(
this.CreateField(LoginFn, auth.GetCurrentLogin()),
this.CreateField(PasswordFn, cipher.Encrypt(auth.Password)),
this.CreateField(IsWinAuthFn, auth.IsWindows)
);
}
public static ServerProperties Query(
InstanceInfo instance,
int timeout = 0
)
{
switch (instance.Type)
{
case QuerySource.MSSQL:
return QueryMssql(instance, timeout);
case QuerySource.TDSQL:
return QueryTeradata(instance, timeout);
default:
return GetBlackProperties(instance);
}
}
private static ServerProperties QueryTeradata(
InstanceInfo instance,
int timeout = 0
)
{
using (DbConnection dbConnection = CreateTeradataConnection(instance))
{
dbConnection.Open();
InstanceVersion version = new InstanceVersion(dbConnection.ServerVersion);
DateTime serverDate = DateTime.MaxValue;
using (DbCommand command = dbConnection.CreateCommand())
{
command.CommandText = "SELECT CURRENT_DATE AS InstanceDate";
if (timeout != 0)
{
command.CommandTimeout = timeout;
}
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.Read())
{
serverDate = DateTime.Parse(reader["InstanceDate"].ToString());
}
}
}
return(new ServerProperties(
version,
dbConnection.DataSource,
serverDate));
}
}
public ITableRow ReadLastMeta(
TemplateNodeInfo node,
InstanceInfo instance,
TemplateNodeQueryInfo templateNodeQuery
)
{
Int64? queryId = this.QueryDirectory.GetQueryId(
node,
templateNodeQuery,
instance,
new DateTime(),
true
);
return queryId != null
? this.ReadLastMeta(queryId.Value)
: null;
}
private static DbConnection CreateTeradataConnection(InstanceInfo instance)
{
if (instance.IsODBC)
{
return ConnectionFactory.CreateOdbcConnection(instance);
}
return ConnectionFactory.CreateTdConnection(instance);
}
private static DbConnection CreateMssqlConnection(InstanceInfo instance)
{
if (instance.IsODBC)
{
return ConnectionFactory.CreateOdbcConnection(instance);
}
return ConnectionFactory.CreateSqlConnection(instance);
}
private static ServerProperties QueryTeradata(
InstanceInfo instance,
int timeout = 0
)
{
using (DbConnection dbConnection = CreateTeradataConnection(instance))
{
dbConnection.Open();
InstanceVersion version = new InstanceVersion(dbConnection.ServerVersion);
DateTime serverDate = DateTime.MaxValue;
using (DbCommand command = dbConnection.CreateCommand())
{
command.CommandText = "SELECT CURRENT_DATE AS InstanceDate";
if (timeout != 0)
{
command.CommandTimeout = timeout;
}
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.Read())
{
serverDate = DateTime.Parse(reader["InstanceDate"].ToString());
}
}
}
return new ServerProperties(
version,
dbConnection.DataSource,
serverDate);
}
}
private void SelectInstance(InstanceInfo instanceInfo)
{
IEnumerable<InstanceInfo> instances =
this.cmbConnection.Items.OfType<InstanceInfo>();
InstanceInfo firstConnection = instances.FirstOrDefault(
x => x.GetConnectionString() == instanceInfo.GetConnectionString() && x.IsODBC == instanceInfo.IsODBC);
if (firstConnection == null)
{
this.cmbConnection.Items.Add(instanceInfo);
this.cmbConnection.SelectedItem = instanceInfo;
}
else
{
this.cmbConnection.SelectedItem = firstConnection;
}
}
private static void GenerateResultDefinition(
XmlElement rootNode,
TemplateNodeQueryInfo templateNodeQueryInfo,
ErrorInfo errorInfo,
InstanceInfo instance,
long rowCount,
Int64 recordSets
)
{
string errorCode = string.Empty;
string errorNumber = "0";
XmlElement node = rootNode.OwnerDocument.CreateElement(QueryResultNodeName);
node.SetAttribute("instance", instance.Name);
node.SetAttribute("name", templateNodeQueryInfo.QueryName);
node.SetAttribute("RecordSets", recordSets.ToString());
node.SetAttribute("RowCount", rowCount.ToString());
if (errorInfo != null)
{
XmlElement errorNode = rootNode.OwnerDocument.CreateElement("SqlErrorMessage");
errorNode.InnerText = errorInfo.Message;
node.AppendChild(errorNode);
errorCode = errorInfo.Code;
errorNumber = errorInfo.Number;
}
node.SetAttribute("SqlErrorCode", errorCode);
node.SetAttribute("SqlErrorNumber", errorNumber);
node.SetAttribute("hierarchy", templateNodeQueryInfo.ResultHierarchy);
rootNode.AppendChild(node);
}
private long SaveDatabaseResult(
TemplateNodeQueryInfo templateNodeQuery,
InstanceInfo instance,
QueryDatabaseResultInfo dbResult,
Int64? queryId
)
{
long totalRows = 0L;
Int64 recordSet = 1L;
foreach (DataTable table in dbResult.DataTables)
{
Debug.Assert(table != null);
long? savedRows = this.SaveResults(
instance,
templateNodeQuery,
recordSet,
table,
queryId
);
if (savedRows.HasValue)
{
totalRows += savedRows.Value;
}
recordSet++;
}
this.UpdateHistory(
instance,
templateNodeQuery,
queryId.Value
);
return totalRows;
}
internal DataTable[] ExecuteSql(
InstanceInfo instance,
QueryItemInfo sql,
string database = null,
IEnumerable<QueryParameterInfo> parameters = null,
IEnumerable<ParameterValue> parameterValues = null,
ProgressItem progress = null,
bool fromGroupSelect = false
)
{
Exception gotException = null;
List<DataTable> tables = new List<DataTable>();
this._cancellationToken.ThrowIfCancellationRequested();
try
{
if (sql == null)
{
throw new Exception("There is no sql statement to execute (QueryItemInfo == null).");
}
List<Tuple<int, string>> parametersQueueForODBC;
using (IQueryConnection connection = _queryConnectionFactory.CreateQueryConnection(sql.ParentQuery.Source, instance))
{
using (IQueryCommand sqlCommand = connection.GetCommand(sql.Text, this._model.Settings.SqlTimeout, parameters, out parametersQueueForODBC))
{
using (new TryFinally(connection.Open, connection.Close))
{
connection.ChangeDatabase(database);
var shouldExecute = true;
if (sql.ExecuteIfSqlText != null)
{
var clone = sql.Clone();
clone.ExecuteIfSqlText = null;
clone.Text = sql.ExecuteIfSqlText;
DataTable[] tt = ExecuteSql(
instance,
clone,
database,
parameters,
parameterValues,
progress,
fromGroupSelect
);
if (tt.Length > 0 && tt[0].Rows.Count > 0)
{
shouldExecute = (int)(tt[0].Rows[0][0]) == 1;
}
}
if (shouldExecute)
{
var executionFinishedEvent = new AutoResetEvent(false);
IQueryCommand command = null;
Action<IAsyncResult> handleCallback = result =>
{
command = (IQueryCommand)result.AsyncState;
try
{
using (var reader = command.EndExecuteReader(result))
{
while (!reader.IsClosed)
{
DataTable table = new DataTable();
table.Load(reader, LoadOption.OverwriteChanges, ExecuteSqlFillErrorHandler);
tables.Add(table);
}
}
}
catch (Exception ex)
{
log.Error(ex);
gotException = ex;
if (fromGroupSelect)
{
log.ErrorFormat(
"Instance:'{0}';Authentication:'{1}';SQL:'{2}';Exception:'{3}'",
instance.Instance,
instance.Authentication,
sql,
ex
);
}
}
finally
{
if (command != null)
{
command.Cancel();
}
executionFinishedEvent.Set();
}
};
sqlCommand.AssignParameters(parameters, parameterValues, parametersQueueForODBC);
var callback = new AsyncCallback(handleCallback);
var asyncResult = sqlCommand.BeginExecuteReader(callback);
if (WaitHandle.WaitAny(new[] { asyncResult.AsyncWaitHandle, this._cancellationToken.WaitHandle }) == 1)
{
if (command != null)
{
command.Cancel();
}
this._cancellationToken.ThrowIfCancellationRequested();
}
executionFinishedEvent.WaitOne();
}
}
}
}
}
catch (Exception ex)
{
log.Error(ex);
if (gotException == null)
{
gotException = ex;
if (fromGroupSelect)
{
log.ErrorFormat(
"Instance:'{0}';Authentication:'{1}';Exception:'{2}'",
instance.Instance,
instance.Authentication,
ex
);
}
}
}
finally
{
if (progress != null)
{
progress.SetProgressDone();
}
}
if (gotException != null)
{
if (!fromGroupSelect)
{
gotException.Data.Add("IgnoreLog", true);
}
throw gotException;
}
return tables.ToArray();
}
private Int64? SaveResults(
InstanceInfo instance,
TemplateNodeQueryInfo templateNodeQuery,
Int64 recordSet,
DataTable dataTable,
Int64? queryId
)
{
Int64? lSavedRows = 0L;
NormalizeInfo dbStructure = this.GetDbStucture(
templateNodeQuery,
recordSet,
instance,
dataTable
);
// Log.InfoFormat("Instance:'{0}';templateNode:'{1}';templateNodeQuery:'{2}';Table:'{3}';PrimaryKey:'{4}'",
// instance.Name,
// templateNode,
// templateNodeQuery,
// dbStructure.TableName,
// queryId
// );
if (queryId != null)
{
this.CurrentStorage.QueryResultsDirectory.GetId(
queryId.Value,
recordSet,
dbStructure.TableName
);
lSavedRows = this.ReportStorage.SaveResults(
queryId.Value,
dbStructure,
dataTable
);
}
return lSavedRows;
}
public NormalizeInfo GetDbStucture(
TemplateNodeQueryInfo templateNodeQueryInfo,
Int64 recordSet,
InstanceInfo instance,
DataTable dataTable = null
)
{
List<QueryInfo> queries = Model.GetQueryByTemplateNodeQueryInfo(templateNodeQueryInfo);
QueryInfo query = queries.FirstOrDefault(x => x.Source == instance.Type || x.Source == QuerySource.SQLite);
string tableName = this.GetTableName(templateNodeQueryInfo, recordSet);
string tableIndexes = string.Empty;
if (query != null)
{
tableIndexes = query.QueryIndexFileds;
}
lock (this._dbStructures)
{
if (!this._dbStructures.ContainsKey(tableName))
{
NormalizeInfo definedRecordSet = query.GetDbStructureForRecordSet(recordSet);
if (definedRecordSet != null)
{
var clone = definedRecordSet.Clone();
clone.TableName = tableName;
this._dbStructures.Add(tableName, clone);
}
else
{
if (dataTable == null)
{
NormalizeInfo result = new NormalizeInfo();
NormalizeFieldInfo field = new NormalizeFieldInfo();
result.TableName = tableName;
result.Fields = new List<NormalizeFieldInfo>();
field.Name = "*";
field.Type = SqlDbType.NVarChar;
result.Fields.Add(field);
result.TableIndexFileds = tableIndexes;
return result;
}
NormalizeInfo dbStructure = new NormalizeInfo
{
TableName = tableName,
IsAutoGenerated = true,
Fields = new List<NormalizeFieldInfo>(),
ChildDirectories = new List<NormalizeInfo>(),
RecordSet = recordSet,
QueryName = query.Name,
TableIndexFileds = tableIndexes
};
foreach (DataColumn column in dataTable.Columns)
{
NormalizeFieldInfo field = new NormalizeFieldInfo();
field.Name = column.ColumnName;
field.Type = column.DataType.ToSqlDbType();
field.IsUnique = true;
dbStructure.Fields.Add(field);
}
this._dbStructures.Add(tableName, dbStructure);
}
}
}
NormalizeInfo structure = this._dbStructures[tableName];
return structure;
}
internal DataTable[] ExecuteSql(
InstanceInfo instance,
QueryItemInfo sql,
IEnumerable<QueryParameterInfo> parameters = null,
IEnumerable<ParameterValue> parameterValues = null
)
{
bool shouldExecute = true;
if (sql == null)
{
throw new Exception("There is no sql statement to execute (QueryItemInfo == null).");
}
// Log.InfoFormat("instance:'{0}';sql.Text:'{1}'",
// instance,
// sql.Text
// );
if (sql.ExecuteIfSqlText != null)
{
var clone = sql.Clone();
clone.ExecuteIfSqlText = null;
clone.Text = sql.ExecuteIfSqlText;
DataTable[] tt = ExecuteSql(
instance,
clone,
parameters,
parameterValues
);
if (tt.Length > 0 && tt[0].Rows.Count > 0)
{
shouldExecute = (int)(tt[0].Rows[0][0]) == 1;
}
}
if (shouldExecute)
{
return this.CurrentStorage.ExecuteSql(
sql.Text,
parameters,
parameterValues,
instance
);
}
return new DataTable[0];
}
private void SaveHistoryData(
QueryInfo query,
InstanceInfo instance,
long queryId,
TemplateNodeQueryInfo templateNodeQuery
)
{
QueryInfo queryInfo = new QueryInfo { Source = QuerySource.SQLite };
Regex regex = new Regex(@"\[\$\{(?<QueryName>[\w]+)\}\$_\$\{(?<RecordSetNumber>[\w]+)\}\$\]");
string strQueryName = String.Empty;
Int64 intRecordSetNumber = 0L;
string strReplacedTableName = String.Empty;
if (query.FillStatementList == null)
{
return;
}
List<HistoryFillStatement> list = query.FillStatementList.GetSortedStatements();
List<QueryParameterInfo> parameters = new List<QueryParameterInfo>
{
new QueryParameterInfo
{
Name = _QueryIdParameterName,
Type = SqlDbType.BigInt
}
};
List<ParameterValue> paramterValues = new List<ParameterValue>
{
new ParameterValue
{
Name = _QueryIdParameterName,
StringValue = queryId.ToString()
}
};
// string newTableName = String.Format("[{0}]",
// this.GetTableName(templateNodeQuery, recordSet) ?? "_unknown_table_"
// );
// string oldTableName = "[${" + query.Name + "}$_${" + recordSet + "}$]";
// string oldTableName = String.Format("[${{{0}}}$_${{{1}}}$]",
// query.Name ?? "_unknown_table_",
// recordSet
//);
// Log.DebugFormat("oldTableName:'{0}',newTableName:'{1}'",
// oldTableName,
// newTableName
//);
foreach (HistoryFillStatement statement in list)
{
QueryItemInfo queryItem = new QueryItemInfo();
queryItem.ParentQuery = queryInfo;
queryItem.Text = statement.Text;
// queryItem.Text = statement.Text.Replace(oldTableName, newTableName);
// Regex regex = new Regex("[\$\{([\w]+)\}\$_\$\{([\w]+)\}\$]");
// Log.InfoFormat("regex:'{0}'",
// regex
// );
var results = regex.Matches(statement.Text);
foreach (Match match in results)
{
// Log.InfoFormat("match:'{0}';match.Value:'{1}'",
// match,
// match.Value
// );
strQueryName = match.Groups["QueryName"].Value;
intRecordSetNumber = Int64.Parse(match.Groups["RecordSetNumber"].Value);
// Log.InfoFormat("strQueryName:'{0}';intRecordSetNumber:'{1}'",
// strQueryName,
// intRecordSetNumber
// );
if (String.Equals(strQueryName, query.Name, StringComparison.OrdinalIgnoreCase))
{
// Log.InfoFormat("matches:strQueryName:'{0}';query.Name:'{1}'",
// strQueryName,
// query.Name
// );
strReplacedTableName = string.Format(
"[{0}]",
this.GetTableName(
templateNodeQuery,
intRecordSetNumber
)
);
// Log.InfoFormat("strReplacedTableName:'{0}'",
// strReplacedTableName
// );
// Log.InfoFormat("queryItem.Text:'{0}'",
// queryItem.Text
// );
queryItem.Text = queryItem.Text.Replace(
match.Value,
strReplacedTableName
);
// Log.InfoFormat("queryItem.Text:'{0}'",
// queryItem.Text
// );
}
}
this.ExecuteSql(
instance,
queryItem,
parameters,
paramterValues
);
}
}
private void UpdateHistory(
InstanceInfo instance,
TemplateNodeQueryInfo templateNodeQuery,
long queryId
)
{
if (this.HistoryStorage != null && this._updateHistory)
{
List<QueryInfo> queries = Model.GetQueryByTemplateNodeQueryInfo(templateNodeQuery);
QueryInfo query = queries.FirstOrDefault(
x =>
x.Source == instance.Type
||
x.Source == QuerySource.SQLite
);
try
{
this.SaveHistoryData(
query,
instance,
queryId,
templateNodeQuery
);
}
catch (Exception ex)
{
Log.ErrorFormat("Update History exception:{0};query:{1}",
ex,
query
);
if (!ex.Data.Contains("IgnoreLog"))
{
Log.ErrorFormat("Update History exception:{0};query:{1}",
ex,
query
);
}
}
}
}
private static ServerProperties GetBlackProperties(InstanceInfo instance)
{
return new ServerProperties(new InstanceVersion(), instance.Name, DateTime.Now);
}
public SQLiteParameter[] GetParameters(
IEnumerable<QueryParameterInfo> parameters,
IEnumerable<ParameterValue> parameterValues,
InstanceInfo instance
)
{
var result = new List<SQLiteParameter>();
if (parameters != null)
{
foreach (var parameter in parameters)
{
result.Add(
new SQLiteParameter
{
ParameterName = parameter.Name,
IsNullable = true,
DbType = parameter.Type.ToDbType(),
Value = parameter.GetDefaultValue()
}
);
}
}
if (parameterValues != null)
{
foreach (var value in parameterValues)
{
var parameter = (
from
SQLiteParameter p
in
result
where
p.ParameterName == value.Name
select
p
).FirstOrDefault();
if (parameter != null)
{
parameter.Value = value.GetValue(parameter.DbType.ToSqlDbType());
}
}
}
result.AddRange(this.GetDefaultParameters(instance));
return result.ToArray();
}
private InstanceInfo CreateFromRow(ServerInstanceRow instanceRow)
{
long loginId = instanceRow.LoginId;
LoginRow loginRow = this._loginManager.GetLogin(loginId);
AuthenticationInfo authInfo = new AuthenticationInfo
{
Username = loginRow.Login,
Password = loginRow.Password,
IsWindows = loginRow.IsWinAuth
};
string conName = instanceRow.ConnectionName;
InstanceInfo instanceInfo = new InstanceInfo(instanceRow.IsDynamicConnection)
{
Authentication = authInfo,
IsODBC = instanceRow.IsOdbc,
DbType = instanceRow.DbType,
IsEnabled = true,
Name = conName,
Instance = conName
};
instanceInfo.SetServerProperties(
new ServerProperties(
new InstanceVersion(instanceRow.ServerInstanceVersion),
instanceRow.ServerInstanceName,
DateTime.Now
)
);
return instanceInfo;
}
internal DataTable[] ExecuteSql(
InstanceInfo instance,
QueryInfo query,
string database = null,
IEnumerable<QueryParameterInfo> parameters = null,
IEnumerable<ParameterValue> parameterValues = null,
ProgressItem progress = null,
bool fromGroupSelect = false
)
{
InstanceVersion ver = instance.ServerProperties.Version;
QueryItemInfo exactSqlVersion = query.Items.GetQueryItemForVersion(ver);
if (exactSqlVersion == null)
{
throw new InvalidOperationException("No <sql-select-text> found for version " + ver + " in <sql-select name=" + query.Name);
}
return ExecuteSql(
instance,
exactSqlVersion,
database,
parameters,
parameterValues,
progress,
fromGroupSelect
);
}
public DataTable[] ExecuteSql(
string sql,
IEnumerable<QueryParameterInfo> parameters,
IEnumerable<ParameterValue> parameterValues,
InstanceInfo instance
)
{
var result = new List<DataTable>();
var selectCommand = new SqlSelectCommand(
this.Connection,
sql,
reader =>
{
var table = new DataTable();
table.Load(reader, LoadOption.OverwriteChanges);
result.Add(table);
},
this.GetParameters(parameters, parameterValues, instance)
);
selectCommand.Execute(100);
return result.ToArray();
}
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;
}
private IEnumerable<SQLiteParameter> GetDefaultParameters(InstanceInfo instance)
{
List<SQLiteParameter> result = new List<SQLiteParameter>();
ConnectionGroupInfo connectionGroup = instance.ConnectionGroup;
connectionGroup.ReadGroupIdFrom(this.ConnectionGroupDirectory);
long? instanceId = this.ServerInstanceDirectory.GetId(connectionGroup, instance);
long? loginId = this.LoginDirectory.GetId(instance);
long? templateId = this.TemplateDirectory.GetId(connectionGroup);
result.Add(
SQLiteHelper.GetParameter(ConnectionGroupDirectory.TableName.AsFk(), connectionGroup.Identity)
);
result.Add(
SQLiteHelper.GetParameter(ServerInstanceDirectory.TableName.AsFk(), instanceId)
);
result.Add(
SQLiteHelper.GetParameter(LoginDirectory.TableName.AsFk(), loginId)
);
result.Add(
SQLiteHelper.GetParameter(TemplateDirectory.TableName.AsFk(), templateId)
);
return result;
}
private DataTable[] GetDataTables(
Int64 recordSetCount,
Int64 queryId,
InstanceInfo instance,
TemplateNodeQueryInfo templateNodeQueryInfo
)
{
var dataTables = new DataTable[recordSetCount];
for (Int64 recordSet = 1L; recordSet <= recordSetCount; recordSet++)
{
NormalizeInfo db = StorageManager.GetDbStucture(templateNodeQueryInfo, recordSet, instance);
if (db != null)
{
if (this._histTable.ContainsKey(templateNodeQueryInfo))
{
dataTables[recordSet - 1L] = this._histTable[templateNodeQueryInfo];
}
else
{
dataTables[recordSet - 1L] = base.ReportStorage.ReadResult(db, queryId);
}
}
}
return dataTables;
}
private static ServerProperties GetBlackProperties(InstanceInfo instance)
{
return(new ServerProperties(new InstanceVersion(), instance.Name, DateTime.Now));
}
public override long? GetQueryId(
TemplateNodeInfo node,
TemplateNodeQueryInfo templateNodeQuery,
InstanceInfo instance,
DateTime dateCreated,
bool onlyFind
)
{
Int64? queryId = 0L;
Debug.Assert(node.IsInstance);
if (node.TemplateNodeId == null)
{
throw new InvalidOperationException();
}
Int64? templateNodeQueryId = Storage.TemplateNodeQueryDirectory
.GetId(node.ConnectionGroup, node.Template, templateNodeQuery);
Int64? serverId = Storage.ServerInstanceDirectory
.GetId(node.ConnectionGroup, instance);
if (onlyFind)
{
Tuple<long, long, long> key = new Tuple<Int64, Int64, Int64>(
(long) node.TemplateNodeId.Value,
(long) templateNodeQueryId,
(long) serverId
);
return this.Cache.GetOrAdd(
key, () =>
{
ITableRow row = this.NewRow();
row.Values.Add(NodeInstanceIdFn, node.TemplateNodeId.Value);
row.Values.Add(TemplateNodeQueryIdFn, templateNodeQueryId);
row.Values.Add(ServerInstanceIdFn, serverId);
queryId = this.GetRow(row);
Log.InfoFormat("ServerId:'{0}';NodeInstanceId:'{1}';TemplateNodeQueryId:'{2}';PrimaryKey:'{3}'",
serverId,
node.TemplateNodeId.Value,
templateNodeQueryId,
queryId
);
return queryId;
}
);
}
List<Field> customFields = new List<Field>
{
this.CreateField(DefaultDatabaseNameFn, node.GetDefaultDatabase()),
this.CreateField(TableDefinition.DateCreated, dateCreated),
this.CreateField(NodeInstanceIdFn, node.TemplateNodeId.GetValueOrDefault()),
this.CreateField(TemplateNodeQueryIdFn, templateNodeQueryId),
this.CreateField(ServerInstanceIdFn, serverId)
};
queryId = this.GetRecordIdByFields(customFields.ToArray());
Log.InfoFormat("ServerId:'{0}';NodeInstanceId:'{1}';TemplateNodeQueryId:'{2}';id:'{3}'",
serverId,
node.TemplateNodeId.GetValueOrDefault(),
templateNodeQueryId,
queryId
);
return queryId;
}
