/// <summary>
/// Query datas
/// </summary>
/// <typeparam name="T">Data type</typeparam>
/// <param name="server">Database server</param>
/// <param name="command">Command</param>
/// <returns>Return datas</returns>
public async Task <IEnumerable <T> > QueryAsync <T>(DatabaseServer server, ICommand command)
{
if (command.Query == null)
{
throw new EZNEWException("ICommand.Query is null");
}
#region query translate
IQueryTranslator translator = MySqlFactory.GetQueryTranslator(server);
var tranResult = translator.Translate(command.Query);
string joinScript = tranResult.AllowJoin ? tranResult.JoinScript : string.Empty;
#endregion
#region script
string cmdText;
switch (command.Query.QueryType)
{
case QueryCommandType.Text:
cmdText = tranResult.ConditionString;
break;
case QueryCommandType.QueryObject:
default:
int size = command.Query.QuerySize;
string objectName = DataManager.GetEntityObjectName(DatabaseServerType.MySQL, command.EntityType, command.ObjectName);
cmdText = $"{tranResult.PreScript}SELECT {string.Join(",", FormatQueryFields(translator.ObjectPetName, command.Query, command.EntityType, out var defaultFieldName))} FROM `{objectName}` AS {translator.ObjectPetName} {joinScript} {(string.IsNullOrWhiteSpace(tranResult.ConditionString) ? string.Empty : $"WHERE {tranResult.ConditionString}")} {(string.IsNullOrWhiteSpace(tranResult.OrderString) ? string.Empty : $"ORDER BY {tranResult.OrderString}")} {(size > 0 ? $"LIMIT 0,{size}" : string.Empty)}";
break;
}
/// <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>
/// 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));
}
