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 }); }