public virtual void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
if (this.ThrowException)
{
throw (System.Exception) this.CreateException(queryOrderClause);
}
}
public virtual void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
if (ThrowException)
{
throw (Exception)CreateException(queryOrderClause);
}
}
public override object VisitQueryOrderClause(QueryOrderClause queryOrderClause, object data)
{
var text = QueryParsingUtils.ToText(queryOrderClause);
throw new InvalidOperationException(
@"OrderBy calls are not valid during map or reduce phase, but the following was found:
" + text + @"
OrderBy calls modify the indexing output, but doesn't actually impact the order of results returned from the database.
You should be calling OrderBy on the QUERY, not on the index, if you want to specify ordering.");
}
public RedILNode VisitQueryOrderClause(QueryOrderClause queryOrderClause, State data)
{
throw new System.NotImplementedException();
}
public virtual void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
VisitChildren (queryOrderClause);
}
public override object Visit(Mono.CSharp.Linq.QueryExpression queryExpression)
{
var oldQueryOrderClause = currentQueryOrderClause;
try {
currentQueryOrderClause = null;
var result = new QueryExpression();
var currentClause = queryExpression.next;
while (currentClause != null) {
var clause = (QueryClause)currentClause.Accept(this);
if (clause is QueryContinuationClause) {
// insert preceding query at beginning of QueryContinuationClause
clause.InsertChildAfter(null, result, QueryContinuationClause.PrecedingQueryRole);
// create a new QueryExpression for the remaining query
result = new QueryExpression();
}
if (clause != null) {
result.AddChild(clause, QueryExpression.ClauseRole);
}
currentClause = currentClause.next;
}
return result;
} finally {
currentQueryOrderClause = oldQueryOrderClause;
}
}
public void VisitQueryOrderClause(QueryOrderClause node)
{
NotSupported(node);
}
public StringBuilder VisitQueryOrderClause(QueryOrderClause queryOrderClause, int data)
{
throw new SLSharpException("SL# does not understand LINQ.");
}
public override void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
base.VisitQueryOrderClause(queryOrderClause);
indexData.HasOrder = true;
}
public StringBuilder VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
return(InvalidNode(queryOrderClause, "LINQ is not supported"));
}
public virtual void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
DebugExpression(queryOrderClause);
StartNode(queryOrderClause);
WriteKeyword(QueryOrderClause.OrderbyKeywordRole);
Space();
WriteCommaSeparatedList(queryOrderClause.Orderings);
EndNode(queryOrderClause);
}
public UnifiedElement VisitQueryOrderClause(
QueryOrderClause queryOrderClause, object data)
{
throw new NotImplementedException("QueryOrderClause");
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
QueryOrderClause o = other as QueryOrderClause;
return(o != null && this.Orderings.DoMatch(o.Orderings, match));
}
public Node VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
return(CreateDummy(queryOrderClause));
}
public void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
throw new NotImplementedException();
}
public virtual S VisitQueryOrderClause(QueryOrderClause queryOrderClause, T data)
{
return(VisitChildren(queryOrderClause, data));
}
public override void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
throw NotSupportedToConsistency();
}
public override void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
FixClauseIndentation(queryOrderClause, queryOrderClause.OrderbyToken);
}
/// <inheritdoc/>
public virtual void VisitQueryOrderClause(QueryOrderClause syntax)
{
VisitNode(syntax);
}
public void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
throw new NotImplementedException();
}
public override void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
}
QueryExpression DecompileQuery(InvocationExpression invocation)
{
if (invocation == null)
return null;
MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression;
if (mre == null)
return null;
switch (mre.MemberName) {
case "Select":
{
if (invocation.Arguments.Count != 1)
return null;
string parameterName;
Expression body;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out body)) {
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = parameterName, Expression = mre.Target.Detach() });
query.Clauses.Add(new QuerySelectClause { Expression = body.Detach() });
return query;
}
return null;
}
case "GroupBy":
{
if (invocation.Arguments.Count == 2) {
string parameterName1, parameterName2;
Expression keySelector, elementSelector;
if (MatchSimpleLambda(invocation.Arguments.ElementAt(0), out parameterName1, out keySelector)
&& MatchSimpleLambda(invocation.Arguments.ElementAt(1), out parameterName2, out elementSelector)
&& parameterName1 == parameterName2)
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = parameterName1, Expression = mre.Target.Detach() });
query.Clauses.Add(new QueryGroupClause { Projection = elementSelector.Detach(), Key = keySelector.Detach() });
return query;
}
} else if (invocation.Arguments.Count == 1) {
string parameterName;
Expression keySelector;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out keySelector)) {
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = parameterName, Expression = mre.Target.Detach() });
query.Clauses.Add(new QueryGroupClause { Projection = new IdentifierExpression(parameterName), Key = keySelector.Detach() });
return query;
}
}
return null;
}
case "SelectMany":
{
if (invocation.Arguments.Count != 2)
return null;
string parameterName;
Expression collectionSelector;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(0), out parameterName, out collectionSelector))
return null;
LambdaExpression lambda = invocation.Arguments.ElementAt(1) as LambdaExpression;
if (lambda != null && lambda.Parameters.Count == 2 && lambda.Body is Expression) {
ParameterDeclaration p1 = lambda.Parameters.ElementAt(0);
ParameterDeclaration p2 = lambda.Parameters.ElementAt(1);
if (p1.Name == parameterName) {
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = p1.Name, Expression = mre.Target.Detach() });
query.Clauses.Add(new QueryFromClause { Identifier = p2.Name, Expression = collectionSelector.Detach() });
query.Clauses.Add(new QuerySelectClause { Expression = ((Expression)lambda.Body).Detach() });
return query;
}
}
return null;
}
case "Where":
{
if (invocation.Arguments.Count != 1)
return null;
string parameterName;
Expression body;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out body)) {
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = parameterName, Expression = mre.Target.Detach() });
query.Clauses.Add(new QueryWhereClause { Condition = body.Detach() });
return query;
}
return null;
}
case "OrderBy":
case "OrderByDescending":
case "ThenBy":
case "ThenByDescending":
{
if (invocation.Arguments.Count != 1)
return null;
string parameterName;
Expression orderExpression;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out orderExpression)) {
if (ValidateThenByChain(invocation, parameterName)) {
QueryOrderClause orderClause = new QueryOrderClause();
InvocationExpression tmp = invocation;
while (mre.MemberName == "ThenBy" || mre.MemberName == "ThenByDescending") {
// insert new ordering at beginning
orderClause.Orderings.InsertAfter(
null, new QueryOrdering {
Expression = orderExpression.Detach(),
Direction = (mre.MemberName == "ThenBy" ? QueryOrderingDirection.None : QueryOrderingDirection.Descending)
});
tmp = (InvocationExpression)mre.Target;
mre = (MemberReferenceExpression)tmp.Target;
MatchSimpleLambda(tmp.Arguments.Single(), out parameterName, out orderExpression);
}
// insert new ordering at beginning
orderClause.Orderings.InsertAfter(
null, new QueryOrdering {
Expression = orderExpression.Detach(),
Direction = (mre.MemberName == "OrderBy" ? QueryOrderingDirection.None : QueryOrderingDirection.Descending)
});
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = parameterName, Expression = mre.Target.Detach() });
query.Clauses.Add(orderClause);
return query;
}
}
return null;
}
case "Join":
case "GroupJoin":
{
if (invocation.Arguments.Count != 4)
return null;
Expression source1 = mre.Target;
Expression source2 = invocation.Arguments.ElementAt(0);
string elementName1, elementName2;
Expression key1, key2;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(1), out elementName1, out key1))
return null;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(2), out elementName2, out key2))
return null;
LambdaExpression lambda = invocation.Arguments.ElementAt(3) as LambdaExpression;
if (lambda != null && lambda.Parameters.Count == 2 && lambda.Body is Expression) {
ParameterDeclaration p1 = lambda.Parameters.ElementAt(0);
ParameterDeclaration p2 = lambda.Parameters.ElementAt(1);
if (p1.Name == elementName1 && (p2.Name == elementName2 || mre.MemberName == "GroupJoin")) {
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause { Identifier = elementName1, Expression = source1.Detach() });
QueryJoinClause joinClause = new QueryJoinClause();
joinClause.JoinIdentifier = elementName2; // join elementName2
joinClause.InExpression = source2.Detach(); // in source2
joinClause.OnExpression = key1.Detach(); // on key1
joinClause.EqualsExpression = key2.Detach(); // equals key2
if (mre.MemberName == "GroupJoin") {
joinClause.IntoIdentifier = p2.Name; // into p2.Name
}
query.Clauses.Add(joinClause);
query.Clauses.Add(new QuerySelectClause { Expression = ((Expression)lambda.Body).Detach() });
return query;
}
}
return null;
}
default:
return null;
}
}
public override void VisitQueryOrderClause(QueryOrderClause syntax)
{
_underlyingVisitor.VisitQueryOrderClause(syntax);
}
QueryExpression DecompileQuery(InvocationExpression invocation)
{
if (invocation == null)
{
return(null);
}
if (invocation.Parent is ParenthesizedExpression == false &&
invocation.Parent is QueryClause == false)
{
return(null);
}
MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression;
if (mre == null)
{
return(null);
}
switch (mre.MemberName)
{
case "Select":
{
if (invocation.Arguments.Count != 1)
{
return(null);
}
string parameterName;
Expression body;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out body))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = parameterName, Expression = Detach(mre.Target)
});
query.Clauses.Add(new QuerySelectClause {
Expression = Detach(body)
});
return(query);
}
return(null);
}
case "GroupBy":
{
if (invocation.Arguments.Count == 2)
{
string parameterName1, parameterName2;
Expression keySelector, elementSelector;
if (MatchSimpleLambda(invocation.Arguments.ElementAt(0), out parameterName1, out keySelector) &&
MatchSimpleLambda(invocation.Arguments.ElementAt(1), out parameterName2, out elementSelector) &&
parameterName1 == parameterName2)
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = parameterName1, Expression = Detach(mre.Target)
});
query.Clauses.Add(new QueryGroupClause {
Projection = Detach(elementSelector), Key = Detach(keySelector)
});
return(query);
}
}
else if (invocation.Arguments.Count == 1)
{
string parameterName;
Expression keySelector;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out keySelector))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = parameterName, Expression = Detach(mre.Target)
});
query.Clauses.Add(new QueryGroupClause {
Projection = new IdentifierExpression(parameterName), Key = Detach(keySelector)
});
return(query);
}
}
return(null);
}
case "SelectMany":
{
if (invocation.Arguments.Count != 2)
{
return(null);
}
string parameterName;
Expression collectionSelector;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(0), out parameterName, out collectionSelector))
{
return(null);
}
LambdaExpression lambda = invocation.Arguments.ElementAt(1) as LambdaExpression;
if (lambda != null && lambda.Parameters.Count == 2 && lambda.Body is Expression)
{
ParameterDeclaration p1 = lambda.Parameters.ElementAt(0);
ParameterDeclaration p2 = lambda.Parameters.ElementAt(1);
if (p1.Name == parameterName)
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = p1.Name, Expression = Detach(mre.Target)
});
query.Clauses.Add(new QueryFromClause {
Identifier = p2.Name, Expression = Detach(collectionSelector)
});
query.Clauses.Add(new QuerySelectClause {
Expression = Detach(((Expression)lambda.Body))
});
return(query);
}
}
return(null);
}
case "Where":
{
if (invocation.Arguments.Count != 1)
{
return(null);
}
string parameterName;
Expression body;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out body))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = parameterName, Expression = Detach(mre.Target)
});
query.Clauses.Add(new QueryWhereClause {
Condition = Detach(body)
});
return(query);
}
return(null);
}
case "OrderBy":
case "OrderByDescending":
case "ThenBy":
case "ThenByDescending":
{
if (invocation.Arguments.Count != 1)
{
return(null);
}
string parameterName;
Expression orderExpression;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameterName, out orderExpression))
{
if (ValidateThenByChain(invocation, parameterName))
{
QueryOrderClause orderClause = new QueryOrderClause();
InvocationExpression tmp = invocation;
while (mre.MemberName == "ThenBy" || mre.MemberName == "ThenByDescending")
{
// insert new ordering at beginning
orderClause.Orderings.InsertAfter(
null, new QueryOrdering
{
Expression = Detach(orderExpression),
Direction = (mre.MemberName == "ThenBy" ? QueryOrderingDirection.None : QueryOrderingDirection.Descending)
});
tmp = (InvocationExpression)mre.Target;
mre = (MemberReferenceExpression)tmp.Target;
MatchSimpleLambda(tmp.Arguments.Single(), out parameterName, out orderExpression);
}
// insert new ordering at beginning
orderClause.Orderings.InsertAfter(
null, new QueryOrdering
{
Expression = Detach(orderExpression),
Direction = (mre.MemberName == "OrderBy" ? QueryOrderingDirection.None : QueryOrderingDirection.Descending)
});
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = parameterName, Expression = Detach(mre.Target)
});
query.Clauses.Add(orderClause);
return(query);
}
}
return(null);
}
case "Join":
case "GroupJoin":
{
if (invocation.Arguments.Count != 4)
{
return(null);
}
Expression source1 = mre.Target;
Expression source2 = invocation.Arguments.ElementAt(0);
string elementName1, elementName2;
Expression key1, key2;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(1), out elementName1, out key1))
{
return(null);
}
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(2), out elementName2, out key2))
{
return(null);
}
LambdaExpression lambda = invocation.Arguments.ElementAt(3) as LambdaExpression;
if (lambda != null && lambda.Parameters.Count == 2 && lambda.Body is Expression)
{
ParameterDeclaration p1 = lambda.Parameters.ElementAt(0);
ParameterDeclaration p2 = lambda.Parameters.ElementAt(1);
if (p1.Name == elementName1 && (p2.Name == elementName2 || mre.MemberName == "GroupJoin"))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(new QueryFromClause {
Identifier = elementName1, Expression = Detach(source1)
});
QueryJoinClause joinClause = new QueryJoinClause();
joinClause.JoinIdentifier = elementName2; // join elementName2
joinClause.InExpression = Detach(source2); // in source2
joinClause.OnExpression = Detach(key1); // on key1
joinClause.EqualsExpression = Detach(key2); // equals key2
if (mre.MemberName == "GroupJoin")
{
joinClause.IntoIdentifier = p2.Name; // into p2.Name
}
query.Clauses.Add(joinClause);
query.Clauses.Add(new QuerySelectClause {
Expression = Detach(((Expression)lambda.Body))
});
return(query);
}
}
return(null);
}
default:
return(null);
}
}
public virtual void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(queryOrderClause);
}
}
public StringBuilder VisitQueryOrderClause(QueryOrderClause queryOrderClause, int data)
{
throw new ASLException("ASL does not understand LINQ.");
}
public override object Visit (Mono.CSharp.Linq.ThenByDescending thenByDescending)
{
var result = new QueryOrderClause ();
var ordering = new QueryOrdering ();
ordering.AddChild ((Expression)thenByDescending.Expr.Accept (this), QueryWhereClause.Roles.Expression);
var location = LocationsBag.GetLocations (thenByDescending);
if (location != null) {
ordering.Direction = QueryOrderingDirection.Descending;
ordering.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
}
result.AddChild (ordering, QueryOrderClause.OrderingRole);
return result;
}
public override void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
base.VisitQueryOrderClause(queryOrderClause);
indexData.HasOrder = true;
}
QueryExpression DecompileQuery(InvocationExpression invocation)
{
if (invocation == null)
{
return(null);
}
MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression;
if (mre == null || IsNullConditional(mre.Target))
{
return(null);
}
switch (mre.MemberName)
{
case "Select": {
if (invocation.Arguments.Count != 1)
{
return(null);
}
if (!IsComplexQuery(mre))
{
return(null);
}
ParameterDeclaration parameter;
Expression body;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameter, out body))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(parameter, mre.Target.Detach()));
query.Clauses.Add(new QuerySelectClause {
Expression = WrapExpressionInParenthesesIfNecessary(body.Detach(), parameter.Name)
});
return(query);
}
return(null);
}
case "GroupBy":
{
if (invocation.Arguments.Count == 2)
{
ParameterDeclaration parameter1, parameter2;
Expression keySelector, elementSelector;
if (MatchSimpleLambda(invocation.Arguments.ElementAt(0), out parameter1, out keySelector) &&
MatchSimpleLambda(invocation.Arguments.ElementAt(1), out parameter2, out elementSelector) &&
parameter1.Name == parameter2.Name)
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(parameter1, mre.Target.Detach()));
query.Clauses.Add(new QueryGroupClause {
Projection = elementSelector.Detach(), Key = keySelector.Detach()
});
return(query);
}
}
else if (invocation.Arguments.Count == 1)
{
ParameterDeclaration parameter;
Expression keySelector;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameter, out keySelector))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(parameter, mre.Target.Detach()));
query.Clauses.Add(new QueryGroupClause {
Projection = new IdentifierExpression(parameter.Name).CopyAnnotationsFrom(parameter), Key = keySelector.Detach()
});
return(query);
}
}
return(null);
}
case "SelectMany":
{
if (invocation.Arguments.Count != 2)
{
return(null);
}
ParameterDeclaration parameter;
Expression collectionSelector;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(0), out parameter, out collectionSelector))
{
return(null);
}
if (IsNullConditional(collectionSelector))
{
return(null);
}
LambdaExpression lambda = invocation.Arguments.ElementAt(1) as LambdaExpression;
if (lambda != null && lambda.Parameters.Count == 2 && lambda.Body is Expression)
{
ParameterDeclaration p1 = lambda.Parameters.ElementAt(0);
ParameterDeclaration p2 = lambda.Parameters.ElementAt(1);
if (p1.Name == parameter.Name)
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(p1, mre.Target.Detach()));
query.Clauses.Add(MakeFromClause(p2, collectionSelector.Detach()));
query.Clauses.Add(new QuerySelectClause {
Expression = WrapExpressionInParenthesesIfNecessary(((Expression)lambda.Body).Detach(), parameter.Name)
});
return(query);
}
}
return(null);
}
case "Where":
{
if (invocation.Arguments.Count != 1)
{
return(null);
}
if (!IsComplexQuery(mre))
{
return(null);
}
ParameterDeclaration parameter;
Expression body;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameter, out body))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(parameter, mre.Target.Detach()));
query.Clauses.Add(new QueryWhereClause {
Condition = body.Detach()
});
return(query);
}
return(null);
}
case "OrderBy":
case "OrderByDescending":
case "ThenBy":
case "ThenByDescending":
{
if (invocation.Arguments.Count != 1)
{
return(null);
}
if (!IsComplexQuery(mre))
{
return(null);
}
ParameterDeclaration parameter;
Expression orderExpression;
if (MatchSimpleLambda(invocation.Arguments.Single(), out parameter, out orderExpression))
{
if (ValidateThenByChain(invocation, parameter.Name))
{
QueryOrderClause orderClause = new QueryOrderClause();
InvocationExpression tmp = invocation;
while (mre.MemberName == "ThenBy" || mre.MemberName == "ThenByDescending")
{
// insert new ordering at beginning
orderClause.Orderings.InsertAfter(
null, new QueryOrdering {
Expression = orderExpression.Detach(),
Direction = (mre.MemberName == "ThenBy" ? QueryOrderingDirection.None : QueryOrderingDirection.Descending)
});
tmp = (InvocationExpression)mre.Target;
mre = (MemberReferenceExpression)tmp.Target;
MatchSimpleLambda(tmp.Arguments.Single(), out parameter, out orderExpression);
}
// insert new ordering at beginning
orderClause.Orderings.InsertAfter(
null, new QueryOrdering {
Expression = orderExpression.Detach(),
Direction = (mre.MemberName == "OrderBy" ? QueryOrderingDirection.None : QueryOrderingDirection.Descending)
});
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(parameter, mre.Target.Detach()));
query.Clauses.Add(orderClause);
return(query);
}
}
return(null);
}
case "Join":
case "GroupJoin":
{
if (invocation.Arguments.Count != 4)
{
return(null);
}
Expression source1 = mre.Target;
Expression source2 = invocation.Arguments.ElementAt(0);
if (IsNullConditional(source2))
{
return(null);
}
ParameterDeclaration element1, element2;
Expression key1, key2;
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(1), out element1, out key1))
{
return(null);
}
if (!MatchSimpleLambda(invocation.Arguments.ElementAt(2), out element2, out key2))
{
return(null);
}
LambdaExpression lambda = invocation.Arguments.ElementAt(3) as LambdaExpression;
if (lambda != null && lambda.Parameters.Count == 2 && lambda.Body is Expression)
{
ParameterDeclaration p1 = lambda.Parameters.ElementAt(0);
ParameterDeclaration p2 = lambda.Parameters.ElementAt(1);
if (p1.Name == element1.Name && (p2.Name == element2.Name || mre.MemberName == "GroupJoin"))
{
QueryExpression query = new QueryExpression();
query.Clauses.Add(MakeFromClause(element1, source1.Detach()));
QueryJoinClause joinClause = new QueryJoinClause();
joinClause.JoinIdentifier = element2.Name; // join elementName2
joinClause.InExpression = source2.Detach(); // in source2
joinClause.OnExpression = key1.Detach(); // on key1
joinClause.EqualsExpression = key2.Detach(); // equals key2
if (mre.MemberName == "GroupJoin")
{
joinClause.IntoIdentifier = p2.Name; // into p2.Name
}
query.Clauses.Add(joinClause);
query.Clauses.Add(new QuerySelectClause {
Expression = ((Expression)lambda.Body).Detach()
});
return(query);
}
}
return(null);
}
default:
return(null);
}
}
public JNode VisitQueryOrderClause(QueryOrderClause node)
{
throw new NotImplementedException();
}
public override object Visit(Mono.CSharp.Linq.OrderByDescending orderByDescending)
{
currentQueryOrderClause = new QueryOrderClause();
var ordering = new QueryOrdering();
if (orderByDescending.Expr != null)
ordering.AddChild((Expression)orderByDescending.Expr.Accept(this), Roles.Expression);
var location = LocationsBag.GetLocations(orderByDescending);
if (location != null) {
ordering.Direction = QueryOrderingDirection.Descending;
ordering.AddChild(new CSharpTokenNode(Convert(location [0]), QueryOrdering.DescendingKeywordRole), QueryOrdering.DescendingKeywordRole);
}
currentQueryOrderClause.AddChild(ordering, QueryOrderClause.OrderingRole);
return currentQueryOrderClause;
}
public override object Visit (Mono.CSharp.Linq.ThenByDescending thenByDescending)
{
var result = new QueryOrderClause ();
/* result.OrderAscending = false;
result.AddChild ((AstNode)thenByDescending.Expr.Accept (this), QueryWhereClause.Roles.Expression);
var location = LocationsBag.GetLocations (thenByDescending);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location[0]), "descending".Length), QueryWhereClause.Roles.Keyword);*/
return result;
}
public void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
StartNode(queryOrderClause);
WriteKeyword(QueryOrderClause.OrderbyKeywordRole);
Space();
WriteCommaSeparatedList(queryOrderClause.Orderings);
EndNode(queryOrderClause);
}
public virtual Node VisitQueryOrderClause(QueryOrderClause queryOrderClause)
{
throw new System.NotImplementedException();
}
