private static void AddParameters(IDbCommand command, SqlMapper.Identity identity, object parameters)
{
var paramInfoGenerator = ParamInfoGenerators.GetOrAdd(parameters.GetType(), type =>
{
var index = identity.ForDynamicParameters(type);
return(SqlMapper.CreateParamInfoGenerator(index, true, true));
});
paramInfoGenerator(command, parameters);
}
private static SqlMapper.CacheInfo GetCacheInfo(SqlMapper.Identity identity)
{
SqlMapper.CacheInfo info;
if (!TryGetQueryCache(identity, out info))
{
info = new SqlMapper.CacheInfo();
if (identity.parametersType != null)
{
if (typeof(SqlMapper.IDynamicParameters).IsAssignableFrom(identity.parametersType))
{
info.ParamReader = (cmd, obj) => { (obj as SqlMapper.IDynamicParameters).AddParameters(cmd, identity); }
}
;
else if (typeof(IEnumerable <KeyValuePair <String, Object> >).IsAssignableFrom(identity.parametersType))
{
info.ParamReader = (cmd, obj) => { (new DynamicParameters(obj) as SqlMapper.IDynamicParameters).AddParameters(cmd, identity); }
}
;
else if (identity.parametersType.IsValueType && !identity.parametersType.IsPrimitive)
{
info.ParamReader = (cmd, obj) =>
{
foreach (PropertyInfo pi in obj.GetType().GetProperties())
{
IDbDataParameter param = cmd.CreateParameter();
param.ParameterName = pi.Name;
param.Value = pi.GetValue(obj, null);
cmd.Parameters.Add(param);
}
}
}
;
else
{
info.ParamReader = SqlMapper.CreateParamInfoGenerator(identity, false);
}
}
SetQueryCache(identity, info);
}
return(info);
}
/// <summary>
/// Add all the parameters needed to the command just before it executes
/// </summary>
/// <param name="command">The raw command prior to execution</param>
/// <param name="identity">Information about the query</param>
private void AddParameters(IDbCommand command, SqlMapper.Identity identity)
{
if (_templates != null)
{
foreach (var template in _templates)
{
var newIdent = identity.ForDynamicParameters(template.GetType());
var appender = ParamReaderCache[newIdent] as Action <IDbCommand, object>;
if (appender == null)
{
lock (ParamReaderCache)
{
appender = ParamReaderCache[newIdent] as Action <IDbCommand, object>;
if (appender == null)
{
appender = SqlMapper.CreateParamInfoGenerator(newIdent, false, false);
ParamReaderCache[newIdent] = appender;
}
}
}
appender(command, template);
}
}
foreach (var param in _parameters.Values)
{
var name = Clean(param.Name);
var oracleCommand = command as OracleCommand;
var add = !oracleCommand.Parameters.Contains(name);
OracleParameter p;
if (add)
{
p = oracleCommand.CreateParameter();
p.ParameterName = name;
}
else
{
p = oracleCommand.Parameters[name];
}
var val = param.Value;
p.Value = val ?? DBNull.Value;
p.Direction = param.ParameterDirection;
var s = val as string;
if (s != null)
{
if (s.Length <= 4000)
{
p.Size = 4000;
}
}
if (param.Size != null)
{
p.Size = param.Size.Value;
}
if (param.DbType != null)
{
p.OracleDbType = param.DbType.Value;
}
if (add)
{
command.Parameters.Add(p);
}
param.AttachedParam = p;
}
}
/// <summary>
/// Add all the parameters needed to the command just before it executes
/// </summary>
/// <param name="command">The raw command prior to execution</param>
/// <param name="identity">Information about the query</param>
public void AddParameters(IDbCommand command, Identity identity)
{
var literals = SqlMapper.GetLiteralTokens(identity.sql);
if (templates != null)
{
foreach (var template in templates)
{
var newIdent = identity.ForDynamicParameters(template.GetType());
Action <IDbCommand, object> appender;
lock (paramReaderCache)
{
if (!paramReaderCache.TryGetValue(newIdent, out appender))
{
appender = SqlMapper.CreateParamInfoGenerator(newIdent, true, RemoveUnused, literals);
paramReaderCache[newIdent] = appender;
}
}
appender(command, template);
}
// The parameters were added to the command, but not the
// DynamicParameters until now.
foreach (IDbDataParameter param in command.Parameters)
{
// If someone makes a DynamicParameters with a template,
// then explicitly adds a parameter of a matching name,
// it will already exist in 'parameters'.
if (!parameters.ContainsKey(param.ParameterName))
{
parameters.Add(param.ParameterName, new ParamInfo
{
AttachedParam = param,
CameFromTemplate = true,
DbType = param.DbType,
Name = param.ParameterName,
ParameterDirection = param.Direction,
Size = param.Size,
Value = param.Value
});
}
}
// Now that the parameters are added to the command, let's place our output callbacks
var tmp = outputCallbacks;
if (tmp != null)
{
foreach (var generator in tmp)
{
generator();
}
}
}
foreach (var param in parameters.Values)
{
if (param.CameFromTemplate)
{
continue;
}
var dbType = param.DbType;
var val = param.Value;
string name = Clean(param.Name);
var isCustomQueryParameter = val is ICustomQueryParameter;
ITypeHandler handler = null;
if (dbType == null && val != null && !isCustomQueryParameter)
{
dbType = SqlMapper.LookupDbType(val.GetType(), name, true, out handler);
}
if (dbType == DynamicParameters.EnumerableMultiParameter)
{
#pragma warning disable 612, 618
SqlMapper.PackListParameters(command, name, val);
#pragma warning restore 612, 618
}
else if (isCustomQueryParameter)
{
((ICustomQueryParameter)val).AddParameter(command, name);
}
else
{
bool add = !command.Parameters.Contains(name);
IDbDataParameter p;
if (add)
{
p = command.CreateParameter();
p.ParameterName = name;
}
else
{
p = (IDbDataParameter)command.Parameters[name];
}
p.Direction = param.ParameterDirection;
if (handler == null)
{
p.Value = val ?? DBNull.Value;
if (dbType != null && p.DbType != dbType)
{
p.DbType = dbType.Value;
}
var s = val as string;
if (s != null)
{
if (s.Length <= DbString.DefaultLength)
{
p.Size = DbString.DefaultLength;
}
}
if (param.Size != null)
{
p.Size = param.Size.Value;
}
}
else
{
if (dbType != null)
{
p.DbType = dbType.Value;
}
if (param.Size != null)
{
p.Size = param.Size.Value;
}
handler.SetValue(p, val ?? DBNull.Value);
}
if (add)
{
command.Parameters.Add(p);
}
param.AttachedParam = p;
}
}
// note: most non-priveleged implementations would use: this.ReplaceLiterals(command);
if (literals.Count != 0)
{
SqlMapper.ReplaceLiterals(this, command, literals);
}
}
/// <summary>
/// Add all the parameters needed to the command just before it executes
/// </summary>
/// <param name="command">The raw command prior to execution</param>
/// <param name="identity">Information about the query</param>
protected void AddParameters(IDbCommand command, SqlMapper.Identity identity)
{
if (templates != null)
{
foreach (var template in templates)
{
var newIdent = identity.ForDynamicParameters(template.GetType());
Action <IDbCommand, object> appender;
lock (paramReaderCache)
{
if (!paramReaderCache.TryGetValue(newIdent, out appender))
{
appender = SqlMapper.CreateParamInfoGenerator(newIdent, false, false);
paramReaderCache[newIdent] = appender;
}
}
appender(command, template);
}
}
foreach (var param in parameters.Values)
{
string name = Clean(param.Name);
bool add = !((OracleCommand)command).Parameters.Contains(name);
OracleParameter p;
if (add)
{
p = ((OracleCommand)command).CreateParameter();
p.ParameterName = name;
}
else
{
p = ((OracleCommand)command).Parameters[name];
}
var val = param.Value;
p.Value = val ?? DBNull.Value;
p.Direction = param.ParameterDirection;
var s = val as string;
if (s != null)
{
if (s.Length <= 4000)
{
p.Size = 4000;
}
}
if (param.Size != null)
{
p.Size = param.Size.Value;
}
if (param.DbType != null)
{
p.OracleDbType = param.DbType.Value;
}
if (add)
{
command.Parameters.Add(p);
}
param.AttachedParam = p;
}
}