/// <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, DatabaseFunctionType 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, DatabaseFunctionType 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(DatabaseFunctionType 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( DatabaseFunctionType 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="functionType"> /// The function Type. /// </param> /// <param name="operationName"> /// The operation name. /// </param> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="data"> /// The data. /// </param> public void Run(DatabaseFunctionType functionType, string operationName, IEnumerable <KeyValuePair <string, object> > parameters, object data) { if (!this.ServiceLocator.IsBoardContext() || !this.styledNickOperations.Contains(operationName.ToLower()) || functionType != DatabaseFunctionType.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( DatabaseFunctionType 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, DatabaseFunctionType 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(DatabaseFunctionType), 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); }