/// <summary>
/// Execute commands
/// </summary>
/// <param name="server">db server</param>
/// <param name="executeCommands">execute commands</param>
/// <param name="useTransaction">use transaction</param>
/// <returns>Return effect data numbers</returns>
async Task <int> ExecuteCommandAsync(DatabaseServer server, CommandExecuteOptions executeOption, IEnumerable <DatabaseExecuteCommand> executeCommands, bool useTransaction)
{
int resultValue = 0;
bool success = true;
using (var conn = SqlServerFactory.GetConnection(server))
{
IDbTransaction transaction = null;
if (useTransaction)
{
transaction = SqlServerFactory.GetExecuteTransaction(conn, executeOption);
}
try
{
foreach (var cmd in executeCommands)
{
var cmdDefinition = new CommandDefinition(cmd.CommandText, SqlServerFactory.ConvertCmdParameters(cmd.Parameters), transaction: transaction, commandType: cmd.CommandType, cancellationToken: executeOption?.CancellationToken ?? default);
var executeResultValue = await conn.ExecuteAsync(cmdDefinition).ConfigureAwait(false);
success = success && (cmd.ForceReturnValue ? executeResultValue > 0 : true);
resultValue += executeResultValue;
if (useTransaction && !success)
{
break;
}
}
if (!useTransaction)
{
return(resultValue);
}
if (success)
{
transaction.Commit();
}
else
{
resultValue = 0;
transaction.Rollback();
}
return(resultValue);
}
catch (Exception ex)
{
resultValue = 0;
transaction?.Rollback();
throw ex;
}
}
}
/// <summary>
/// Get execute transaction
/// </summary>
/// <param name="connection">Connection</param>
/// <param name="executeOption">Execute option</param>
/// <returns>Return database transaction</returns>
public static IDbTransaction GetExecuteTransaction(IDbConnection connection, CommandExecuteOptions executeOption)
{
DataIsolationLevel?dataIsolationLevel = executeOption?.IsolationLevel;
if (!dataIsolationLevel.HasValue)
{
dataIsolationLevel = DataManager.GetDataIsolationLevel(DatabaseServerType.SQLServer);
}
var systemIsolationLevel = DataManager.GetSystemIsolationLevel(dataIsolationLevel);
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
return(systemIsolationLevel.HasValue ? connection.BeginTransaction(systemIsolationLevel.Value) : connection.BeginTransaction());
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public async Task <int> ExecuteAsync(CommandExecuteOptions executeOption, IEnumerable <ICommand> commands)
{
if (commands.IsNullOrEmpty())
{
return(0);
}
Dictionary <string, List <ICommand> > commandGroup = new Dictionary <string, List <ICommand> >();
Dictionary <string, DatabaseServer> serverInfos = new Dictionary <string, DatabaseServer>();
#region Get database servers
foreach (var cmd in commands)
{
var servers = GetServers(cmd);
foreach (var server in servers)
{
string serverKey = server.Key;
if (serverInfos.ContainsKey(serverKey))
{
commandGroup[serverKey].Add(cmd);
}
else
{
commandGroup.Add(serverKey, new List <ICommand>()
{
cmd
});
serverInfos.Add(serverKey, server);
}
}
}
#endregion
#region Verify database server provider
IEnumerable <DatabaseServerType> serverTypeList = serverInfos.Values.Select(c => c.ServerType).Distinct();
VerifyServerProvider(serverTypeList);
#endregion
#region Execute commands
//Single database server
if (commandGroup.Count == 1)
{
var firstGroup = commandGroup.First();
var databaseServer = serverInfos[firstGroup.Key];
var provider = DataManager.GetDatabaseProvider(databaseServer.ServerType);
return(await provider.ExecuteAsync(databaseServer, executeOption, firstGroup.Value).ConfigureAwait(false));
}
//Multiple database server
Task <int>[] executeTasks = new Task <int> [commandGroup.Count];
int groupIndex = 0;
foreach (var cmdGroup in commandGroup)
{
var databaseServer = serverInfos[cmdGroup.Key];
var provider = DataManager.GetDatabaseProvider(databaseServer.ServerType);
executeTasks[groupIndex] = provider.ExecuteAsync(databaseServer, executeOption, cmdGroup.Value.Select(c => c.Clone()));
groupIndex++;
}
return((await Task.WhenAll(executeTasks).ConfigureAwait(false)).Sum());
#endregion
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public int Execute(CommandExecuteOptions executeOption, params ICommand[] commands)
{
return(ExecuteAsync(executeOption, commands).Result);
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public int Execute(CommandExecuteOptions executeOption, IEnumerable <ICommand> commands)
{
return(ExecuteAsync(executeOption, commands).Result);
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public async Task <int> ExecuteAsync(CommandExecuteOptions executeOption, params ICommand[] commands)
{
IEnumerable <ICommand> cmdCollection = commands;
return(await ExecuteAsync(executeOption, cmdCollection).ConfigureAwait(false));
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="server">Server</param>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public async Task <int> ExecuteAsync(DatabaseServer server, CommandExecuteOptions executeOption, IEnumerable <ICommand> commands)
{
#region group execute commands
IQueryTranslator translator = SqlServerFactory.GetQueryTranslator(server);
List <DatabaseExecuteCommand> executeCommands = new List <DatabaseExecuteCommand>();
var batchExecuteConfig = DataManager.GetBatchExecuteConfiguration(server.ServerType) ?? BatchExecuteConfiguration.Default;
var groupStatementsCount = batchExecuteConfig.GroupStatementsCount;
groupStatementsCount = groupStatementsCount < 0 ? 1 : groupStatementsCount;
var groupParameterCount = batchExecuteConfig.GroupParametersCount;
groupParameterCount = groupParameterCount < 0 ? 1 : groupParameterCount;
StringBuilder commandTextBuilder = new StringBuilder();
CommandParameters parameters = null;
int statementsCount = 0;
bool forceReturnValue = false;
int cmdCount = 0;
DatabaseExecuteCommand GetGroupExecuteCommand()
{
var executeCommand = new DatabaseExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = forceReturnValue,
Parameters = parameters
};
statementsCount = 0;
translator.ParameterSequence = 0;
commandTextBuilder.Clear();
parameters = null;
forceReturnValue = false;
return(executeCommand);
}
foreach (var cmd in commands)
{
DatabaseExecuteCommand executeCommand = GetExecuteDbCommand(translator, cmd as RdbCommand);
if (executeCommand == null)
{
continue;
}
//Trace log
SqlServerFactory.LogExecuteCommand(executeCommand);
cmdCount++;
if (executeCommand.PerformAlone)
{
if (statementsCount > 0)
{
executeCommands.Add(GetGroupExecuteCommand());
}
executeCommands.Add(executeCommand);
continue;
}
commandTextBuilder.AppendLine(executeCommand.CommandText);
parameters = parameters == null ? executeCommand.Parameters : parameters.Union(executeCommand.Parameters);
forceReturnValue |= executeCommand.ForceReturnValue;
statementsCount++;
if (translator.ParameterSequence >= groupParameterCount || statementsCount >= groupStatementsCount)
{
executeCommands.Add(GetGroupExecuteCommand());
}
}
if (statementsCount > 0)
{
executeCommands.Add(GetGroupExecuteCommand());
}
#endregion
return(await ExecuteCommandAsync(server, executeOption, executeCommands, executeOption?.ExecuteByTransaction ?? cmdCount > 1).ConfigureAwait(false));
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="server">Server</param>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public int Execute(DatabaseServer server, CommandExecuteOptions executeOption, params ICommand[] commands)
{
return(ExecuteAsync(server, executeOption, commands).Result);
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="server">Server</param>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effect data numbers</returns>
public int Execute(DatabaseServer server, CommandExecuteOptions executeOption, IEnumerable <ICommand> commands)
{
return(ExecuteAsync(server, executeOption, commands).Result);
}
