protected override void OnApplyParameter(PersistenceParameter param)
{
SqlParameter p;
if (this.Command.Parameters.Contains(param.Name))
{
p = this.Command.Parameters[param.Name];
}
else
{
p = new SqlParameter()
{
ParameterName = param.Name,
};
this.Command.Parameters.Add(p);
}
p.Value = param.Value;
if (param.Options != null)
{
var options = (SqlPersistenceParameterOptions)param.Options;
if (options.Size != null)
{
p.Size = options.Size.Value;
}
if (options.SqlDbType != null)
{
p.SqlDbType = options.SqlDbType.Value;
}
}
}
/// <summary>
/// Define o tipo do parâmetero.
/// </summary>
/// <param name="propertyMetadata">Metadados da propriedade.</param>
/// <param name="parameter">Parâmetro de persistência.</param>
protected virtual void SetParameterType(IPropertyMetadata propertyMetadata, PersistenceParameter parameter)
{
if (StringComparer.InvariantCultureIgnoreCase.Equals(propertyMetadata.PropertyType, "System.Byte[]"))
{
parameter.DbType = DbType.Binary;
}
}
internal void PersistenceParam(string name, object value, PersistenceParameterOptions options)
{
PersistenceParameter param;
if (options != null || !this.PersistenceParameters.TryGetValue(name, out param))
{
this.PersistenceParameters[name] = param = new PersistenceParameter(name, value, options);
}
param.Value = value;
}
/// <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>
/// Define o tipo do parâmetero.
/// </summary>
/// <param name="propertyMetadata">Metadados da propriedade.</param>
/// <param name="parameter">Parâmetro de persistência.</param>
protected override void SetParameterType(IPropertyMetadata propertyMetadata, PersistenceParameter parameter)
{
if (StringComparer.InvariantCultureIgnoreCase.Equals(propertyMetadata.PropertyType, "System.Boolean"))
{
parameter.DbType = System.Data.DbType.Int16;
if ((bool)parameter.Value)
{
parameter.Value = 1;
}
else
{
parameter.Value = 0;
}
}
base.SetParameterType(propertyMetadata, parameter);
}
/// <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>
/// Formata texto de um <see cref="ConditionalTerm"/>
/// </summary>
/// <param name="conditionalTerm">Termo condicional</param>
/// <param name="sqlCommand">Objeto <see cref="StringBuilder"/> no qual será adicionado texto</param>
/// <returns>Retorna o próprio objeto</returns>
private DefaultPersistenceSqlParser Format(ConditionalTerm conditionalTerm, StringBuilder sqlCommand)
{
if (conditionalTerm is Constant)
{
Append(((Constant)conditionalTerm).Text, sqlCommand);
}
else if (conditionalTerm is Column)
{
Format((Column)conditionalTerm, sqlCommand);
}
else if (conditionalTerm is Variable)
{
var variable = (Variable)conditionalTerm;
var parameter = Action != null?Action.Parameters.Where(f => f.Name == variable.Name).FirstOrDefault() : null;
Colosoft.Query.QueryParameter queryParameter = null;
if (parameter == null && Action != null && Action.Conditional != null)
{
queryParameter = Action.Conditional.ParameterContainer.FirstOrDefault(f => f.Name == variable.Name);
if (queryParameter != null)
{
parameter = new PersistenceParameter(queryParameter.Name, queryParameter.Value);
}
}
if (parameter != null && (parameter.Value is QueryInfo || parameter.Value is Colosoft.Query.Queryable))
{
if (queryParameter == null)
{
this.Action.Parameters.Remove(parameter);
}
else if (Action.Conditional.ParameterContainer is Colosoft.Query.IQueryParameterContainerExt)
{
((Colosoft.Query.IQueryParameterContainerExt)Action.Conditional.ParameterContainer).Remove(queryParameter);
}
var value = parameter.Value;
if (value is Colosoft.Query.Queryable)
{
value = ((Colosoft.Query.Queryable)value).CreateQueryInfo();
}
Format(new QueryTerm((QueryInfo)value), sqlCommand);
}
else
{
Append(((Variable)conditionalTerm).Name, sqlCommand);
}
}
else if (conditionalTerm is ValuesArray)
{
var values = (ValuesArray)conditionalTerm;
if (values.Values != null && values.Values.Length == 1 && values.Values[0] is Variable)
{
var variable = (Variable)values.Values[0];
var parameter = Action != null?Action.Parameters.Where(f => f.Name == variable.Name).FirstOrDefault() : null;
Colosoft.Query.QueryParameter queryParameter = null;
if (parameter == null && Action != null && Action.Conditional != null)
{
queryParameter = Action.Conditional.ParameterContainer.FirstOrDefault(f => f.Name == variable.Name);
if (queryParameter != null)
{
parameter = new PersistenceParameter(queryParameter.Name, queryParameter.Value);
}
}
if (parameter != null && (parameter.Value is QueryInfo || parameter.Value is Colosoft.Query.Queryable))
{
if (queryParameter == null)
{
this.Action.Parameters.Remove(parameter);
}
else if (Action.Conditional.ParameterContainer is Colosoft.Query.IQueryParameterContainerExt)
{
((Colosoft.Query.IQueryParameterContainerExt)Action.Conditional.ParameterContainer).Remove(queryParameter);
}
var value = parameter.Value;
if (value is Colosoft.Query.Queryable)
{
value = ((Colosoft.Query.Queryable)value).CreateQueryInfo();
}
Format(new QueryTerm((QueryInfo)value), sqlCommand);
values = null;
}
}
if (values != null)
{
Append(conditionalTerm.ToString(), sqlCommand);
}
}
else if (conditionalTerm is ConditionalContainer)
{
Format((ConditionalContainer)conditionalTerm, sqlCommand);
}
else if (conditionalTerm is QueryTerm)
{
Format((QueryTerm)conditionalTerm, sqlCommand);
}
else if (conditionalTerm is FunctionCall)
{
var f = (FunctionCall)conditionalTerm;
Format(f, sqlCommand);
}
else if (conditionalTerm is Formula)
{
Format((Formula)conditionalTerm, sqlCommand);
}
else if (conditionalTerm is MinusTerm)
{
sqlCommand.Append("-");
Format(((MinusTerm)conditionalTerm).Term, sqlCommand);
}
else if (conditionalTerm is Conditional)
{
Format((Conditional)conditionalTerm, sqlCommand);
}
else
{
throw new NotSupportedException(ResourceMessageFormatter.Create(() => Properties.Resources.NotSupportedException_TypeOfConditionalTermNotSupported, conditionalTerm.GetType().ToString()).Format());
}
return(this);
}
/// <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
});
}
