// Used from SqlServerCeDriver as well public static void SetParameterSizes(IDataParameterCollection parameters, SqlType[] parameterTypes) { for (int i = 0; i < parameters.Count; i++) { SetVariableLengthParameterSize((IDbDataParameter) parameters[i], parameterTypes[i]); } }
public void AddAnnotations(IDataParameterCollection pcol) { foreach (SqlParameter p in pcol) { AddAnnotation(p.ParameterName, p.Value); } }
public DatabaseCache(string text, IDataParameterCollection ParameterList) { SQL = text; Parameters = new IDataParameter[ParameterList.Count]; ParameterList.CopyTo(Parameters, 0); }
public int AddParameterValue(IDbConnection dbConnection, IDataParameterCollection parameterCollection, string parameterName, object value) { var param = CreateParameter(dbConnection); param.ParameterName = parameterName; param.Value = value; return(parameterCollection.Add(param)); }
private static IDataParameter[] CreateParameterCopy(DbCommand command) { IDataParameterCollection parameters = command.Parameters; IDataParameter[] array = new IDataParameter[parameters.Count - 1]; parameters.CopyTo(array, 0); return(CachingMechanism.CloneParameters(array)); }
public static int AddWithValue(this IDataParameterCollection Parameters, string name, object value) { IDbDataParameter Parameter = Factory.CreateDataParameter(Parameters); Parameter.ParameterName = name; Parameter.Value = value; return(Parameters.Add(Parameter)); }
public ParameterCollection(IDataParameterCollection parameters) { foreach (IDataParameter innerParameter in parameters) { var parameter = new Parameter(innerParameter); AddParameter(parameter); } }
public void GetParameters() { IDataParameterCollection collectionStub = MockRepository.GenerateStub <IDataParameterCollection>(); _innerCommandMock.Stub(mock => mock.Parameters).Return(collectionStub); _mockRepository.ReplayAll(); Assert.That(_command.Parameters, Is.SameAs(collectionStub)); }
/// <summary> /// 提供某组参数的一个副本 /// </summary> private static IDataParameter[] Clone(IDbCommand command) { IDataParameterCollection parameters = command.Parameters; IDataParameter[] parameterArray = new IDataParameter[parameters.Count]; parameters.CopyTo(parameterArray, 0); return(Clone(parameterArray)); }
public static IDbDataParameter CreateDataParameter(IDataParameterCollection dataParameterCollection) { var nameSpace = dataParameterCollection.GetType().Namespace; string strType = ClientType.Unknow.ToString(); _dicNameSpacesToDbType.TryGetValue(nameSpace, out strType); return(GetInstance <IDbDataParameter>(strType, regParameter)); }
internal DataParameterCollection(IDbCommand command) { _command = command; _parameters = command.Parameters; _parameters.Clear(); _parameterDbType = command.CreateParameter().GetType(); }
public IDataReader ExecuteReader(string strQuery , IDbDataParameter[] paramArray , CommandType cmdType) { IDataParameterCollection paramCol = null; return(ExecuteReader(strQuery, paramArray, cmdType, out paramCol)); }
private static IDataParameter[] CreateParameterCopy(DbCommand command) { IDataParameterCollection parameters = (IDataParameterCollection)command.Parameters; IDataParameter[] originalParameters = new IDataParameter[parameters.Count]; parameters.CopyTo((Array)originalParameters, 0); return(CachingMechanism.CloneParameters(originalParameters)); }
public object ExecuteScalar(string strQuery , IDbDataParameter[] paramArray , CommandType cmdType) { IDataParameterCollection paramCol = null; return(ExecuteScalar(null, null, strQuery, paramArray, cmdType, out paramCol)); }
public DataSet FillDataSet(string strQuery , string strAlias , DataSet dsDataSet) { IDataParameterCollection paramCol = null; return(FillDataSet(null, null, strQuery, strAlias, dsDataSet, null, CommandType.Text, out paramCol)); }
public int ExecuteNonQuery(IDbConnection connection , IDbTransaction trx , string strQuery) { IDataParameterCollection paramCol = null; return(ExecuteNonQuery(connection, trx, strQuery, null, CommandType.Text, out paramCol)); }
/// <summary> /// /// </summary> /// <param name="parameterCollection"></param> /// <param name="parameterName"></param> /// <param name="parameterValue"></param> public static void AddWithValue <T>(this IDataParameterCollection parameterCollection, string parameterName, object parameterValue) where T : IDataParameter, new() { parameterCollection.Add(new T { ParameterName = parameterName, Value = parameterValue }); }
public DataSet FillDataSet(string strQuery , string strAlias , DataSet dsDataSet , IDbDataParameter[] paramArray) { IDataParameterCollection paramCol = null; return(FillDataSet(strQuery, strAlias, dsDataSet, paramArray, CommandType.Text, out paramCol)); }
internal void Inject(ref DbCommand command) { IDataParameterCollection pCol = ((DbCommand)command).Parameters; foreach (DbParameter p in this._lst) { pCol.Add(p); } }
public OrmLiteVistaDbParameterCollection(IDataParameterCollection vistaDbParameterCollection) { if (vistaDbParameterCollection == null) throw new ArgumentNullException("vistaDbParameterCollection"); this.VistaDbParameterCollection = vistaDbParameterCollection; parameters = new OrderedDictionary(StringComparer.InvariantCultureIgnoreCase); }
public static Env Of(EngineConnection connection, IDataParameterCollection parameters) { var env = new Env(); env.AddAll(parameters); env.Engine = connection.Engine; env.DefaultDatabase = connection.Database; return(env); }
public static void AddRange <T>(this IDataParameterCollection collection, IEnumerable <T> collectionToAdd) { var toAdd = collectionToAdd as IList <T> ?? collectionToAdd.ToList(); for (var i = 0; i < toAdd.ToList().Count(); i++) { collection.Add(toAdd[i]); } }
private static IDataParameter[] CreateParameterCopy(DBCommandWrapper command) { IDataParameterCollection parameters = command.Command.Parameters; IDataParameter[] parameterArray = new IDataParameter[parameters.Count]; parameters.CopyTo(parameterArray, 0); return(ParameterCachingMechanism.CloneParameters(parameterArray)); }
public override IDbDataParameter ApplyParameterByFieldInfo(IDataParameterCollection parameters, ColumnInfo info, object value, bool isOld) { NpgsqlParameter param = parameters[isOld ? "old_" + info.Name : info.Name] as NpgsqlParameter; param.NpgsqlDbType = GetNpgsqlDbType(info); param.IsNullable = info.IsNullable; param.Value = value ?? DBNull.Value; return(param); }
public DataSet FillDataSet(string strQuery , string strAlias , DataSet dsDataSet , IDbDataParameter[] paramArray , CommandType cmdType , out IDataParameterCollection paramCol) { return(FillDataSet(null, null, strQuery, strAlias, dsDataSet, paramArray, cmdType, out paramCol)); }
private static SqlParameter[] CreateParameterCopy(DbCommand command) { IDataParameterCollection parameters = command.Parameters; SqlParameter[] parameterArray = new SqlParameter[parameters.Count]; parameters.CopyTo(parameterArray, 0); return(SqlParameterCache.CloneParameters(parameterArray)); }
StringBuilder BuildWhereSql(PanelContext data, IDataParameterCollection parameters, string prefix) { StringBuilder sqlwehre = new StringBuilder(); for (int i = 0; i < data.QueryFields.Count; i++) { QueryField qf = data.QueryFields[i]; if (i == 0) { sqlwehre.Append(" WHERE "); } else { sqlwehre.Append(" AND "); //sqlwehre.Append(fd.Operator == QueryMode.OR ? " OR " : " AND "); } string paramname = String.Format("@{0}{1}", prefix, qf.Column.Name); switch (qf.Operator) { case OperationType.EQUER: sqlwehre.AppendFormat(" {0}={1} ", qf.Column.Name, paramname); break; case OperationType.NOTEQUER: sqlwehre.AppendFormat(" {0}<>{1} ", qf.Column.Name, paramname); break; case OperationType.LIKE: sqlwehre.AppendFormat(" {0} like '%'+{1}+'%' ", qf.Column.Name, paramname); break; case OperationType.LESSTHAN: sqlwehre.AppendFormat(" {0}<{1} ", qf.Column.Name, paramname); break; case OperationType.MORETHAN: sqlwehre.AppendFormat(" {0}>{1} ", qf.Column.Name, paramname); break; case OperationType.LESSTHANEQURE: sqlwehre.AppendFormat(" {0}<={1} ", qf.Column.Name, paramname); break; case OperationType.MORETHANEQURE: sqlwehre.AppendFormat(" {0}>={1} ", qf.Column.Name, paramname); break; default: sqlwehre.AppendFormat(" {0}={1} ", qf.Column.Name, paramname); break; } parameters.Add(new MySqlParameter(paramname, qf.Value)); } return(sqlwehre); }
/// <summary> /// Gets a collection of entities into a <see cref="List{T}"/> /// </summary> /// <typeparam name="T">The entity type to populate</typeparam> /// <param name="query">The query to execute in the command</param> /// <param name="type">The <see cref="CommandType"/> to use</param> /// <param name="parameters">The <see cref="IDataParameterCollection"/> to use by the command</param> /// <returns>A collection of entities into a <see cref="List{T}"/></returns> public List <T> ExecuteToEntityList <T>(string query, CommandType type, IDataParameterCollection parameters) { var result = new List <T>(); WhileReading(query, type, CommandBehavior.CloseConnection, parameters, (r) => { result.Add(GetEntityFromDataRecord <T>(r)); }); return(result); }
/// <summary> /// 批量添加命令参数 /// </summary> public static void AddRange(this IDataParameterCollection source, IEnumerable <IDbDataParameter> parameters) { if (parameters != null) { foreach (var p in parameters) { source.Add(p); } } }
} // end method private static IDbDataParameter AttemptAddWithValue(IDataParameterCollection parameters, string name, object value) { var mirror = Mirror.mirrorCache[parameters.GetType()]; var addWithValue = mirror.GetMethod("AddWithValue", new[] {typeof(string), typeof(object)}); if (addWithValue == null) return null; var parameter = addWithValue.Invoke(parameters, new[] {name, value}); return parameter as IDbDataParameter; } // end method
public object ExecuteScalar(IDbConnection connection , IDbTransaction trx , string strQuery , IDbDataParameter[] paramArray , CommandType cmdType) { IDataParameterCollection paramCol = null; return(ExecuteScalar(connection, trx, strQuery, paramArray, cmdType, out paramCol)); }
public static void AddRange(this IDataParameterCollection collection, IEnumerable <IDataParameter> parameters) { Ensure.IsNotNull(collection); Ensure.IsNotNull(parameters); foreach (IDataParameter item in parameters) { collection.Add(item); } }
private IDataParameterCollection _parameters = null; //the parameters #endregion Fields #region Constructors internal DataParameterCollection( IDbCommand dbCommand, Type parameterDbType, PropertyInfo parameterDbTypeProperty, string parameterNamePrefix) { _dbCommand = dbCommand; _parameters = _dbCommand.Parameters; _parameterDbType = parameterDbType; _parameterDbTypeProperty = parameterDbTypeProperty; _parameterNamePrefix = parameterNamePrefix; }
/// <summary> /// Reemplaza los parametros null de un <see cref="SqlCommand"/> por <see cref="DBNull.Value"/> /// </summary> /// <param name="Parameters"></param> /// <remarks> /// Necesario para que si se envian parametros null SqlServer no devuelva un error de "Esperando parametro" /// Llamenlo justo antes de cualquier <see cref="SqlCommand.ExecuteNonQuery"/> o /// <see cref="SqlCommand.ExecuteScalar"/> para que se limpien los campos /// </remarks> public static void ClearNullParameterValues(IDataParameterCollection Parameters) { foreach (IDataParameter p in Parameters) { if (p.Value == null) { p.Value = DBNull.Value; } } }
public static IDataParameter Add(this IDataParameterCollection paramCollection, IDbCommand cmd, string name) { var param = cmd.CreateParameter(); param.ParameterName = name; paramCollection.Add(param); return(param); }
public string Convert(string commandText, IDataParameterCollection parameters) { var sqlParams = parameters.Cast<DataParameterMock>() .OrderByDescending(x => x.ParameterName.Length); var sql = commandText; foreach (var p in sqlParams) sql = Convert(sql, p); return sql; }
/// <summary> /// Declare BuilCommand /// </summary> /// <param name="storeProName"></param> /// <param name="parameters"></param> /// <returns></returns> private DbCommand BuildReturnCommand(string storeProName, IDataParameterCollection parameters, DbType returnType) { DbCommand command = BuildQueryCommand(storeProName, parameters); IDbDataParameter param = mcnnFactory.MakeParameter(STR_RETURN_VALUE_PARAM_NAME, returnType, ParameterDirection.ReturnValue); command.Parameters.Add(param); return command; }
internal static Exception ParameterNull(string parameter, IDataParameterCollection collection, Type parameterType) { return CollectionNullValue(parameter, collection.GetType(), parameterType); }
internal static Exception ParametersMappingIndex(int index, IDataParameterCollection collection) { return CollectionIndexInt32(index, collection.GetType(), collection.Count); }
/// <summary> /// Declare BuildQueryCommand /// </summary> /// <param name="storeProName"></param> /// <param name="parameters"></param> /// <returns></returns> private DbCommand BuildQueryCommand(string storeProName, IDataParameterCollection parameters) { //mcnnFactory.Ma //mcnnFactory. DbCommand command = mcnnFactory.MakeCommandStoreProc(storeProName, parameters); return command; }
/// <summary> /// Declare function RunProcedure with return DataSet /// </summary> /// <param name="storeProName"></param> /// <param name="parameters"></param> /// <param name="tableName"></param> /// <returns></returns> protected DataSet RunProcedure(string storeProName, IDataParameterCollection parameters, string tableName) { DataSet ds = new DataSet(); DbDataAdapter adapter = (DbDataAdapter)mcnnFactory.MakeAdapter(); adapter.SelectCommand = BuildQueryCommand(storeProName, parameters); adapter.Fill(ds, tableName); return ds; }
/// <summary> /// Declare function RunProcedre to fill the exist Dataset /// </summary> /// <param name="storeProName"></param> /// <param name="parameters"></param> /// <param name="ds"></param> /// <param name="tableName"></param> protected void RunProcedure(string storeProName, IDataParameterCollection parameters, DataSet ds, string tableName) { DbDataAdapter adapter = (DbDataAdapter)mcnnFactory.MakeAdapter(); adapter.SelectCommand = BuildIntCommand(storeProName, parameters); adapter.Fill(ds, tableName); }
private void ParameterInput(IDataParameterCollection parameters, StatementType typeIndex, DataRow row, DataTableMapping mappings) { Data.MissingMappingAction missingMapping = UpdateMappingAction; Data.MissingSchemaAction missingSchema = UpdateSchemaAction; foreach (IDataParameter parameter in parameters) { if ((null != parameter) && (0 != (ParameterDirection.Input & parameter.Direction))) { string columnName = parameter.SourceColumn; if (!string.IsNullOrEmpty(columnName)) { DataColumn dataColumn = mappings.GetDataColumn(columnName, null, row.Table, missingMapping, missingSchema); if (null != dataColumn) { DataRowVersion version = DbDataAdapter.GetParameterSourceVersion(typeIndex, parameter); parameter.Value = row[dataColumn, version]; } else { parameter.Value = null; } DbParameter dbparameter = (parameter as DbParameter); if ((null != dbparameter) && dbparameter.SourceColumnNullMapping) { Debug.Assert(DbType.Int32 == parameter.DbType, "unexpected DbType"); parameter.Value = ADP.IsNull(parameter.Value) ? s_parameterValueNullValue : s_parameterValueNonNullValue; } } } } }
/// <summary> /// Declare function RunProcedure with return the number of rows Affected /// </summary> /// <param name="storeProName"></param> /// <param name="parameters"></param> /// <param name="rowsAffected"></param> /// <returns></returns> protected int RunProcedure(string storeProName, IDataParameterCollection parameters, out int rowsAffected) { int result = 0;// We must signature the value default DbCommand command = BuildIntCommand(storeProName, parameters); rowsAffected = command.ExecuteNonQuery(); result = (int)command.Parameters[STR_RETURN_VALUE_PARAM_NAME].Value; return result; }
/// <summary> /// Declare funciton RunProcedure with return DataReader Object /// </summary> /// <param name="storeProName"></param> /// <param name="parameters"></param> /// <returns></returns> protected DbDataReader RunProcedure(string storeProName, IDataParameterCollection parameters) { DbDataReader reader; DbCommand command = BuildQueryCommand(storeProName, parameters); reader = command.ExecuteReader(CommandBehavior.Default); return reader; }
private DbCommand BuildIntCommand(string storeProName, IDataParameterCollection parameters) { return BuildReturnCommand(storeProName, parameters, DbType.Int64); }
internal static Exception InvalidParameterType(IDataParameterCollection collection, Type parameterType, object invalidValue) { return CollectionInvalidType(collection.GetType(), parameterType, invalidValue); }
/// <summary> /// Initializes a new instance of the <see cref="DbParameters"/> class. /// </summary> public DbParameters(IDbProvider dbProvider) { this.dbProvider = dbProvider; dbCommand = dbProvider.CreateCommand(); dataParameterCollection = dbCommand.Parameters; }
/// <summary> /// Collect all Out or InOut param values, casting them to the correct .net type. /// </summary> private List<object> CopyOutParams(ParameterInfo[] paramInfos, IDataParameterCollection paramSet) { List<object> outParamValues = new List<object>(); //Type type_t = typeof(T); int i = -1; foreach (IDbDataParameter param in paramSet) { i++; if (param.Direction == ParameterDirection.Input) { outParamValues.Add("unused"); continue; } object val = param.Value; Type desired_type = paramInfos[i].ParameterType; if (desired_type.Name.EndsWith("&")) { //for ref and out parameters, we need to tweak ref types, e.g. // "System.Int32&, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" string fullName1 = desired_type.AssemblyQualifiedName; string fullName2 = fullName1.Replace("&", ""); desired_type = Type.GetType(fullName2); } try { //fi.SetValue(t, val); //fails with 'System.Decimal cannot be converted to Int32' //DbLinq.util.FieldUtils.SetObjectIdField(t, fi, val); //object val2 = DbLinq.Util.FieldUtils.CastValue(val, desired_type); object val2 = TypeConvert.To(val, desired_type); outParamValues.Add(val2); } catch (Exception) { //fails with 'System.Decimal cannot be converted to Int32' //Logger.Write(Level.Error, "CopyOutParams ERROR L245: failed on CastValue(): " + ex.Message); } } return outParamValues; }
public ParametersBuilder (IDbCommand command, BindVariableCharacter bindVarChar) { cmd = command; sql = cmd.CommandText; parms = cmd.Parameters; bindCharSetting = bindVarChar; SetBindCharacter(); }
/// <summary> /// Builds a Postgres query to insert a row of data into a table. /// </summary> /// <param name="tableName">The name of the table to insert data into.</param> /// <param name="columnList">The list of columns that make up the row.</param> /// <param name="parameterList">A collection of parameters to insert.</param> /// <returns>Postgres insert statement to insert the given data into the designated table.</returns> public string BuildQueryInsertRow(string tableName, ICollection<string> columnList, IDataParameterCollection parameterList) { var columns = String.Join(",", columnList); ICollection<string> paramNameList = new List<string>(); foreach (IDbDataParameter parameter in parameterList) { paramNameList.Add(parameter.ParameterName); } var paramNames = String.Join(",", paramNameList); return String.Format(@"INSERT INTO ""{0}"" ({1}) VALUES ({2});", tableName, columns, paramNames); }
public Log4NetCommand() { mostRecentInstance = this; parameters = new Log4NetParameterCollection(); }
private void ParameterOutput(IDataParameterCollection parameters, DataRow row, DataTableMapping mappings) { Data.MissingMappingAction missingMapping = UpdateMappingAction; Data.MissingSchemaAction missingSchema = UpdateSchemaAction; foreach (IDataParameter parameter in parameters) { if (null != parameter) { ParameterOutput(parameter, row, mappings, missingMapping, missingSchema); } } }
/// <summary> /// Metodo responsavel pela execucao de comandos que nao sao de pesquisa(Insert, Update, Delete). /// </summary> /// <param name="cmdTexto">Texto do Comando</param> /// <param name="tipoComando">Tipo do Comando</param> /// <param name="cmdParametros">Colecao de Parametros</param> /// <returns> /// Retorna a quantidade de linhas afetadas pelo comando ou /// um parametro de saida do tipo inteiro. /// </returns> public int ExecutarNonQuery(string cmdTexto, CommandType tipoComando, IDataParameter[] cmdParametros) { try { PrepararComando(tipoComando, cmdTexto, cmdParametros); int linhas = comando.ExecuteNonQuery(); parametrosSaida = comando.Parameters; if (comando.Parameters.Contains("@RETURN_VALUE")) { try { object valor = ((IDataParameter)comando.Parameters["@RETURN_VALUE"]).Value; return Convert.ToInt32(valor); } catch //alguns drivers como o ASAClient não suporta @REturn_Value { return linhas; } } else return linhas; } catch (System.Exception ex) { if (transacao != null) CancelarTransacao(); throw ex; } finally { if (transacao == null) { conexao.Close(); comando.Dispose(); } } }
internal static Exception ParametersSourceIndex(string parameterName, IDataParameterCollection collection, Type parameterType) { return CollectionIndexString(parameterType, "ParameterName", parameterName, collection.GetType()); }
/// <summary> /// This method assigns dataRow column values to an IDataParameterCollection /// </summary> /// <param name="commandParameters">The IDataParameterCollection to be assigned values</param> /// <param name="dataRow">The dataRow used to hold the command's parameter values</param> /// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception> protected internal static void AssignParameterValues(IDataParameterCollection commandParameters, DataRow dataRow) { if (commandParameters == null || dataRow == null) { // Do nothing if we get no data return; } DataColumnCollection columns = dataRow.Table.Columns; int i = 0; // Set the parameters values foreach (IDataParameter commandParameter in commandParameters) { // Check the parameter name if (commandParameter.ParameterName == null || commandParameter.ParameterName.Length <= 1) throw new InvalidOperationException(string.Format( "Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.", i, commandParameter.ParameterName)); if (columns.Contains(commandParameter.ParameterName)) commandParameter.Value = dataRow[commandParameter.ParameterName]; else if (columns.Contains(commandParameter.ParameterName.Substring(1))) commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)]; i++; } }
public MockDbCommand() { this.parameters = new MockParameterCollection(this); }
private static IDbDataParameter GetOutPutParameter(IDataParameterCollection parameters) { foreach (IDbDataParameter parameter in parameters) { if (parameter.Direction == ParameterDirection.Output) return parameter; } return null; }