public static IEnumerable <TSource> GetAll <TSource>(this IDbConnection connection)
{
var structureMap = LeanMapper.GetMapper <TSource>();
if (structureMap == null)
{
return(new List <TSource>());
}
return(connection.Query <TSource>(String.Format("Select {0} from {1} {2};", structureMap.GetColumns("it"), structureMap.TableName, "it")));
}
public static void Update <TSource>(this IDbConnection connection, TSource Data)
{
var structureMap = LeanMapper.GetMapper <TSource>();
if (structureMap == null)
{
return;
}
var dynamicParameters = structureMap.GetParameters(Data, false);
connection.Execute(structureMap.UpdateSqlTemplate, dynamicParameters);
}
public static TSource Insert <TSource>(this IDbConnection connection, TSource Data)
{
var structureMap = LeanMapper.GetMapper <TSource>();
if (structureMap == null)
{
return(default(TSource));
}
var dynamicParameters = structureMap.GetParameters(Data);
connection.Execute(structureMap.InsertSqlTemplate, dynamicParameters);
structureMap.UpdateIdFromParameters(Data, dynamicParameters);
return(Data);
}
public static Tuple <string, string, object> ParseExpression <TSource>(Expression <Func <TSource, bool> > predicate) //Experiments
{
//1 checkout if expression is unary
var body = predicate.Body;
string left = String.Empty;
object right = null;
string condition = "=";
if (body is UnaryExpression && body.NodeType == ExpressionType.Not)
{
left = ((body as UnaryExpression).Operand as MemberExpression).Member.Name;
right = 0;
}
if (body.NodeType == ExpressionType.MemberAccess)
{
left = (body as MemberExpression).Member.Name;
right = 1;
}
if (body is BinaryExpression)
{
left = LeanMapper.GetMapper <TSource>().GetPropertyName(BinaryPartExpression((body as BinaryExpression).Left));
right = BinaryPartExpression((body as BinaryExpression).Right);
switch (body.NodeType)
{
case ExpressionType.Equal:
condition = "=";
break;
case ExpressionType.NotEqual:
condition = "!=";
break;
case ExpressionType.LessThan:
condition = "<";
break;
case ExpressionType.LessThanOrEqual:
condition = "<=";
break;
case ExpressionType.GreaterThan:
condition = ">";
break;
case ExpressionType.GreaterThanOrEqual:
condition = ">=";
break;
}
}
//if (body is MethodCallExpression && (((body as MethodCallExpression).Object as MemberExpression).Member as PropertyInfo).PropertyType == typeof(string))
//{
// if ((body as MethodCallExpression).Method.Name == "StartsWith")
// condition = String.Format("{0} like '{1}%'", LeanMapper.GetMapper<TSource>().GetPropertyName(((body as MethodCallExpression).Object as MemberExpression).Member.Name),
// BinaryPartExpression((body as MethodCallExpression).Arguments[0]));
// if ((body as MethodCallExpression).Method.Name == "EndsWith")
// condition = String.Format("{0} like '%{1}'", LeanMapper.GetMapper<TSource>().GetPropertyName(((body as MethodCallExpression).Object as MemberExpression).Member.Name),
// BinaryPartExpression((body as MethodCallExpression).Arguments[0]));
//}
//dirty fix
return(new Tuple <string, string, object>(left, condition, right));
}
BuildFunction <TReturn, TFunc>()
{
var mappingDescriptor = new MappingFunctionDescriptor(typeof(TFunc));
MethodInfo queryMethodSignature = GetSqlMapperQueryMethod(mappingDescriptor);
// variables that are visible in main scope
var variables = new List <ParameterExpression>();
//body of main query method
var methodBodyExpressions = new List <Expression>();
////query method incoming parameters
//var queryMethodParameters = new List<ParameterExpression>();
// parameters for fake map function
var mappingParameters = new List <ParameterExpression>();
// body for fake map function
var mappingBodyExpressions = new List <Expression>();
// declare and assign dictionaries and id evaluators for mapped types
foreach (Type type in mappingDescriptor.GenericTypes.Take(mappingDescriptor.GenericTypes.Length - 1))
{
IStructureMap mapper = LeanMapper.GetMapper(type);
mappingParameters.Add(Expression.Parameter(type));
if (mapper == null)
{
continue;
}
SetupIdDataChecker(variables, methodBodyExpressions, mappingParameters.Last(), mappingBodyExpressions,
mapper);
}
// declare parameters for main query method (they will be passed down to inner SqlMapper.Query method call)
ParameterExpression cnnP = Expression.Parameter(typeof(IDbConnection), "cnn");
ParameterExpression sqlP = Expression.Parameter(typeof(string), "sql");
ParameterExpression mapParam = Expression.Parameter(mappingDescriptor.MappingType, "map");
ParameterExpression paramP = Expression.Parameter(typeof(object), "param");
ParameterExpression transactionP = Expression.Parameter(typeof(IDbTransaction), "transaction");
ParameterExpression bufferedP = Expression.Parameter(typeof(bool), "buffered");
ParameterExpression splitOnP = Expression.Parameter(typeof(string), "splitOn");
ParameterExpression commandTimeoutP = Expression.Parameter(typeof(int?), "commandTimeout");
ParameterExpression commandTypeP = Expression.Parameter(typeof(CommandType?), "commandType");
ParameterExpression newMapper = Expression.Parameter(mappingDescriptor.MappingType, "newMapper");
methodBodyExpressions.Add(Expression.Assign(newMapper,
FinishFakeMappingFunction <TReturn, TFunc>(mapParam, mappingParameters, mappingBodyExpressions)));
variables.Add(newMapper);
//call REAL Query Method
MethodCallExpression callRealDapperMethod = Expression.Call(queryMethodSignature, cnnP, sqlP, newMapper,
paramP, transactionP, bufferedP, splitOnP, commandTimeoutP, commandTypeP);
LabelTarget returnFinalTarget = Expression.Label(typeof(IEnumerable <TReturn>));
GotoExpression returnFinalValue = Expression.Return(returnFinalTarget, callRealDapperMethod);
LabelExpression rerturnFinalExpression = Expression.Label(returnFinalTarget,
Expression.Default(typeof(IEnumerable <TReturn>)));
methodBodyExpressions.Add(returnFinalValue);
methodBodyExpressions.Add(rerturnFinalExpression);
return
(Expression
.Lambda
<Func <IDbConnection, string, TFunc, dynamic, IDbTransaction, bool, string, int?, CommandType?,
IEnumerable <TReturn> > >(
Expression.Block(variables, methodBodyExpressions),
cnnP, sqlP, mapParam, paramP, transactionP, bufferedP, splitOnP, commandTimeoutP,
commandTypeP).Compile());
}
