CompleteSQL/PredicateBuilder.cs at master · nikolainf/CompleteSQL · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using CompleteSQL.Extension;
using System.Collections;

namespace CompleteSQL
{
    internal static class PredicateBuilder
    {
        internal static string BuildPredicate(this LambdaExpression expr, string alias)
        {
            return BuildPredicate(expr.Body, string.Concat(alias, "."));

        }

        private static string BuildPredicate(Expression expr, string alias)
        {
            if (expr is BinaryExpression)
            {
                var binaryExpression = (BinaryExpression)expr;

                switch (expr.NodeType)
                {
                    case ExpressionType.AndAlso:

                        return BuildPredicate(binaryExpression.Left, alias) + " And " + BuildPredicate(binaryExpression.Right, alias);

                    case ExpressionType.OrElse:

                        throw new NotImplementedException();

                    case ExpressionType.Equal:
                        return ComparePredicate(" = ", binaryExpression.Left, binaryExpression.Right, alias);

                    case ExpressionType.NotEqual:
                        return ComparePredicate(" <> ", binaryExpression.Left, binaryExpression.Right, alias);

                    case ExpressionType.GreaterThan:
                        return ComparePredicate(" > ", binaryExpression.Left, binaryExpression.Right, alias);

                    case ExpressionType.GreaterThanOrEqual:
                        return ComparePredicate(" >= ", binaryExpression.Left, binaryExpression.Right, alias);

                    case ExpressionType.LessThan:
                        return ComparePredicate(" < ", binaryExpression.Left, binaryExpression.Right, alias);

                    case ExpressionType.LessThanOrEqual:
                        return ComparePredicate(" <= ", binaryExpression.Left, binaryExpression.Right, alias);

                    default:
                        throw new ArgumentException();
                }

            }

            else
                return alias + GetPredicate((MethodCallExpression)expr);

        }

        private static string ComparePredicate(string equalOperator, Expression left, Expression right, string alias)
        {
            return string.Concat(GetOperand(left, alias), equalOperator, GetOperand(right, alias));
        }


        private static string GetPredicate(MethodCallExpression expr)
        {

            if (expr.Method.DeclaringType == typeof(string))
                switch (expr.Method.Name)
                {
                    case "Contains": return ((MemberExpression)expr.Object).Member.Name + " Like '%" + ((ConstantExpression)expr.Arguments[0]).Value.ToString() + "%'";
                    case "StartsWith": return ((MemberExpression)expr.Object).Member.Name + " Like '" + ((ConstantExpression)expr.Arguments[0]).Value.ToString() + "%'";
                    case "EndsWith": return ((MemberExpression)expr.Object).Member.Name + " Like '%" + ((ConstantExpression)expr.Arguments[0]).Value.ToString() + "'";

                }
            else if(expr.Method.Name.Equals("Contains"))
            {
                int inArgIndex = expr.Object != null ? 0 : 1;
                var inList = expr.Object ?? expr.Arguments[0];
                var inArg = expr.Arguments[inArgIndex];


                MemberExpression inListMemberExpression = (MemberExpression)inList;
                MemberExpression inArgMemberExpression = (MemberExpression)inArg;

                var f = Expression.Lambda(inListMemberExpression).Compile();
                var value = f.DynamicInvoke();

                string quote = inArgMemberExpression.Type == typeof(string) ? "'" : string.Empty;


                string predicate = inArgMemberExpression.Member.Name + " In(";

                if(inArgMemberExpression.Type == typeof(string))
                {
                    predicate += "'" + string.Join("', '", ((IEnumerable)value).Cast<object>()) + "')";
                }
                else
                {
                     predicate += string.Join(", ", ((IEnumerable)value).Cast<object>()) + ")";
                }

                return predicate;


            }

            throw new NotImplementedException();
        }


        private static string GetOperand(Expression expr, string alias)
        {
            if (expr is MemberExpression)
                return string.Concat(alias, ((MemberExpression)expr).Member.Name);
            else if (expr is ConstantExpression)
                return ((ConstantExpression)expr).Value.ToString();
            else
                throw new ArgumentNullException(expr.ToString());
        }
    }
}