/// <summary>
/// Retorna o parâmetro correspondente a chave primária
/// </summary>
/// <param name="transaction">Transação.</param>
/// <param name="entityName">Nome da entidade</param>
/// <returns>Pâremetro correspondente a chave primária</returns>
public object GetPrimaryKey(IPersistenceTransactionExecuter transaction, string entityName)
{
var metadata = _typeSchema.GetTypeMetadata(entityName);
var identityMetadata = metadata.GetKeyProperties().FirstOrDefault();
GDAStoredProcedure procedure = new GDAStoredProcedure("control.GetIdentityProcedure");
procedure.AddParameter("?schemaname", metadata.TableName.Schema);
procedure.AddParameter("?tablename", metadata.TableName.Name);
procedure.AddParameter("?columnname", identityMetadata.ColumnName);
using (GDASession session = new GDASession(GDASettings.GetProviderConfiguration(ProviderName)))
{
var da = new DataAccess();
return(da.ExecuteScalar(session, procedure));
}
}
/// <summary>
/// Registra as informações do usuário.
/// </summary>
/// <param name="transaction"></param>
protected override void RegisterUserInfo(IPersistenceTransactionExecuter transaction)
{
var trans2 = ((PersistenceTransactionExecuter)transaction).Transaction;
var dataAccess = new DataAccess(trans2.ProviderConfiguration);
dataAccess.ExecuteCommand(trans2, "ALTER SESSION SET NLS_SORT=BINARY_CI");
dataAccess.ExecuteCommand(trans2, "ALTER SESSION SET NLS_COMP=LINGUISTIC");
var profile = Security.Profile.ProfileManager.CurrentProfileInfo;
var user = Security.UserContext.Current.User;
if (profile != null && user != null)
{
var parameters = new GDAParameter[] {
new GDAParameter("?profileId", profile.ProfileId),
new GDAParameter("?userKey", int.Parse(user.UserKey))
};
var command = new StringBuilder().AppendLine("DECLARE").AppendLine("v_exists NUMBER := 0;").AppendLine("BEGIN").AppendLine("SELECT COUNT(*) INTO v_exists FROM sys.all_tables WHERE OWNER = 'SECURITY' AND TABLE_NAME = 'USERINFO' AND TEMPORARY = 'Y';").AppendLine("IF v_exists = 0 THEN").AppendLine("EXECUTE IMMEDIATE 'CREATE GLOBAL TEMPORARY TABLE \"SECURITY\".\"USERINFO\"(\"PROFILEID\" NUMBER(9), \"USERID\" NUMBER(9)) ON COMMIT DELETE ROWS';").AppendLine("ELSE").AppendLine("DELETE FROM \"SECURITY\".\"USERINFO\";").AppendLine("END IF;").AppendLine("INSERT INTO \"SECURITY\".\"USERINFO\"(\"PROFILEID\", \"USERID\") VALUES(?profileId, ?userKey);").AppendLine("END;");
dataAccess.ExecuteCommand(trans2, command.ToString(), parameters);
}
}
/// <summary>
/// Retorna o parâmetro correspondente a chave primária
/// </summary>
/// <param name="transaction"></param>
/// <param name="entityName">Nome da entidade</param>
/// <returns>Pâremetro correspondente a chave primária</returns>
public object GetPrimaryKey(IPersistenceTransactionExecuter transaction, string entityName)
{
var metadata = _typeSchema.GetTypeMetadata(entityName);
var identityMetadata = metadata.GetKeyProperties().FirstOrDefault();
using (var session = new GDASession(GDASettings.GetProviderConfiguration(ProviderName)))
{
DataAccess da = session != null ? new DataAccess(session.ProviderConfiguration) : new DataAccess();
var indexes = new List <int>();
var script = "BEGIN \"CONTROL\".\"GETIDENTITY\"(:1,:2,:3,:4); END;";
var parameters = new GDA.Collections.GDAParameterCollection();
parameters.Add(new GDAParameter(":1", metadata.TableName.Schema, System.Data.ParameterDirection.Input));
parameters.Add(new GDAParameter(":2", metadata.TableName.Name, System.Data.ParameterDirection.Input));
parameters.Add(new GDAParameter(":3", identityMetadata.ColumnName, System.Data.ParameterDirection.Input));
var resultParameter = new GDAParameter(":4", null)
{
DbType = System.Data.DbType.Int32,
Direction = System.Data.ParameterDirection.Output
};
parameters.Add(resultParameter);
da.ExecuteCommand(session, script, parameters.ToArray());
return(resultParameter.Value);
}
}
/// <summary>
/// Recupera as propriedades volatéis.
/// </summary>
/// <param name="actions">Ações de persistência.</param>
/// <param name="actionResult">resultado das ações de persistência.</param>
/// <param name="transaction">Transação usada na execução.</param>
protected virtual void RetrievePersistenceVolatileProperties(PersistenceAction[] actions, PersistenceActionResult[] actionResult, IPersistenceTransactionExecuter transaction)
{
}
/// <summary>
/// Configura a transação.
/// </summary>
/// <param name="transaction"></param>
protected virtual void ConfigureTransaction(IPersistenceTransactionExecuter transaction)
{
}
/// <summary> /// Registra as informações do usuário no banco de dados. /// </summary> protected abstract void RegisterUserInfo(IPersistenceTransactionExecuter transaction);
/// <summary> /// Executa uma ação de persistência no banco de dados /// </summary> /// <param name="commandText">Texto do comando a ser executado</param> /// <param name="action">Ação a ser executada</param> /// <param name="transaction">Objeto de transação</param> /// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param> /// <returns>Retorna resultado da ação de persistência</returns> protected abstract PersistenceActionResult ExecuteCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings);
/// <summary>
/// Executa as ações sobre a transação informada.
/// </summary>
/// <param name="actions">Ações que serão executadas.</param>
/// <param name="executionType">Tipo de execução.</param>
/// <param name="transaction">Transação que será utilizada.</param>
/// <param name="primaryKeyMappings">Mapeamentos das chaves primárias.</param>
/// <param name="alternatives"></param>
/// <param name="existsErrors"></param>
/// <returns></returns>
protected PersistenceActionResult[] Execute(PersistenceAction[] actions, ExecutionType executionType, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings, List <Tuple <int, PersistenceActionResult> > alternatives, out bool existsErrors)
{
var result = new PersistenceActionResult[actions.Length];
existsErrors = false;
for (int i = 0; i < actions.Length; i++)
{
PersistenceActionResult[] beforeActions = null;
try
{
string actionCommandText = null;
if (actions[i].Type != PersistenceActionType.ExecuteProcedure)
{
var parser = CreateParser(actions[i], transaction.ProviderName);
actionCommandText = parser.GetPersistenceCommandText();
if (actions[i].Conditional == null)
{
SwapIds(actions[i], primaryKeyMappings);
GetId(actions[i], primaryKeyMappings, transaction.ProviderName, transaction);
}
}
SwapNewUidReferences(actions[i], primaryKeyMappings);
if (actions[i].BeforeActions.Count > 0)
{
var existsErrors2 = false;
beforeActions = Execute(actions[i].BeforeActions.ToArray(), executionType, transaction, primaryKeyMappings, alternatives, out existsErrors2);
if (existsErrors2)
{
existsErrors = true;
}
if (existsErrors2 && executionType == ExecutionType.Default)
{
result[i] = new PersistenceActionResult {
Success = false,
BeforeActions = beforeActions
};
break;
}
}
PersistenceActionResult commandResult = null;
var alternative = alternatives.Where(f => f.Item1 == actions[i].ActionId).FirstOrDefault();
if (alternative != null)
{
commandResult = result[i] = alternative.Item2;
var existsErrors2 = false;
commandResult.AlternativeActions = Execute(actions[i].AlternativeActions.ToArray(), executionType, transaction, primaryKeyMappings, alternatives, out existsErrors2);
if (existsErrors2)
{
existsErrors = true;
}
else
{
commandResult.FailureMessage = null;
}
commandResult.Success = !existsErrors2;
if (existsErrors2 && executionType == ExecutionType.Default)
{
break;
}
}
else
{
try
{
commandResult = result[i] = ExecuteCommand(actionCommandText, actions[i], transaction, primaryKeyMappings);
}
catch (Exception ex)
{
existsErrors = true;
result[i] = new PersistenceActionResult()
{
BeforeActions = beforeActions ?? new PersistenceActionResult[0],
FailureMessage = ex.Message,
Success = false
};
if (actions[i].AlternativeActions.Count > 0 && !alternatives.Where(f => f.Item1 == actions[i].ActionId).Any())
{
alternatives.Add(new Tuple <int, PersistenceActionResult>(actions[i].ActionId, result[i]));
}
if (executionType == ExecutionType.Default)
{
break;
}
continue;
}
}
commandResult.BeforeActions = beforeActions;
if (!commandResult.Success)
{
existsErrors = true;
if (actions[i].AlternativeActions.Count > 0)
{
if (!alternatives.Where(f => f.Item1 == actions[i].ActionId).Any())
{
alternatives.Add(new Tuple <int, PersistenceActionResult>(actions[i].ActionId, result[i]));
}
}
if (executionType == ExecutionType.Default)
{
break;
}
continue;
}
if (actions[i].AfterActions.Count > 0)
{
var existsErrors2 = false;
commandResult.AfterActions = Execute(actions[i].AfterActions.ToArray(), executionType, transaction, primaryKeyMappings, alternatives, out existsErrors2);
if (existsErrors2)
{
existsErrors = true;
}
commandResult.Success = !existsErrors2;
var failureAction = commandResult.AfterActions.Where(f => !f.Success).FirstOrDefault();
if (failureAction != null)
{
commandResult.Success = false;
}
if (existsErrors2 && executionType == ExecutionType.Default)
{
break;
}
}
}
catch (Exception ex)
{
existsErrors = true;
result[i] = new PersistenceActionResult()
{
BeforeActions = beforeActions ?? new PersistenceActionResult[0],
FailureMessage = ex.Message,
Success = false
};
if (executionType == ExecutionType.Default)
{
break;
}
}
}
if (actions.Length != result.Length)
{
existsErrors = true;
for (var i = 0; i < actions.Length; i++)
{
result[i] = new PersistenceActionResult()
{
FailureMessage = "Invalid result length for actions",
Success = false
}
}
;
}
if (!existsErrors)
{
transaction.Commited += (sender, e) => {
RetrievePersistenceVolatileProperties(actions, result, transaction);
}
}
;
return(result);
}
/// <summary>
/// Configura a transação.
/// </summary>
/// <param name="transaction"></param>
protected override void ConfigureTransaction(IPersistenceTransactionExecuter transaction)
{
base.ConfigureTransaction(transaction);
}
/// <summary>
/// Executa um comando de delete no banco de dados.
/// </summary>
/// <param name="commandText">Texto do comando a ser executado.</param>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação do comando.</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected virtual PersistenceActionResult ExecuteDeleteCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
var trans = (PersistenceTransactionExecuter)transaction;
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
bool hasRowVersion = typeMetadata.IsVersioned && (action.Conditional == null);
var actionParameters = action.Parameters.Where(f => !(f.Value is PropertyReference || f.Value is ExpressionParameter || f.Value is QueryInfo || f.Value is Colosoft.Query.Queryable));
var conditionalParameters = action.Conditional != null?action.Conditional.Where(f => !(f.Value is PropertyReference || f.Value is ExpressionParameter || f.Value is QueryInfo || f.Value is Colosoft.Query.Queryable) && !actionParameters.Any(x => x.Name == f.Name)).ToArray() : new QueryParameter[0];
int parameterCount = conditionalParameters.Where(f => !actionParameters.Any(x => x.Name == f.Name)).Count() + actionParameters.Count();
if (hasRowVersion)
{
parameterCount++;
}
var parameters = new GDAParameter[parameterCount];
var index = 0;
if (action.Conditional == null)
{
foreach (var actionParameter in actionParameters)
{
var propertyMetadata = typeMetadata[actionParameter.Name];
if (propertyMetadata == null)
{
parameters[index++] = CreateParameter(!string.IsNullOrEmpty(actionParameter.Name) && actionParameter.Name.StartsWith("?") ? actionParameter.Name : '?' + actionParameter.Name, actionParameter.Value);
}
else
{
parameters[index++] = CreateParameter('?' + propertyMetadata.Name, actionParameter.Value);
}
}
}
else
{
foreach (var param in conditionalParameters.Where(f => !actionParameters.Any(x => x.Name == f.Name)))
{
parameters[index] = CreateParameter(param.Name, param.Value);
index++;
}
foreach (var param in actionParameters)
{
parameters[index] = CreateParameter(param.Name, param.Value);
index++;
}
}
if (hasRowVersion)
{
parameters[index] = CreateParameter('?' + DataAccessConstants.RowVersionPropertyName, action.RowVersion, 0, (System.Data.ParameterDirection)((int)Colosoft.Query.ParameterDirection.InputOutput));
}
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
int affectedRows = 0;
try
{
affectedRows = da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, commandText, parameters);
}
catch (GDAException ex)
{
Exception ex2 = ex;
if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException)
{
ex2 = ex.InnerException;
}
ex2 = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2);
action.NotifyError(ex2);
return(new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ex2.Message
});
}
if (affectedRows == 0 && hasRowVersion)
{
return new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.Exception_RowsNotAffected, typeMetadata.FullName, action.RowVersion).Format()
}
}
;
action.NotifyExecution();
var actionResult = new PersistenceActionResult()
{
Success = true,
AffectedRows = affectedRows,
Parameters = action.Parameters.ToArray(),
ActionId = action.ActionId,
RowVersion = (hasRowVersion) ? (long)action.RowVersion : 0
};
return(actionResult);
}
/// <summary>
/// Recupera uma chave para a entidade informada.
/// </summary>
/// <param name="transaction">Transação.</param>
/// <param name="entityName"></param>
/// <returns></returns>
public object GetPrimaryKey(IPersistenceTransactionExecuter transaction, string entityName)
{
var trans = (Colosoft.Data.Database.Generic.PersistenceTransactionExecuter)transaction;
return(new GDA.DataAccess().ExecuteScalar(trans.Transaction, "SELECT LAST_INSERT_ID()"));
}
/// <summary>
/// Executa o comando de exclusão.
/// </summary>
/// <param name="commandText"></param>
/// <param name="action"></param>
/// <param name="transaction"></param>
/// <param name="primaryKeyMappings"></param>
/// <returns></returns>
protected override PersistenceActionResult ExecuteDeleteCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
var trans = (PersistenceTransactionExecuter)transaction;
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
bool hasRowVersion = typeMetadata.IsVersioned && (action.Conditional == null);
int parameterCount = (action.Conditional != null ? action.Conditional.Count() : 0) + action.Parameters.Count;
if (hasRowVersion)
{
parameterCount++;
}
var parameters = new GDAParameter[parameterCount];
var index = 0;
if (action.Conditional == null)
{
for (int i = 0; i < action.Parameters.Count; i++)
{
var propertyMetadata = typeMetadata[action.Parameters[i].Name];
if (propertyMetadata == null)
{
parameters[i] = CreateParameter('?' + action.Parameters[i].Name, action.Parameters[i].Value);
}
else
{
parameters[i] = CreateParameter('?' + propertyMetadata.ColumnName, action.Parameters[i].Value);
}
}
index = action.Parameters.Count;
}
else
{
foreach (var param in action.Conditional)
{
parameters[index] = CreateParameter(param.Name, param.Value);
index++;
}
foreach (var param in action.Parameters)
{
parameters[index] = CreateParameter(param.Name, param.Value);
index++;
}
}
if (hasRowVersion)
{
parameters[index] = CreateParameter('?' + DataAccessConstants.RowVersionPropertyName, action.RowVersion, 0, (System.Data.ParameterDirection)((int)Colosoft.Query.ParameterDirection.InputOutput));
}
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
int affectedRows = 0;
try
{
affectedRows = da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, commandText, parameters);
}
catch (GDAException ex)
{
Exception ex2 = ex;
if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException)
{
ex2 = ex.InnerException;
}
ex2 = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2);
action.NotifyError(ex2);
return(new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ex2.Message
});
}
if (affectedRows == 0 && hasRowVersion)
{
return new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.Exception_RowsNotAffected, typeMetadata.FullName, action.RowVersion).Format()
}
}
;
action.NotifyExecution();
var actionResult = new PersistenceActionResult()
{
Success = true,
AffectedRows = affectedRows,
Parameters = action.Parameters.ToArray(),
ActionId = action.ActionId,
RowVersion = (hasRowVersion) ? (long)action.RowVersion : 0
};
return(actionResult);
}
}
/// <summary>
/// Executa uma procedure no banco de dados.
/// </summary>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação de persistência.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected override PersistenceActionResult ExecuteProcedureCommand(PersistenceAction action, IPersistenceTransactionExecuter transaction)
{
var trans = (PersistenceTransactionExecuter)transaction;
DataAccess da = trans != null ? new DataAccess(trans.Transaction.ProviderConfiguration) : new DataAccess();
var indexes = new List <int>();
var storedProcedureName = (Query.Database.TranslatedStoredProcedureName)Translator.GetName(action.StoredProcedureName);
var script = "BEGIN " + (!string.IsNullOrEmpty(storedProcedureName.Schema) ? string.Format("\"{0}\".\"{1}\"", storedProcedureName.Schema, storedProcedureName.Name) : string.Format("\"{0}\"", storedProcedureName.Name)) + " (";
for (var i = 1; i <= action.Parameters.Count; i++)
{
script += ":" + i + ",";
}
script = (action.Parameters.Count > 0 ? script.Substring(0, script.Length - 1) : script) + "); END;";
var parameters = new GDA.Collections.GDAParameterCollection();
for (int i = 0; i < action.Parameters.Count; i++)
{
var paramDirection = (System.Data.ParameterDirection)((int)action.Parameters[i].Direction);
var value = action.Parameters[i].Value;
parameters.Add(CreateParameter(":" + (i + 1), value, action.Parameters[i].Size, paramDirection));
if (action.Parameters[i].Direction != Query.ParameterDirection.Input)
{
indexes.Add(i);
}
}
var parameters2 = parameters.ToArray();
var result = da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, script, parameters2);
foreach (int index in indexes)
{
action.Parameters[index].Value = parameters2[index].Value;
}
var presult = new PersistenceActionResult()
{
ActionId = action.ActionId,
Parameters = action.Parameters.ToArray(),
Result = result,
Success = true
};
return(presult);
}
/// <summary>
/// Executa um comando de update no banco de dados.
/// </summary>
/// <param name="commandText">Texto do comando a ser executado.</param>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação do comando.</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected override PersistenceActionResult ExecuteUpdateCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
var trans = (PersistenceTransactionExecuter)transaction;
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
bool hasRowVersion = typeMetadata.IsVersioned && (action.Conditional == null);
var actionParameters = action.Parameters.Where(f => !(f.Value is PropertyReference || f.Value is ExpressionParameter || f.Value is QueryInfo || f.Value is Colosoft.Query.Queryable));
var volatileProperties = typeMetadata.GetVolatileProperties().ToArray();
var onlyResultProperties = volatileProperties.Where(f => !action.Parameters.Any(g => g.Name == f.Name)).ToArray();
int parameterCount = actionParameters.Count();
if (action.Conditional != null)
{
parameterCount += action.Conditional.Count();
}
if (action.Query != null)
{
parameterCount += action.Query.Parameters.Count;
}
if (hasRowVersion)
{
parameterCount++;
}
var resultParameters = new PersistenceParameter[action.Parameters.Count + onlyResultProperties.Length];
var parameters = new GDAParameter[parameterCount + 1];
int index = 0;
foreach (var actionParameter in actionParameters)
{
var propertyMetadata = typeMetadata[actionParameter.Name];
if (propertyMetadata == null)
{
parameters[index] = CreateParameter('?' + actionParameter.Name, actionParameter.Value);
}
else
{
parameters[index] = CreateParameter('?' + propertyMetadata.ColumnName, actionParameter.Value);
}
if (actionParameter.DbType != DbType.AnsiString)
{
parameters[index].DbType = actionParameter.DbType;
}
resultParameters[index] = actionParameter;
if (volatileProperties.Any(p => p.Name == actionParameter.Name))
{
parameters[index].Direction = System.Data.ParameterDirection.InputOutput;
}
index++;
}
index = actionParameters.Count();
if (action.Conditional == null)
{
var index2 = index;
foreach (var property in onlyResultProperties)
{
resultParameters[index2++] = new PersistenceParameter(property.Name, string.Empty, Query.ParameterDirection.Output);
}
}
else
{
foreach (var param in action.Conditional)
{
parameters[index++] = CreateParameter(param.Name, param.Value);
}
}
if (action.Query != null)
{
foreach (var param in action.Query.Parameters)
{
parameters[index++] = CreateParameter(param.Name, param.Value);
}
}
if (hasRowVersion)
{
parameters[index++] = CreateParameter('?' + DataAccessConstants.RowVersionPropertyName, action.RowVersion, 0, System.Data.ParameterDirection.Input);
}
parameters[index] = CreateParameter('?' + DataAccessConstants.AffectedRowsParameterName, 0, 0, System.Data.ParameterDirection.Output);
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
try
{
da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, commandText, parameters);
}
catch (GDAException ex)
{
Exception ex2 = ex;
if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException)
{
ex2 = ex.InnerException;
}
ex2 = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2);
action.NotifyError(ex2);
return(new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ex2.Message
});
}
int affectedRows = Convert.ToInt32(parameters[index].Value);
if (affectedRows == 0 && hasRowVersion)
{
return new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ResourceMessageFormatter.Create(() => Database.Generic.Properties.Resources.Exception_RowsNotAffected, typeMetadata.FullName, action.RowVersion).Format(),
}
}
;
var actionResult = new PersistenceActionResult()
{
Success = true,
AffectedRows = affectedRows,
Parameters = resultParameters,
ActionId = action.ActionId,
RowVersion = 0
};
return(actionResult);
}
/// <summary>
/// Executa um comando de insert no banco de dados.
/// </summary>
/// <param name="commandText">Texto do comando a ser executado.</param>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação do comando.</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected override PersistenceActionResult ExecuteInsertCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
var trans = (PersistenceTransactionExecuter)transaction;
bool hasRowVersion = (action.RowVersion != null);
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
var volatileProperties = typeMetadata.GetVolatileProperties().ToArray();
var onlyResultProperties = volatileProperties.Where(f => action.Parameters.Count(g => g.Name == f.Name) == 0);
int onlyResultCount = onlyResultProperties.Count();
var resultParameters = new PersistenceParameter[action.Parameters.Count + onlyResultCount];
var parameters = new GDAParameter[action.Parameters.Count + 1];
bool isPosCommand = GetKeyRepository(trans.ProviderName).IsPosCommand(action.EntityFullName);
IPropertyMetadata identityMetadata = typeMetadata.GetKeyProperties().FirstOrDefault(f => f.ParameterType == Schema.PersistenceParameterType.IdentityKey);
for (int i = 0; i < action.Parameters.Count; i++)
{
var propertyMetadata = typeMetadata[action.Parameters[i].Name];
if (propertyMetadata == null)
{
parameters[i] = CreateParameter('?' + action.Parameters[i].Name, action.Parameters[i].Value);
}
else
{
parameters[i] = CreateParameter('?' + propertyMetadata.ColumnName, action.Parameters[i].Value);
}
if (action.Parameters[i].DbType != DbType.AnsiString)
{
parameters[i].DbType = action.Parameters[i].DbType;
}
resultParameters[i] = action.Parameters[i];
if (isPosCommand && identityMetadata.Name == action.Parameters[i].Name)
{
parameters[i].Direction = System.Data.ParameterDirection.InputOutput;
}
if (volatileProperties.Any(p => p.Name == action.Parameters[i].Name))
{
parameters[i].Direction = System.Data.ParameterDirection.InputOutput;
}
}
int index = action.Parameters.Count;
foreach (var property in onlyResultProperties)
{
resultParameters[index++] = new PersistenceParameter(property.Name, string.Empty);
}
parameters[parameters.Length - 1] = CreateParameter('?' + DataAccessConstants.AffectedRowsParameterName, 0, 0, System.Data.ParameterDirection.Output);
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, commandText, parameters);
int affectedRows = Convert.ToInt32(parameters[parameters.Length - 1].Value);
if (GetKeyRepository(trans.ProviderName).IsPosCommand(action.EntityFullName))
{
if (identityMetadata.ParameterType == Schema.PersistenceParameterType.IdentityKey)
{
for (int i = 0; i < parameters.Length; i++)
{
if (action.Parameters[i].Name == identityMetadata.Name)
{
int identityValue = (int)parameters[i].Value;
int virtualId = (int)action.Parameters[i].Value;
action.Parameters[i].Value = identityValue;
primaryKeyMappings.Add(virtualId, identityValue);
break;
}
}
}
}
var actionResult = new PersistenceActionResult()
{
Success = true,
AffectedRows = affectedRows,
Parameters = resultParameters,
ActionId = action.ActionId,
RowVersion = 0
};
return(actionResult);
}
/// <summary>
/// Recupera as propriedades volatéis.
/// </summary>
/// <param name="actions"></param>
/// <param name="result"></param>
/// <param name="transaction">Transação usada na execução.</param>
protected override void RetrievePersistenceVolatileProperties(PersistenceAction[] actions, PersistenceActionResult[] result, IPersistenceTransactionExecuter transaction)
{
for (int actionIndex = 0; actionIndex < actions.Length; actionIndex++)
{
if (actions[actionIndex].Type == PersistenceActionType.Insert || actions[actionIndex].Type == PersistenceActionType.Update)
{
var action = actions[actionIndex];
var actionResult = result[actionIndex];
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
var volatileProperties = typeMetadata.GetVolatileProperties().ToArray();
if (!typeMetadata.IsVersioned && volatileProperties.Length == 0)
{
continue;
}
var commandText = new StringBuilder();
var keysIndex = new List <Tuple <int, IPropertyMetadata> >();
for (int i = 0; i < action.Parameters.Count; i++)
{
var propertyMetadata = typeMetadata[action.Parameters[i].Name];
if (propertyMetadata.ParameterType == Data.Schema.PersistenceParameterType.IdentityKey || propertyMetadata.ParameterType == Data.Schema.PersistenceParameterType.Key)
{
keysIndex.Add(new Tuple <int, IPropertyMetadata>(i, propertyMetadata));
}
}
if (keysIndex.Count == 0)
{
continue;
}
var parameters = new GDA.Collections.GDAParameterCollection();
bool isFirst = true;
commandText.Append("SELECT ");
var selectCommandText = new StringBuilder();
if (typeMetadata.IsVersioned)
{
selectCommandText.Append("CAST(ORA_ROWSCN AS NUMBER(18,0)) AS ").AppendFormat("\"{0}\"", Query.DataAccessConstants.RowVersionPropertyName);
isFirst = false;
}
foreach (var property in typeMetadata.GetVolatileProperties())
{
if (!isFirst)
{
selectCommandText.Append(", ");
}
isFirst = false;
if (typeMetadata.IsVersioned && property.Name == Query.DataAccessConstants.RowVersionPropertyName)
{
continue;
}
selectCommandText.AppendFormat("\"{0}\" AS \"{1}\"", property.ColumnName.ToUpper(), property.Name);
}
var tableNameTranslatedName = (Query.Database.TranslatedTableName)Translator.GetName(new EntityInfo(action.EntityFullName));
isFirst = true;
commandText.Append(selectCommandText).Append(" FROM ").AppendFormat("\"{0}\".\"{1}\"", tableNameTranslatedName.Schema, tableNameTranslatedName.Name).Append(" WHERE ");
var paramaterCount = 1;
foreach (var i in keysIndex)
{
if (!isFirst)
{
commandText.Append(" AND ");
}
isFirst = false;
var whereParameter = new GDA.GDAParameter("?" + (paramaterCount++), action.Parameters[i.Item1].Value);
parameters.Add(whereParameter);
commandText.AppendFormat("\"{0}\"", i.Item2.ColumnName.ToUpper()).Append("=").Append(whereParameter.ParameterName);
}
var transaction2 = (PersistenceTransactionExecuter)transaction;
var da = new DataAccess(transaction2.Transaction.ProviderConfiguration);
var resultParameters = new List <PersistenceParameter>();
using (var enumerator = da.LoadResult(transaction2.Transaction, commandText.ToString(), parameters.ToArray()).GetEnumerator())
{
if (enumerator.MoveNext())
{
var record = enumerator.Current;
for (var i = 0; i < record.FieldCount; i++)
{
var parameterName = record.GetName(i);
object value = null;
if (record.BaseDataRecord.GetDataTypeName(i) == "TimeStampTZ")
{
#if UNMANAGED
// Recupera o valor do Oracle
var oracleTimeStampTZ = ((global::Oracle.DataAccess.Client.OracleDataReader)record.BaseDataRecord)
.GetOracleTimeStampTZ(i);
#else
var oracleTimeStampTZ = ((global::Oracle.ManagedDataAccess.Client.OracleDataReader)record.BaseDataRecord).GetOracleTimeStampTZ(i);
#endif
value = new DateTimeOffset((DateTime)oracleTimeStampTZ, TimeSpan.Parse(oracleTimeStampTZ.TimeZone == "+00:00" ? "00:00" : oracleTimeStampTZ.TimeZone));
}
else
{
value = record.GetValue(i);
}
resultParameters.Add(new PersistenceParameter(parameterName, value));
if (typeMetadata.IsVersioned && StringComparer.InvariantCultureIgnoreCase.Equals(Query.DataAccessConstants.RowVersionPropertyName, parameterName))
{
try
{
if (value is DBNull || value == null)
{
actionResult.RowVersion = 0;
}
else
{
actionResult.RowVersion = Convert.ToInt64(value);
}
}
catch
{
}
}
}
}
}
if (actionResult.Parameters != null)
{
foreach (var i in actionResult.Parameters)
{
if (!resultParameters.Any(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Name, i.Name)))
{
resultParameters.Add(i);
}
}
}
actionResult.Parameters = resultParameters.ToArray();
}
}
}
/// <summary>
/// Executa uma procedure no banco de dados.
/// </summary>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação de persistência.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected virtual PersistenceActionResult ExecuteProcedureCommand(PersistenceAction action, IPersistenceTransactionExecuter transaction)
{
var trans = (PersistenceTransactionExecuter)transaction;
var outputParametersIndexes = new List <int>();
var procedure = CreateProcedure(action);
if (action.Parameters != null)
{
for (int i = 0; i < action.Parameters.Count; i++)
{
var paramDirection = (System.Data.ParameterDirection)((int)action.Parameters[i].Direction);
procedure.AddParameter(new GDAParameter(action.Parameters[i].Name, action.Parameters[i].Value, paramDirection)
{
Size = action.Parameters[i].Size
});
if (action.Parameters[i].Direction != Colosoft.Query.ParameterDirection.Input)
{
outputParametersIndexes.Add(i);
}
}
}
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
object result = null;
try
{
result = da.ExecuteScalar(trans.Transaction, procedure);
}
catch (GDAException ex)
{
Exception ex2 = ex;
if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException)
{
ex2 = ex.InnerException;
}
ex2 = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2);
action.NotifyError(ex2);
return(new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ex2.Message
});
}
foreach (int index in outputParametersIndexes)
{
action.Parameters[index].Value = procedure[index];
}
action.NotifyExecution();
var presult = new PersistenceActionResult()
{
ActionId = action.ActionId,
Parameters = action.Parameters.ToArray(),
Result = result,
Success = true
};
return(presult);
}
/// <summary>
/// Gera o id em caso de inserção
/// </summary>
/// <param name="action">Ação a ser executada</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param>
/// <param name="providerName">Nome do provedor.</param>
/// <param name="transaction">Transação.</param>
private void GetId(PersistenceAction action, Dictionary <int, int> primaryKeyMappings, string providerName, IPersistenceTransactionExecuter transaction)
{
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
if (action.Type == PersistenceActionType.Insert && !GetKeyRepository(providerName).IsPosCommand(typeMetadata.FullName))
{
for (int i = 0; i < action.Parameters.Count; i++)
{
var propertyMetadata = typeMetadata[action.Parameters[i].Name];
if (propertyMetadata.ParameterType == PersistenceParameterType.IdentityKey)
{
int virtualId = 0;
object value = action.Parameters[i].Value;
if (value is int)
{
virtualId = (int)value;
}
else
{
var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(int));
if (converter == null && !converter.CanConvertFrom(value.GetType()))
{
continue;
}
try
{
virtualId = (int)converter.ConvertFrom(value);
}
catch (NotSupportedException)
{
continue;
}
}
if (virtualId <= 0)
{
var keyRepository = GetKeyRepository(providerName);
var key = new PersistenceParameter(action.Parameters[i].Name, keyRepository.GetPrimaryKey(transaction, typeMetadata.FullName));
action.Parameters[i] = key;
primaryKeyMappings.Add(virtualId, (int)key.Value);
}
else
{
throw new Exception(ResourceMessageFormatter.Create(() => Properties.Resources.ForeignMemberNotInserted, propertyMetadata.Name, virtualId.ToString(), typeMetadata.FullName).Format());
}
return;
}
}
}
}
/// <summary>
/// Registra as informações do usuário no banco de dados.
/// </summary>
protected override void RegisterUserInfo(IPersistenceTransactionExecuter transaction)
{
}
/// <summary>
/// Executa um comando de insert no banco de dados.
/// </summary>
/// <param name="commandText">Texto do comando a ser executado.</param>
/// <param name="action">Informação da ação de persistência.</param>
/// <param name="transaction">Transação do comando.</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais.</param>
/// <returns>Retorna resultado da ação de persistência.</returns>
protected virtual PersistenceActionResult ExecuteInsertCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
var trans = (PersistenceTransactionExecuter)transaction;
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
bool hasRowVersion = typeMetadata.IsVersioned;
var onlyResultProperties = typeMetadata.GetVolatileProperties().Where(f => action.Parameters.Count(g => g.Name == f.Name) == 0);
int onlyResultCount = onlyResultProperties.Count();
int parameterCount = action.Parameters.Count + onlyResultCount;
if (hasRowVersion)
{
parameterCount++;
}
var resultParameters = new PersistenceParameter[action.Parameters.Count + onlyResultCount];
var parameters = new GDAParameter[parameterCount + onlyResultCount];
for (int i = 0; i < action.Parameters.Count; i++)
{
parameters[i] = CreateParameter('?' + action.Parameters[i].Name, action.Parameters[i].Value);
if (action.Parameters[i].DbType != DbType.AnsiString)
{
parameters[i].DbType = action.Parameters[i].DbType;
}
resultParameters[i] = action.Parameters[i];
}
int index = action.Parameters.Count;
foreach (var property in onlyResultProperties)
{
parameters[index] = CreateParameter('?' + property.Name, "", 0, System.Data.ParameterDirection.InputOutput);
resultParameters[index] = new PersistenceParameter(property.Name, "");
index++;
}
if (hasRowVersion)
{
parameters[index] = CreateParameter('?' + DataAccessConstants.RowVersionPropertyName, action.RowVersion, 0, System.Data.ParameterDirection.Output);
}
int affectedRows = 0;
try
{
var da = new DataAccess(trans.Transaction.ProviderConfiguration);
affectedRows = da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, commandText, parameters);
}
catch (Exception ex)
{
Exception ex2 = ex;
if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException)
{
ex2 = ex.InnerException;
}
ex = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2);
action.NotifyError(ex);
return(new PersistenceActionResult()
{
Success = false,
AffectedRows = affectedRows,
ActionId = action.ActionId,
FailureMessage = ex.Message,
RowVersion = (hasRowVersion) ? (long)parameters[parameters.Length - 1].Value : 0
});
}
var keyRepository = GetKeyRepository(trans.ProviderName);
if (keyRepository.IsPosCommand(action.EntityFullName))
{
IPropertyMetadata identityMetadata = typeMetadata.GetKeyProperties().FirstOrDefault();
if (identityMetadata != null && identityMetadata.ParameterType == Schema.PersistenceParameterType.IdentityKey)
{
for (int i = 0; i < parameters.Length; i++)
{
if (action.Parameters[i].Name == identityMetadata.Name)
{
int identityValue = 0;
var key = keyRepository.GetPrimaryKey(transaction, typeMetadata.FullName);
if (key is int)
{
identityValue = (int)key;
}
else if (key is uint)
{
identityValue = (int)(uint)key;
}
else
{
identityValue = Convert.ToInt32(key);
}
parameters[i].Value = identityValue;
var virtualIdValue = action.Parameters[i].Value;
int virtualId = 0;
if (virtualIdValue is int)
{
virtualId = (int)virtualIdValue;
}
else if (virtualIdValue is uint)
{
virtualId = (int)(uint)virtualIdValue;
}
else
{
virtualId = Convert.ToInt32(virtualIdValue);
}
action.Parameters[i].Value = identityValue;
primaryKeyMappings.Add(virtualId, identityValue);
break;
}
}
}
}
action.NotifyExecution();
return(new PersistenceActionResult()
{
Success = true,
AffectedRows = affectedRows,
Parameters = resultParameters,
ActionId = action.ActionId,
RowVersion = (hasRowVersion) ? (long)parameters[parameters.Length - 1].Value : 0
});
}
/// <summary>
/// Retorna o parâmetro correspondente a chave primária
/// </summary>
/// <param name="transaction">Transação.</param>
/// <param name="entityName">Nome da entidade</param>
/// <returns>Pâremetro correspondente a chave primária</returns>
public object GetPrimaryKey(IPersistenceTransactionExecuter transaction, string entityName)
{
throw new NotSupportedException(Properties.Resources.NotSupportedException_PosCommandOnly);
}
/// <summary>
/// Executa o comando no banco de dados
/// </summary>
/// <param name="commandText">Texto do comando a ser executado</param>
/// <param name="action">Texto do comando</param>
/// <param name="transaction">Transação do comando</param>
/// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param>
/// <returns>Retorna resultado da ação de persistência</returns>
protected override PersistenceActionResult ExecuteCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings)
{
switch (action.Type)
{
case PersistenceActionType.Insert:
return(ExecuteInsertCommand(commandText, action, transaction, primaryKeyMappings));
case PersistenceActionType.Update:
return(ExecuteUpdateCommand(commandText, action, transaction, primaryKeyMappings));
case PersistenceActionType.Delete:
return(ExecuteDeleteCommand(commandText, action, transaction, primaryKeyMappings));
case PersistenceActionType.ExecuteProcedure:
return(ExecuteProcedureCommand(action, transaction));
default:
return(new PersistenceActionResult {
Success = false,
AffectedRows = -1,
FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.NotImplementedException_PersistenceTypeNotSupported, action.Type.ToString()).Format()
});
}
}
