Skip to content

D
Dapper
Commit c86c7061 authored by mgravell's avatar mgravell
Browse files
Options

PERF: inline all parameter setup (except lists)

parent 1b23a621
Show whitespace changes
Inline Side-by-side
Showing with 157 additions and 114 deletions
Dapper/SqlMapper.cs
View file @ c86c7061
...@@ -12,6 +12,7 @@ ...@@ -12,6 +12,7 @@
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
using System.Reflection.Emit; using System.Reflection.Emit;
using System.ComponentModel;
namespace Dapper namespace Dapper
{ {
...@@ -20,7 +21,7 @@ public static class SqlMapper ...@@ -20,7 +21,7 @@ public static class SqlMapper
class CacheInfo class CacheInfo
{ {
public object Deserializer { get; set; } public object Deserializer { get; set; }
public Func<object, List<ParamInfo>> ParamReader { get; set; } public Action<IDbCommand, object> ParamReader { get; set; }
} }
static ConcurrentDictionary<Identity, CacheInfo> queryCache = new ConcurrentDictionary<Identity, CacheInfo>(); static ConcurrentDictionary<Identity, CacheInfo> queryCache = new ConcurrentDictionary<Identity, CacheInfo>();
...@@ -84,22 +85,6 @@ private static DbType LookupDbType(Type type) ...@@ -84,22 +85,6 @@ private static DbType LookupDbType(Type type)
throw new NotSupportedException("The type : " + type.ToString() + " is not supported by dapper"); throw new NotSupportedException("The type : " + type.ToString() + " is not supported by dapper");
} }
class ParamInfo
{
private ParamInfo()
{
}
public static ParamInfo Create(string name, DbType type, object val)
{
return new ParamInfo { Name = name, Type = type, Val = val };
}
public DbType Type { get; private set; }
public string Name { get; private set; }
public object Val { get; private set; }
}
private class Identity : IEquatable<Identity> private class Identity : IEquatable<Identity>
{ {
...@@ -154,13 +139,7 @@ public static int Execute(this IDbConnection cnn, string sql, object param = nul ...@@ -154,13 +139,7 @@ public static int Execute(this IDbConnection cnn, string sql, object param = nul
{ {
var identity = new Identity(sql, cnn, null, param == null ? null : param.GetType()); var identity = new Identity(sql, cnn, null, param == null ? null : param.GetType());
var info = GetCacheInfo(param, identity); var info = GetCacheInfo(param, identity);
List<ParamInfo> paramInfos = null; return ExecuteCommand(cnn, transaction, sql, info.ParamReader, param);
if (info.ParamReader != null)
{
paramInfos = info.ParamReader(param);
}
return ExecuteCommand(cnn, transaction, sql, paramInfos);
} }
/// <summary> /// <summary>
...@@ -195,13 +174,8 @@ private static IEnumerable<T> QueryInternal<T>(this IDbConnection cnn, string sq ...@@ -195,13 +174,8 @@ private static IEnumerable<T> QueryInternal<T>(this IDbConnection cnn, string sq
var info = GetCacheInfo(param, identity); var info = GetCacheInfo(param, identity);
List<ParamInfo> paramInfos = null;
if (info.ParamReader != null)
{
paramInfos = info.ParamReader(param);
}
using (var reader = GetReader(cnn, transaction, sql, paramInfos)) using (var reader = GetReader(cnn, transaction, sql, info.ParamReader, param))
{ {
if (info.Deserializer == null) if (info.Deserializer == null)
{ {
...@@ -289,127 +263,196 @@ private static object GetDynamicDeserializer(IDataReader reader) ...@@ -289,127 +263,196 @@ private static object GetDynamicDeserializer(IDataReader reader)
return rval; return rval;
} }
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
[Obsolete("This method is for internal usage only", true)]
public static void PackListParameters(IDbCommand command, string namePrefix, object value)
{
// initially we tried TVP, however it performs quite poorly.
// keep in mind SQL support up to 2000 params easily in sp_executesql, needing more is rare
private static Func<object, List<ParamInfo>> CreateParamInfoGenerator(Type type) var list = value as IEnumerable;
var count = 0;
bool isString = value is IEnumerable<string>;
if (list != null)
{ {
DynamicMethod dm = new DynamicMethod("ParamInfo" + Guid.NewGuid().ToString(), typeof(List<ParamInfo>), new Type[] { typeof(object) }, true); foreach (var item in list)
{
count++;
var listParam = command.CreateParameter();
listParam.ParameterName = namePrefix + count.ToString();
listParam.Value = item ?? DBNull.Value;
if (isString)
{
listParam.Size = 4000;
if (item != null && ((string)item).Length > 4000)
{
listParam.Size = -1;
}
}
command.Parameters.Add(listParam);
}
command.CommandText = command.CommandText.Replace(namePrefix,
"(" + string.Join(
",", Enumerable.Range(1, count).Select(i => namePrefix + i.ToString())
) + ")");
}
}
private static Action<IDbCommand, object> CreateParamInfoGenerator(Type type)
{
DynamicMethod dm = new DynamicMethod("ParamInfo" + Guid.NewGuid().ToString(), null, new Type[] { typeof(IDbCommand), typeof(object) }, type, true);
var il = dm.GetILGenerator(); var il = dm.GetILGenerator();
il.DeclareLocal(type); // 0 il.DeclareLocal(type); // 0
il.Emit(OpCodes.Ldarg_0); // stack is now [untyped-param] bool haveInt32Arg1 = false;
il.Emit(OpCodes.Ldarg_1); // stack is now [untyped-param]
il.Emit(OpCodes.Unbox_Any, type); // stack is now [typed-param] il.Emit(OpCodes.Unbox_Any, type); // stack is now [typed-param]
il.Emit(OpCodes.Stloc_0);// stack is now empty il.Emit(OpCodes.Stloc_0);// stack is now empty
il.Emit(OpCodes.Newobj, typeof(List<ParamInfo>).GetConstructor(Type.EmptyTypes)); // stack is now [list] il.Emit(OpCodes.Ldarg_0); // stack is now [command]
il.EmitCall(OpCodes.Callvirt, typeof(IDbCommand).GetProperty("Parameters").GetGetMethod(), null); // stack is now [parameters]
foreach (var prop in type.GetProperties().OrderBy(p => p.Name)) foreach (var prop in type.GetProperties().OrderBy(p => p.Name))
{ {
// we want to call list.Add(ParamInfo.Create(string name, DbType type, object val)) DbType dbType = LookupDbType(prop.PropertyType);
if (dbType == DbType.Xml)
il.Emit(OpCodes.Dup); // stack is now [list] [list] {
// this actually represents special handling for list types;
il.Emit(OpCodes.Ldstr, prop.Name); // stack is [list] [list] [name] il.Emit(OpCodes.Ldarg_0); // stack is now [parameters] [command]
il.Emit(OpCodes.Ldc_I4, (int)LookupDbType(prop.PropertyType)); // stack is [list] [list] [name] [dbtype] il.Emit(OpCodes.Ldstr, "@" + prop.Name); // stack is now [parameters] [command] [name]
il.Emit(OpCodes.Ldloc_0); // stack is [list] [list] [name] [dbtype] [typed-param] il.Emit(OpCodes.Ldloc_0); // stack is now [parameters] [command] [name] [typed-param]
il.Emit(OpCodes.Callvirt, prop.GetGetMethod()); // stack is [list] [list] [name] [dbtype] [typed-value] il.Emit(OpCodes.Callvirt, prop.GetGetMethod()); // stack is [parameters] [command] [name] [typed-value]
if (prop.PropertyType.IsValueType) if (prop.PropertyType.IsValueType)
{ {
il.Emit(OpCodes.Box, prop.PropertyType); // stack is [list] [list] [name] [dbtype] [untyped-value] il.Emit(OpCodes.Box, prop.PropertyType); // stack is [parameters] [command] [name] [boxed-value]
} }
il.Emit(OpCodes.Call, typeof(ParamInfo).GetMethod("Create", BindingFlags.Static | BindingFlags.Public)); // stack is [list] [list] [param-info] il.EmitCall(OpCodes.Call, typeof(SqlMapper).GetMethod("PackListParameters"), null); // stack is [parameters]
il.Emit(OpCodes.Callvirt, typeof(List<ParamInfo>).GetMethod("Add", BindingFlags.Public | BindingFlags.Instance)); // stack is [list] continue;
} }
il.Emit(OpCodes.Dup); // stack is now [parameters] [parameters]
il.Emit(OpCodes.Ret); il.Emit(OpCodes.Ldarg_0); // stack is now [parameters] [parameters] [command]
il.EmitCall(OpCodes.Callvirt, typeof(IDbCommand).GetMethod("CreateParameter"), null);// stack is now [parameters] [parameters] [parameter]
return (Func<object, List<ParamInfo>>)dm.CreateDelegate(typeof(Func<object, List<ParamInfo>>)); il.Emit(OpCodes.Dup);// stack is now [parameters] [parameters] [parameter] [parameter]
} il.Emit(OpCodes.Ldstr, "@" + prop.Name); // stack is now [parameters] [parameters] [parameter] [parameter] [name]
il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty("ParameterName").GetSetMethod(), null);// stack is now [parameters] [parameters] [parameter]
private static IDbCommand SetupCommand(IDbConnection cnn, IDbTransaction tranaction, string sql, List<ParamInfo> paramInfo) il.Emit(OpCodes.Dup);// stack is now [parameters] [parameters] [parameter] [parameter]
{ EmitInt32(il, (int)dbType);// stack is now [parameters] [parameters] [parameter] [parameter] [db-type]
var cmd = cnn.CreateCommand();
cmd.Transaction = tranaction; il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty("DbType").GetSetMethod(), null);// stack is now [parameters] [parameters] [parameter]
cmd.CommandText = sql;
if (paramInfo != null) il.Emit(OpCodes.Dup);// stack is now [parameters] [parameters] [parameter] [parameter]
EmitInt32(il, (int)ParameterDirection.Input);// stack is now [parameters] [parameters] [parameter] [parameter] [dir]
il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty("Direction").GetSetMethod(), null);// stack is now [parameters] [parameters] [parameter]
il.Emit(OpCodes.Dup);// stack is now [parameters] [parameters] [parameter] [parameter]
il.Emit(OpCodes.Ldloc_0); // stack is now [parameters] [parameters] [parameter] [parameter] [typed-param]
il.Emit(OpCodes.Callvirt, prop.GetGetMethod()); // stack is [parameters] [parameters] [parameter] [parameter] [typed-value]
bool checkForNull = true;
if (prop.PropertyType.IsValueType)
{
il.Emit(OpCodes.Box, prop.PropertyType); // stack is [parameters] [parameters] [parameter] [parameter] [boxed-value]
if (Nullable.GetUnderlyingType(prop.PropertyType) == null)
{ // struct but not Nullable<T>; boxed value cannot be null
checkForNull = false;
}
}
if (checkForNull)
{ {
foreach (var info in paramInfo) if (dbType == DbType.String && !haveInt32Arg1)
{ {
var param = cmd.CreateParameter(); il.DeclareLocal(typeof(int));
param.ParameterName = "@" + info.Name; haveInt32Arg1 = true;
param.DbType = info.Type; }
param.Value = info.Val ?? DBNull.Value; // relative stack: [boxed value]
param.Direction = ParameterDirection.Input; il.Emit(OpCodes.Dup);// relative stack: [boxed value] [boxed value]
if (info.Type == DbType.String) Label notNull = il.DefineLabel();
Label? allDone = dbType == DbType.String ? il.DefineLabel() : (Label?)null;
il.Emit(OpCodes.Brtrue_S, notNull);
// relative stack [boxed value = null]
il.Emit(OpCodes.Pop); // relative stack empty
il.Emit(OpCodes.Ldsfld, typeof(DBNull).GetField("Value")); // relative stack [DBNull]
if (dbType == DbType.String)
{ {
param.Size = 4000; EmitInt32(il, 0);
if (info.Val != null && ((string)info.Val).Length > 4000) il.Emit(OpCodes.Stloc_1);
}
if (allDone != null) il.Emit(OpCodes.Br_S, allDone.Value);
il.MarkLabel(notNull);
if (prop.PropertyType == typeof(string))
{ {
param.Size = -1; il.Emit(OpCodes.Dup); // [string] [string]
il.EmitCall(OpCodes.Callvirt, typeof(string).GetProperty("Length").GetGetMethod(), null); // [string] [length]
EmitInt32(il, 4000); // [string] [length] [4000]
il.Emit(OpCodes.Cgt); // [string] [0 or 1]
Label isLong = il.DefineLabel(), lenDone = il.DefineLabel();
il.Emit(OpCodes.Brtrue_S, isLong);
EmitInt32(il, 4000); // [string] [4000]
il.Emit(OpCodes.Br_S, lenDone);
il.MarkLabel(isLong);
EmitInt32(il, -1); // [string] [-1]
il.MarkLabel(lenDone);
il.Emit(OpCodes.Stloc_1); // [string]
} }
if (allDone != null) il.MarkLabel(allDone.Value);
// relative stack [boxed value or DBNull]
} }
il.EmitCall(OpCodes.Callvirt, typeof(IDataParameter).GetProperty("Value").GetSetMethod(), null);// stack is now [parameters] [parameters] [parameter]
if (info.Type == DbType.Xml) if (prop.PropertyType == typeof(string))
{ {
var endOfSize = il.DefineLabel();
// don't set if 0
il.Emit(OpCodes.Ldloc_1); // [parameters] [parameters] [parameter] [size]
il.Emit(OpCodes.Brfalse_S, endOfSize); // [parameters] [parameters] [parameter]
// initially we tried TVP, however it performs quite poorly. il.Emit(OpCodes.Dup);// stack is now [parameters] [parameters] [parameter] [parameter]
// keep in mind SQL support up to 2000 params easily in sp_executesql, needing more is rare il.Emit(OpCodes.Ldloc_1); // stack is now [parameters] [parameters] [parameter] [parameter] [size]
il.EmitCall(OpCodes.Callvirt, typeof(IDbDataParameter).GetProperty("Size").GetSetMethod(), null);// stack is now [parameters] [parameters] [parameter]
var list = info.Val as IEnumerable;
var count = 0;
bool isString = info.Val is IEnumerable<string>;
if (list != null) il.MarkLabel(endOfSize);
{
foreach (var item in list)
{
count++;
var listParam = cmd.CreateParameter();
listParam.ParameterName = "@" + info.Name + count;
listParam.Value = item ?? DBNull.Value;
if (isString)
{
listParam.Size = 4000;
if (item != null && ((string)item).Length > 4000)
{
listParam.Size = -1;
} }
il.EmitCall(OpCodes.Callvirt, typeof(IList).GetMethod("Add"), null); // stack is now [parameters]
il.Emit(OpCodes.Pop); // IList.Add returns the new index (int); we don't care
} }
cmd.Parameters.Add(listParam); // stack is currently [command]
il.Emit(OpCodes.Pop); // stack is now empty
il.Emit(OpCodes.Ret);
return (Action<IDbCommand, object>)dm.CreateDelegate(typeof(Action<IDbCommand, object>));
} }
cmd.CommandText = cmd.CommandText.Replace("@" + info.Name, private static IDbCommand SetupCommand(IDbConnection cnn, IDbTransaction tranaction, string sql, Action<IDbCommand, object> paramReader, object obj)
"(" + string.Join(
",", Enumerable.Range(1, count).Select(i => "@" + info.Name + i)
) + ")");
}
else
{ {
throw new NotImplementedException(); var cmd = cnn.CreateCommand();
}
} cmd.Transaction = tranaction;
else cmd.CommandText = sql;
if (paramReader != null)
{ {
cmd.Parameters.Add(param); paramReader(cmd, obj);
}
}
} }
return cmd; return cmd;
} }
private static int ExecuteCommand(IDbConnection cnn, IDbTransaction tranaction, string sql, List<ParamInfo> paramInfo) private static int ExecuteCommand(IDbConnection cnn, IDbTransaction tranaction, string sql, Action<IDbCommand, object> paramReader, object obj)
{ {
using (var cmd = SetupCommand(cnn, tranaction, sql, paramInfo)) using (var cmd = SetupCommand(cnn, tranaction, sql, paramReader, obj))
{ {
return cmd.ExecuteNonQuery(); return cmd.ExecuteNonQuery();
} }
} }
private static IDataReader GetReader(IDbConnection cnn, IDbTransaction tranaction, string sql, List<ParamInfo> paramInfo) private static IDataReader GetReader(IDbConnection cnn, IDbTransaction tranaction, string sql, Action<IDbCommand, object> paramReader, object obj)
{ {
using (var cmd = SetupCommand(cnn, tranaction, sql, paramInfo)) using (var cmd = SetupCommand(cnn, tranaction, sql, paramReader, obj))
{ {
return cmd.ExecuteReader(); return cmd.ExecuteReader();
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment