// 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));
}
public DatabaseCache(string text, IDataParameterCollection ParameterList)
{
SQL = text;
Parameters = new IDataParameter[ParameterList.Count];
ParameterList.CopyTo(Parameters, 0);
}
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 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;
}