/// <summary>
/// The run operation.
/// </summary>
/// <param name="sqlConnection">
/// The sql connection.
/// </param>
/// <param name="dbTransaction">
/// The unit Of Work.
/// </param>
/// <param name="dbfunctionType">
/// The dbfunction type.
/// </param>
/// <param name="operationName">
/// The operation name.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <returns>
/// The run operation.
/// </returns>
protected abstract bool RunOperation(
[NotNull] SqlConnection sqlConnection,
[NotNull] IDbTransaction dbTransaction,
DBFunctionType dbfunctionType,
[NotNull] string operationName,
[NotNull] IEnumerable <KeyValuePair <string, object> > parameters,
[CanBeNull] out object result);
/// <summary>
/// The run operation.
/// </summary>
/// <param name="sqlConnection">The sql connection.</param>
/// <param name="dbTransaction">The db unit of work.</param>
/// <param name="dbfunctionType">The dbfunction type.</param>
/// <param name="operationName">The operation name.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="result">The result.</param>
/// <returns>
/// The run operation.
/// </returns>
protected override bool RunOperation(
SqlConnection sqlConnection,
IDbTransaction dbTransaction,
DBFunctionType dbfunctionType,
string operationName,
IEnumerable <KeyValuePair <string, object> > parameters,
out object result)
{
// create statistic SQL...
var sb = new StringBuilder();
sb.AppendLine("DECLARE @TableName sysname");
sb.AppendLine("DECLARE cur_showfragmentation CURSOR FOR");
sb.AppendLine(
"SELECT table_name FROM information_schema.tables WHERE table_type = 'base table' AND table_name LIKE '{objectQualifier}%'");
sb.AppendLine("OPEN cur_showfragmentation");
sb.AppendLine("FETCH NEXT FROM cur_showfragmentation INTO @TableName");
sb.AppendLine("WHILE @@FETCH_STATUS = 0");
sb.AppendLine("BEGIN");
sb.AppendLine("DBCC SHOWCONTIG (@TableName)");
sb.AppendLine("FETCH NEXT FROM cur_showfragmentation INTO @TableName");
sb.AppendLine("END");
sb.AppendLine("CLOSE cur_showfragmentation");
sb.AppendLine("DEALLOCATE cur_showfragmentation");
using (var cmd = this.DbAccess.GetCommand(sb.ToString(), CommandType.Text))
{
this.DbAccess.ExecuteNonQuery(cmd, dbTransaction);
}
result = this._sqlMessages.Select(s => s.Message).ToDelimitedString("\r\n");
return(true);
}
/// <summary>
/// The run filters.
/// </summary>
/// <param name="functionType">
/// The function type.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="operationName">
/// The operation name.
/// </param>
/// <param name="result">
/// The result.
/// </param>
private void RunFilters(DBFunctionType functionType, IList <KeyValuePair <string, object> > parameters, string operationName, ref object result)
{
// execute filter...
var filterFunctions = this._serviceLocator.Get <IEnumerable <IDbDataFilter> >()
.BySortOrder()
.WhereOperationSupported(operationName)
.ToList();
foreach (var filter in filterFunctions)
{
filter.Run(functionType, operationName, parameters, result);
}
}
/// <summary>
/// The execute.
/// </summary>
/// <param name="dbfunctionType">
/// The dbfunction type.
/// </param>
/// <param name="operationName">
/// The operation name.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <param name="transaction"></param>
/// <returns>
/// The execute.
/// </returns>
public virtual bool Execute(
DBFunctionType dbfunctionType,
[NotNull] string operationName,
[NotNull] IEnumerable <KeyValuePair <string, object> > parameters,
[CanBeNull] out object result,
IDbTransaction transaction = null)
{
if (this.IsSupportedOperation(operationName))
{
this._sqlMessages.Clear();
var createdTransaction = transaction == null;
try
{
transaction ??= this.DbAccess.BeginTransaction();
if (transaction.Connection is SqlConnection sqlConnection)
{
sqlConnection.FireInfoMessageEventOnUserErrors = true;
sqlConnection.InfoMessage += this.sqlConnection_InfoMessage;
var operationSuccessful = this.RunOperation(
sqlConnection,
transaction,
dbfunctionType,
operationName,
parameters,
out result);
if (createdTransaction && operationSuccessful)
{
transaction.Commit();
}
return(operationSuccessful);
}
}
finally
{
if (createdTransaction)
{
transaction?.Dispose();
}
}
}
result = null;
return(false);
}
/// <summary>
/// The run.
/// </summary>
/// <param name="dbfunctionType">
/// The dbfunction type.
/// </param>
/// <param name="operationName">
/// The operation name.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="data">
/// The data.
/// </param>
public void Run(DBFunctionType dbfunctionType, string operationName, IEnumerable <KeyValuePair <string, object> > parameters, object data)
{
if (!this.ServiceLocator.IsBoardContext() || !this._styledNickOperations.Contains(operationName.ToLower()) || dbfunctionType != DBFunctionType.DataTable)
{
return;
}
if (!this.BoardSettings.UseStyledNicks)
{
return;
}
var dataTable = (DataTable)data;
this.StyleTransform.DecodeStyleByTable(dataTable);
}
/// <summary>
/// The db function execute.
/// </summary>
/// <param name="functionType">
/// The function Type.
/// </param>
/// <param name="binder">
/// The binder.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="executeDb">
/// The execute db.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <returns>
/// The db function execute.
/// </returns>
protected bool DbFunctionExecute(
DBFunctionType functionType,
[NotNull] InvokeMemberBinder binder,
[NotNull] IList <KeyValuePair <string, object> > parameters,
[NotNull] Func <IDbCommand, object> executeDb,
[CanBeNull] out object result)
{
CodeContracts.VerifyNotNull(binder, "binder");
CodeContracts.VerifyNotNull(parameters, "parameters");
CodeContracts.VerifyNotNull(executeDb, "executeDb");
var operationName = binder.Name;
// see if there's a specific function override for the current provider...
var specificFunction = this.DbSpecificFunctions
.WhereOperationSupported(operationName)
.FirstOrDefault();
result = null;
if (specificFunction != null)
{
if (!specificFunction.Execute(functionType, operationName, parameters, out result, this.DbTransaction))
{
// unsuccessful -- execute command below
specificFunction = null;
}
}
if (specificFunction == null)
{
using (var cmd = this._dbAccessProvider.Instance.GetCommand(operationName, CommandType.StoredProcedure, parameters))
{
result = executeDb(cmd);
}
}
this.RunFilters(functionType, parameters, operationName, ref result);
return(true);
}
/// <summary>
/// Handle the run operation.
/// </summary>
/// <param name="sqlConnection">
/// The SQL Connection.
/// </param>
/// <param name="transaction">
/// The DB Transaction.
/// </param>
/// <param name="functionType">
/// The function Type.
/// </param>
/// <param name="operationName">
/// The operation Name.
/// </param>
/// <param name="parameters">
/// The parameters.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
protected override bool RunOperation(
SqlConnection sqlConnection,
IDbTransaction transaction,
DBFunctionType functionType,
string operationName,
IEnumerable <KeyValuePair <string, object> > parameters,
out object result)
{
// find operation...
var method = this.Methods.FirstOrDefault(
x => string.Equals(x.Key.Name, operationName, StringComparison.OrdinalIgnoreCase));
if (method.IsDefault())
{
result = null;
return(false);
}
var mappedParameters = new List <object>();
var globalParams = new Dictionary <Type, object>
{
{ typeof(IDbTransaction), transaction },
{ typeof(SqlConnection), sqlConnection },
{ typeof(DBFunctionType), functionType },
{ typeof(IDbAccess), this.DbAccess }
};
var incomingParameters = parameters.ToList();
var incomingIndex = 0;
// match up parameters...
method.Value.ForEach(param =>
{
var global = globalParams.FirstOrDefault(p => p.Key == param.ParameterType);
if (global.IsNotDefault())
{
mappedParameters.Add(global.Value);
return;
}
var param1 = param;
var matchedNameParam = incomingParameters.FirstOrDefault(x => x.Key == param1.Name);
if (matchedNameParam.IsNotDefault())
{
// use this named parameter...
mappedParameters.Add(matchedNameParam.Value);
}
else if (incomingIndex < incomingParameters.Count)
{
// just use the indexed value of...
mappedParameters.Add(incomingParameters[incomingIndex++].Value);
}
});
// execute the method...
result = method.Key.Invoke(null, mappedParameters.ToArray());
return(true);
}
