/// <summary>
/// Executa uma procedure no sistema.
/// </summary>
/// <param name="queryInfo">Informações da procedure.</param>
/// <returns>Resultado da consulta.</returns>
protected override IQueryResult ExecuteStoredProcedure(QueryInfo queryInfo)
{
var group = new QueryExecutionGroup(ProviderLocator.GetProviderName(queryInfo), queryInfo.IsolationLevel);
GDASession session = CreateSession(group);
try
{
if (!queryInfo.IgnoreRegisterUserInfo)
{
RegisterUserInfo(new GDAStoredProcedureTransaction(session, group.ProviderName));
}
RegisterSession(session);
var result = ExecuteStoredProcedure(session, queryInfo);
if (result != null)
{
EventHandler methodHandler = null;
methodHandler = new EventHandler((sender, e) => {
result.Disposed -= methodHandler;
if (session is GDATransaction)
{
((GDATransaction)session).Commit();
}
session.Dispose();
});
result.Disposed += methodHandler;
return(result);
}
}
catch
{
if (session is GDATransaction)
{
((GDATransaction)session).Rollback();
}
session.Dispose();
throw;
}
if (session is GDATransaction)
{
((GDATransaction)session).Commit();
}
session.Dispose();
return(null);
}
/// <summary>
/// Cria uma sessão de persistencia para o grupo de execução.
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
protected override GDA.GDASession CreateSession(QueryExecutionGroup group)
{
var providerConfiguration = GDA.GDASettings.GetProviderConfiguration(group.ProviderName);
var session = new GDA.GDASession(providerConfiguration);
var isolationLevel = group.IsolationLevel;
if (isolationLevel == System.Transactions.IsolationLevel.Unspecified)
{
isolationLevel = System.Transactions.IsolationLevel.ReadUncommitted;
}
string command = null;
switch (isolationLevel)
{
case System.Transactions.IsolationLevel.ReadUncommitted:
command = "READ UNCOMMITTED";
break;
case System.Transactions.IsolationLevel.ReadCommitted:
command = "READ COMMITTED";
break;
case System.Transactions.IsolationLevel.RepeatableRead:
command = "REPEATABLE READ";
break;
case System.Transactions.IsolationLevel.Serializable:
command = "SERIALIZABLE";
break;
case System.Transactions.IsolationLevel.Snapshot:
command = "SNAPSHOT";
break;
}
if (!string.IsNullOrEmpty(command))
{
command = "SET TRANSACTION ISOLATION LEVEL " + command;
new GDA.DataAccess().ExecuteCommand(session, System.Data.CommandType.Text, 30, command);
}
return(session);
}
/// <summary>
/// Cria a sessão de conexão com base no dados do grupo de execução.
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
protected virtual GDASession CreateSession(QueryExecutionGroup group)
{
IProviderConfiguration providerConfiguration = null;
if (string.IsNullOrEmpty(group.ProviderName))
{
providerConfiguration = GDASettings.DefaultProviderConfiguration;
}
else
{
providerConfiguration = GDASettings.GetProviderConfiguration(group.ProviderName);
}
if (group.IsolationLevel == System.Transactions.IsolationLevel.Unspecified)
{
return(new GDASession(providerConfiguration));
}
else
{
var transaction = new GDATransaction(providerConfiguration, Convert(group.IsolationLevel));
transaction.BeginTransaction();
return(transaction);
}
}
/// <summary>
/// Executa as várias consultas.
/// </summary>
/// <param name="queries"></param>
/// <returns></returns>
public override IEnumerable <IQueryResult> Execute(QueryInfo[] queries)
{
queries.Require("queries").NotNull();
var result = new IQueryResult[queries.Length];
Dictionary <QueryExecutionGroup, IList <int> > providerDictionary = new Dictionary <QueryExecutionGroup, IList <int> >(QueryExecutionGroup.Comparer);
for (int i = 0; i < queries.Length; i++)
{
string providerName = ProviderLocator.GetProviderName(queries[i]);
var group = new QueryExecutionGroup(providerName, queries[i].IsolationLevel);
IList <int> indexes;
if (providerDictionary.TryGetValue(group, out indexes))
{
indexes.Add(i);
}
else
{
indexes = new List <int>();
indexes.Add(i);
providerDictionary.Add(group, indexes);
}
}
IStoredProcedureTransaction storedProcedureTransaction = null;
foreach (var provider in providerDictionary)
{
using (var session = CreateSession(provider.Key))
{
RegisterSession(session);
foreach (var index in provider.Value)
{
IQueryResult queryResult = null;
try
{
if (queries[index].StoredProcedureName == null)
{
SqlQueryParser parser = CreateParser(queries[index]);
string queryString = parser.GetText();
try
{
queryResult = ExecuteQuery(session, queryString, queries[index]);
}
catch (GDAException ex)
{
throw new GDAException(string.Format("{0}. Query: {1}", ex.Message, queries[index].ToString()), ex.InnerException);
}
}
else
{
if (storedProcedureTransaction == null)
{
storedProcedureTransaction = new GDAStoredProcedureTransaction(session, provider.Key.ProviderName);
if (!queries[index].IgnoreRegisterUserInfo)
{
RegisterUserInfo(storedProcedureTransaction);
}
}
queryResult = ExecuteStoredProcedure(session, queries[index]);
}
}
catch
{
if (session is GDATransaction)
{
((GDATransaction)session).Rollback();
}
throw;
}
yield return(queryResult);
}
if (session is GDATransaction)
{
((GDATransaction)session).Commit();
}
}
}
}
