/// <summary>
/// execute command
/// </summary>
/// <param name="executeOption">execute option</param>
/// <param name="cmds">commands</param>
/// <returns>date numbers </returns>
public async Task <int> ExecuteAsync(CommandExecuteOption executeOption, params ICommand[] cmds)
{
if (cmds.IsNullOrEmpty())
{
return(0);
}
Dictionary <string, List <ICommand> > commandGroup = new Dictionary <string, List <ICommand> >();
Dictionary <string, ServerInfo> serverInfos = new Dictionary <string, ServerInfo>();
#region get database servers
foreach (var cmd in cmds)
{
var servers = await GetServerAsync(cmd).ConfigureAwait(false);
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 engine
IEnumerable <ServerType> serverTypeList = serverInfos.Values.Select(c => c.ServerType).Distinct();
VerifyServerEngine(serverTypeList.ToArray());
#endregion
#region execute commands
int totalVal = 0;
foreach (var cmdGroup in commandGroup)
{
ServerInfo serverInfo = serverInfos[cmdGroup.Key];
IDbEngine engine = DataManager.DbEngines[serverInfo.ServerType];
totalVal += await engine.ExecuteAsync(serverInfo, executeOption, cmdGroup.Value.ToArray()).ConfigureAwait(false);
}
return(totalVal);
#endregion
}
/// <summary>
/// Execute commands
/// </summary>
/// <param name="server">Database server</param>
/// <param name="executeCommands">Execute commands</param>
/// <param name="useTransaction">Use transaction</param>
/// <returns>Return effected data numbers</returns>
async Task <int> ExecuteCommandAsync(DatabaseServer server, CommandExecuteOption executeOption, IEnumerable <DatabaseExecuteCommand> executeCommands, bool useTransaction)
{
int resultValue = 0;
bool success = true;
using (var conn = MySqlFactory.GetConnection(server))
{
IDbTransaction transaction = null;
if (useTransaction)
{
transaction = GetExecuteTransaction(conn, executeOption);
}
try
{
foreach (var cmd in executeCommands)
{
var cmdDefinition = new CommandDefinition(cmd.CommandText, 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></returns>
IDbTransaction GetExecuteTransaction(IDbConnection connection, CommandExecuteOption executeOption)
{
DataIsolationLevel?dataIsolationLevel = executeOption?.IsolationLevel;
if (!dataIsolationLevel.HasValue)
{
dataIsolationLevel = DataManager.GetServerDataIsolationLevel(ServerType.MySQL);
}
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>
/// <typeparam name="T">data type</typeparam>
/// <param name="server">server</param>
/// <param name="executeOption">execute option</param>
/// <param name="cmds">command</param>
/// <returns>data numbers</returns>
public async Task <int> ExecuteAsync(ServerInfo server, CommandExecuteOption executeOption, params ICommand[] cmds)
{
#region group execute commands
IQueryTranslator translator = QueryTranslator.GetTranslator(server);
List <DbExecuteCommand> executeCommands = new List <DbExecuteCommand>();
var batchExecuteConfig = DataManager.GetBatchExecuteConfig(server.ServerType) ?? BatchExecuteConfig.Default;
var groupStatementsCount = batchExecuteConfig.GroupStatementsCount;
groupStatementsCount = groupStatementsCount < 0 ? 1 : groupStatementsCount;
var groupParameterCount = batchExecuteConfig.GroupParametersCount;
groupParameterCount = groupParameterCount < 0 ? 1 : groupParameterCount;
StringBuilder commandTextBuilder = new StringBuilder();
CmdParameters parameters = null;
int statementsCount = 0;
bool forceReturnValue = false;
foreach (var cmd in cmds)
{
DbExecuteCommand executeCommand = GetExecuteDbCommand(translator, cmd as RdbCommand);
if (executeCommand == null)
{
continue;
}
if (executeCommand.PerformAlone)
{
if (statementsCount > 0)
{
executeCommands.Add(new DbExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = true,
Parameters = parameters
});
statementsCount = 0;
translator.ParameterSequence = 0;
commandTextBuilder.Clear();
parameters = null;
}
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(new DbExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = true,
Parameters = parameters
});
statementsCount = 0;
translator.ParameterSequence = 0;
commandTextBuilder.Clear();
parameters = null;
}
}
if (statementsCount > 0)
{
executeCommands.Add(new DbExecuteCommand()
{
CommandText = commandTextBuilder.ToString(),
CommandType = CommandType.Text,
ForceReturnValue = true,
Parameters = parameters
});
}
#endregion
return(await ExecuteCommandAsync(server, executeOption, executeCommands, executeOption?.ExecuteByTransaction ?? cmds.Length > 1).ConfigureAwait(false));
}
/// <summary>
/// execute command
/// </summary>
/// <typeparam name="T">data type</typeparam>
/// <param name="server">server</param>
/// <param name="executeOption">execute option</param>
/// <param name="cmds">command</param>
/// <returns>data numbers</returns>
public int Execute(ServerInfo server, CommandExecuteOption executeOption, params ICommand[] cmds)
{
return(ExecuteAsync(server, executeOption, cmds).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(CommandExecuteOption 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 engine
IEnumerable <DatabaseServerType> serverTypeList = serverInfos.Values.Select(c => c.ServerType).Distinct();
VerifyServerEngine(serverTypeList);
#endregion
#region Execute commands
//Single database server
if (commandGroup.Count == 1)
{
var firstGroup = commandGroup.First();
var databaseServer = serverInfos[firstGroup.Key];
var engine = DataManager.GetDatabaseEngine(databaseServer.ServerType);
return(await engine.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 engine = DataManager.GetDatabaseEngine(databaseServer.ServerType);
executeTasks[groupIndex] = engine.ExecuteAsync(databaseServer, executeOption, cmdGroup.Value);
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(CommandExecuteOption 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(CommandExecuteOption 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(CommandExecuteOption executeOption, params ICommand[] commands)
{
IEnumerable <ICommand> cmdCollection = commands;
return(await ExecuteAsync(executeOption, cmdCollection).ConfigureAwait(false));
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="server">Database server</param>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effected data numbers</returns>
public async Task <int> ExecuteAsync(DatabaseServer server, CommandExecuteOption executeOption, IEnumerable <ICommand> commands)
{
#region group execute commands
IQueryTranslator translator = MySqlFactory.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
MySqlFactory.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">Database server</param>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effected data numbers</returns>
public int Execute(DatabaseServer server, CommandExecuteOption executeOption, params ICommand[] commands)
{
return(ExecuteAsync(server, executeOption, commands).Result);
}
/// <summary>
/// Execute command
/// </summary>
/// <param name="server">Database server</param>
/// <param name="executeOption">Execute option</param>
/// <param name="commands">Commands</param>
/// <returns>Return effected data numbers</returns>
public int Execute(DatabaseServer server, CommandExecuteOption executeOption, IEnumerable <ICommand> commands)
{
return(ExecuteAsync(server, executeOption, commands).Result);
}
