public NLINQ.Expression Transform(System.Linq.Expressions.Expression expression)
{
Visit(Evaluator.PartialEval(expression));
if (tree == null)
tree = new NLINQ.QueryExpression(from, new NLINQ.QueryBody(clauses, new NLINQ.SelectClause(from.Identifier), null));
return tree;
}
public virtual OrderByCriteria Update(OrderByCriteria criterium, Expression expression, bool ascending)
{
if (criterium.Expression != expression || criterium.Ascending != ascending)
return new OrderByCriteria(expression, ascending);
return criterium;
}
public virtual UnaryExpression Update(UnaryExpression u, Expression operand, UnaryExpressionType unaryExpressionType)
{
if (u.Expression != operand || u.Type != unaryExpressionType)
{
return new UnaryExpression(unaryExpressionType, operand);
}
return u;
}
public virtual TypedNew Update(TypedNew nex, string type, Expression[] args)
{
if (args != nex.Parameters || nex.Type != type)
{
return new TypedNew(type, args);
}
return nex;
}
public virtual TernaryExpression Update(TernaryExpression c, Expression test, Expression ifTrue, Expression ifFalse)
{
if (test != c.LeftExpression || ifTrue != c.MiddleExpression || ifFalse != c.RightExpression)
{
return new TernaryExpression(test, ifTrue, ifFalse);
}
return c;
}
public MethodCall(Identifier identifier, Expression[] parameters, Identifier anonIndentifier, Identifier indexIdentifier, Expression lambdaExpression)
{
this.identifier = identifier;
this.parameters = parameters;
this.anonIndentifier = anonIndentifier;
this.indexIdentifier = indexIdentifier;
this.lambdaExpression = lambdaExpression;
}
public virtual MethodCall Update(MethodCall m, Identifier target, Identifier methodName, Expression[] args)
{
if (target != m.AnonIdentifier || methodName != m.Identifier || args != m.Parameters)
{
return new MethodCall(methodName, (Expression[])args, m.AnonIdentifier, m.IndexIdentifier, m.LambdaExpression);
}
return m;
}
public JoinClause(string type, Identifier identifier, Expression inIdentifier, Expression on, Expression equals, Identifier into)
{
this.type = type;
this.identifier = identifier;
this.inIdentifier = inIdentifier;
this.on = on;
this.equals = equals;
this.into = into;
}
public override Expression Visit(Expression exp)
{
foreach (IVisitor<Expression> visitor in visitors)
{
TraceHelper.TraceEvent(traceSource, System.Diagnostics.TraceEventType.Start, 1, "{0} process begin...", visitor.GetType().Name);
exp = visitor.Visit(exp);
TraceHelper.TraceEvent(traceSource, System.Diagnostics.TraceEventType.Start, 1, "{0} process succeed...", visitor.GetType().Name);
}
return exp;
}
public ComplexColumnExpression(TableAlias alias, Expression innerExpression, Identifier columnAlias)
: base(alias, null, columnAlias)
{
Expression = innerExpression;
}
public DateAdd(Identifier identifier, Expression expression, Expression result)
: base(DateAddIdentifier, identifier, expression, result)
{
}
public DatePart(Identifier part, Expression expressionToCast)
: base(DatePartIdentifier, new Expression[] { part, expressionToCast })
{
}
public Indexer(Expression innerExpression, Expression parameter)
{
this.innerExpression = innerExpression;
this.parameter = parameter;
}
public MethodCall(Expression target, Identifier methodName, Expression[] parameters)
{
this.Target = target;
this.MethodName = methodName;
Parameters = parameters;
}
public virtual AnonymousParameter Update(AnonymousParameter original, Identifier identifier, Expression expression)
{
if (original.Expression != expression || original.Identifier != identifier)
return new AnonymousParameter(identifier, expression);
return original;
}
public NLinq.Expressions.Expression Visit(MethodCallExpression call)
{
if (call.Method.IsStatic && (call.Method.DeclaringType == typeof(Enumerable) || call.Method.DeclaringType == typeof(Queryable)) || call.Method.DeclaringType == typeof(ContextExtensions))
{
NLinq.Expressions.Expression subExpression = Visit(call.Arguments[0]);
switch (call.Method.Name)
{
case "Skip":
case "Take":
if (tree == null)
{
if (subExpression == null)
subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null));
tree = new NLINQ.MemberExpression(new MethodCall(call.Method.Name, Visit(call.Arguments[1])), subExpression);
}
else
tree = new NLINQ.MemberExpression(new MethodCall(call.Method.Name, Visit(call.Arguments[1])), tree);
return tree;
case "Cast":
return subExpression;
case "FirstOrDefault":
case "LastOrDefault":
case "Last":
case "First":
string methodName = call.Method.Name;
if (call.Method.Name.EndsWith("OrDefault"))
methodName = methodName.Substring(0, call.Method.Name.Length - 9);
if (tree == null)
{
if (subExpression == null)
subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null));
tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(methodName)), subExpression);
}
else
tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(methodName)), tree);
break;
case "Select":
SelectOrGroupClause select = new SelectClause(Visit(call.Arguments[1]));
tree = new QueryExpression(from, new QueryBody(clauses, select, null));
identifiers["#First"].Text = "e" + identifiers["#First"].GetHashCode();
identifiers.Clear();
identifiers["#First"] = new Identifier("e0");
clauses = new ClauseList();
from = new FromClause(null, identifiers["#First"], tree);
return tree;
case "SelectMany":
//Select the result of the join (a load reference)
FromClause from2 = null;
Identifier newElement = null;
select = null;
if (call.Arguments.Count == 2)
newElement = new Identifier("e1");
if (call.Arguments.Count == 3)
newElement = new Identifier(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Parameters[1].Name);
from2 = new FromClause(call.Method.GetGenericArguments()[1].FullName, newElement, Visit(call.Arguments[1]));
if (call.Arguments.Count == 2)
{
//System.Linq.Expressions.LambdaExpression lambda = ((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[1]).Operand);
identifiers["#First"].Text = "e" + identifiers["#First"].GetHashCode();
//newElement = new Identifier("e0");
identifiers.Clear();
newElement.Text = "e0";
identifiers.Add("#First", newElement);
identifiers.Add(newElement.Text, newElement);
select = new SelectClause(newElement);
}
//Select a property of the select many
if (call.Arguments.Count == 3)
{
//newElement = new Identifier(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Parameters[1].Name);
identifiers.Add(newElement.Text, newElement);
Identifier src = new Identifier(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Parameters[0].Name);
if (!identifiers.ContainsKey(src.Text))
identifiers.Add(src.Text, identifiers["#First"]);
select = new SelectClause(Visit(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[2]).Operand).Body));
if (((SelectClause)select).Expression == null)
select = null;
}
if (call.Arguments.Count > 3)
throw new NotSupportedException();
//from2 = new FromClause(call.Method.GetGenericArguments()[1].FullName, newElement, Visit(((System.Linq.Expressions.LambdaExpression)((System.Linq.Expressions.UnaryExpression)call.Arguments[1]).Operand).Body));
clauses.Add(from2);
tree = new QueryExpression(from, new QueryBody(clauses, select, null));
break;
case "Avg":
case "Sum":
if (subExpression == null)
subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null));
tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(call.Method.Name)), subExpression);
return tree;
case "Count":
case "Any":
if (call.Arguments.Count > 1)
{
if (subExpression != null)
{
var param = ((System.Linq.Expressions.LambdaExpression)call.Arguments[1]).Parameters[0];
var paramIdent = new Identifier(param.Name);
identifiers.Add(param.Name, paramIdent);
subExpression = new QueryExpression(new FromClause(param.Type.FullName, paramIdent, subExpression), new QueryBody(new ClauseList(new List<QueryBodyClause>() { new WhereClause(Visit(call.Arguments[1])) }), new SelectClause(paramIdent), null));
}
else
clauses.Add(new WhereClause(Visit(call.Arguments[1])));
}
if (subExpression == null)
subExpression = new QueryExpression(from, new QueryBody(clauses, new SelectClause(identifiers["#First"]), null));
tree = new NLINQ.MemberExpression(new MethodCall(new Identifier(call.Method.Name)), subExpression);
return tree;
case "Intersect":
break;
case "Where":
clauses.Add(new WhereClause(Visit(call.Arguments[1])));
tree = null;
if (from == null)
from = new FromClause(null, identifiers["#First"], subExpression);
break;
case "OrderBy":
NLINQ.Expression m = Visit(call.Arguments[1]);
clauses.Add(new OrderByClause(new OrderByCriteria(m, true)));
break;
case "ThenBy":
break;
case "Infer":
var inferQuery = new QueryTranslator(from.Type);
var result = inferQuery.Visit(call.Arguments[1]);
var first = inferQuery.identifiers["#First"];
NLINQ.MemberExpression me = (NLINQ.MemberExpression)result;
while (me.Previous != first)
me = (NLINQ.MemberExpression)me.Previous;
me.Previous = null;
if (inferQuery.tree != null)
result = inferQuery.tree;
InferredRelationShips.Add(result.ToString());
tree = subExpression;
return subExpression;
}
}
if (call.Method.DeclaringType == typeof(string) || call.Method.DeclaringType == typeof(DateTime))
{
NLinq.Expressions.Expression source = Visit(call.Object);
List<NLinq.Expressions.Expression> parameters = new List<NLinq.Expressions.Expression>();
foreach (var arg in call.Arguments)
{
var param = Visit(arg);
if (param != null)
parameters.Add(param);
}
return new NLinq.Expressions.MemberExpression(
new NLinq.Expressions.MethodCall(new NLinq.Expressions.Identifier(call.Method.Name), parameters.ToArray()),
source);
}
return null;
}
public FromClause(string type, Identifier identifier, Expression expression)
{
this.type = type;
this.identifier = identifier;
this.expression = expression;
}
public Like(Expression lhs, Expression rhs)
: base(LikeIdentifier, lhs, rhs)
{
}
public WhereClause(Expression expression)
{
this.expression = expression;
}
public IsNull(Expression nullable)
: base(IsNullIdentifier, nullable)
{
}
public MethodCall(Identifier identifier, Expression[] parameters)
{
this.identifier = identifier;
this.parameters = parameters;
}
public ComplexColumnExpression(TableAlias alias, Expression innerExpression, string columnAlias)
: base(alias, null, columnAlias)
{
Expression = innerExpression;
}
public BinaryExpression(BinaryExpressionType type, Expression leftExpression, Expression rightExpression)
{
this.type = type;
this.leftExpression = leftExpression;
this.rightExpression = rightExpression;
}
private Field[] GetFields(Expression expression)
{
FieldExtractionVisitor fev = new FieldExtractionVisitor(driver);
fev.Visit(expression);
return fev.Fields.ToArray();
}
public override Expression Visit(Expression exp)
{
previousIsDateTime = false;
return base.Visit(exp);
}
public ComplexColumnExpression(TableAlias alias, Expression innerExpression)
: this(alias, innerExpression, (string)null)
{
}
public InPredicate(Expression[] values)
: base(InPredicateIdentifier, values)
{
}
public Exists(Expression expression)
: base(ExistsIdentifier, expression)
{
}
public Cast(Expression expressionToCast, DbType type)
: base(CastIdentifier, new Expression[] { expressionToCast })
{
Type = type;
}
public OrderByCriteria(Expression expression, bool ascending)
{
this.expression = expression;
this.ascending = ascending;
}
