public static string ToSelectClause(this LambdaExpression lambda, BaseConvension dbConvension)
{
var arguments = ((NewExpression)lambda.Body).Arguments;
var typeList = arguments.Select(a => ((System.Linq.Expressions.MemberExpression)a).Member).ToList();
return(dbConvension.ToSelectClauseString(typeList.Select(a => Tuple.Create <string, string>(a.ReflectedType.Name, a.Name))));
}
public static string Parse(this MethodCallExpression methodCallExpression, BaseConvension convention)
{
if (methodCallExpression == null)
{
throw new ArgumentNullException("Not a valid method call Expression.");
}
switch (methodCallExpression.Method.Name)
{
case "Contains":
return(methodCallExpression.ParseContains(convention));
case "Equals":
case "StartsWith":
case "EndsWith":
default: throw new InvalidOperationException();
}
}
public static string ToCommaSeparatedList(this List <string> source, BaseConvension convension)
{
var commaSeparated = new StringBuilder();
var first = true;
foreach (var item in source)
{
if (first)
{
first = false;
}
else
{
commaSeparated.Append(", ");
}
commaSeparated.Append(convension.ToValueNameConvention(item));
}
return(commaSeparated.ToString());
}
public ExpressionParser(BaseConvension dbConvension, bool getValueFromRhf) : this(dbConvension)
{
_getValueFromRhf = getValueFromRhf;
}
public ExpressionParser(BaseConvension dbConvension)
{
_dbConvention = dbConvension;
}
public static IList <string> PredicateParser(this Expression expression, BaseConvension dbConvention, bool getValueFromRhf = true)
{
var expressionParser = new ExpressionParser(dbConvention, getValueFromRhf);
return(expressionParser.ParsePredicate(expression));
}
public static string BuildWhereClauseString(this Expression expression, BaseConvension dbConvention)
{
var builder = PredicateParser(expression, dbConvention);
return(dbConvention.ToWhereClauseString(builder));
}
public QueryBuilder(BaseConvension dbConvension) : this()
{
DbConvension = dbConvension;
}
public static string GetTypeName(this MemberExpression memberExpression, BaseConvension convension)
{
var tuple = Tuple.Create <string, string>(memberExpression.Member.Name, memberExpression.Member.DeclaringType.Name);
return(convension.ToQuantifiedNameConvention(memberExpression.Member.DeclaringType.Name, memberExpression.Member.Name));
}
private static string ParseContains(this MethodCallExpression methodCallExpression, BaseConvension convension)
{
if (methodCallExpression.Arguments.Count != 1)
{
throw new NotSupportedException();
}
var format = "{0} IN ({1})"; //TODO:: move this format to dbConvesion
var declaringType = methodCallExpression.Method.DeclaringType;
if (!declaringType.IsGenericType || declaringType.GetGenericTypeDefinition() != typeof(List <>))
{
throw new NotSupportedException();
}
var argument = methodCallExpression.Arguments.First() as MemberExpression;
var caller = methodCallExpression.Object as MemberExpression;
var items = caller.GetValue <List <string> >().ToCommaSeparatedList(convension);
return(convension.ToContainsString(argument.GetTypeName(convension), items));
}
