/// <summary>
/// Translate the expression "first", there must be an expression on the
/// translation reference.
/// </summary>
/// <param name="m"></param>
private void TranslateFirst(MethodCallExpression m, Boolean defaultIfNull)
{
Debug.Assert(Translation != null, "Cannot apply first without a query");
Translation = new FirstQueryTranslated(this)
{
Criteria = rootCriteria, DefaultIfNull = defaultIfNull
};
}
public QueryTranslator(ICriteria criteria)
{
rootCriteria = criteria;
Translation = new QueryTranslated(this)
{
Criteria = rootCriteria
};
this.row = Expression.Parameter(typeof(Linq.Visitors.Select.ProjectionResult), "row");
}
/// <summary>
/// Handle projection of aggregate, an aggregate is a SUm, Max or other stuff, it is valid only
/// if is a single projection
/// </summary>
/// <param name="m"></param>
private void HandleProjectionOfSingleElement(
System.Linq.Expressions.MethodCallExpression m,
Func <String, NHEX.IProjection> createProjection)
{
if (m.Arguments.Count == 2)
{
throw new ApplicationException("Cannot handle composite aggregation");
//Select.PostfixSelectVisitor svst = new Select.PostfixSelectVisitor(row, s => NHEX.Projections.Property(s));
//svst.Visit(Linq.Utils.Expression.StripQuotes(m.Arguments[1]));
//projectedProperties.AddLast(svst.ProjectionsPropertyNames[0]);
//Linq.Utils.NHibernate.AddProjectionToCriteria(
// createProjection(svst.ProjectionsPropertyNames[0]), rootCriteria);
}
Translation = new AggregateQueryTranslated(this, createProjection)
{
Criteria = rootCriteria
};
}
/// <summary>
/// Translate the expression "first", there must be an expression on the
/// translation reference.
/// </summary>
/// <param name="m"></param>
private void TranslateSingle(MethodCallExpression m, Boolean defaultIfNull)
{
Debug.Assert(Translation != null, "Cannot apply first without a query");
if (defaultIfNull)
{
Translation = new SingleOrDefaultQueryTranslated(this)
{
Criteria = rootCriteria
}
}
;
else
{
Translation = new SingleQueryTranslated(this)
{
Criteria = rootCriteria
}
};
}
}
protected override Expression VisitMethodCall(MethodCallExpression m)
{
if (m.Method.DeclaringType == typeof(Queryable) ||
m.Method.DeclaringType == typeof(Enumerable))
{
switch (m.Method.Name)
{
case "Where":
WhereArgumentsVisitor vst = new WhereArgumentsVisitor(rootCriteria);
System.Linq.Expressions.Expression exp = vst.Visit(m.Arguments[1]);
rootCriteria.Add(vst.CurrentCriterions[0]);
break;
case "Select":
HandleSelect(m);
break;
case "First":
TranslateFirst(m, false);
break;
case "FirstOrDefault":
TranslateFirst(m, true);
break;
case "Single":
TranslateSingle(m, false);
break;
case "SingleOrDefault":
TranslateSingle(m, true);
break;
case "Count":
Translation = new CountQueryTranslated(this)
{
Criteria = rootCriteria
};
break;
case "Sum":
HandleProjectionOfSingleElement(m, s => NHEX.Projections.Sum(s));
break;
case "Min":
HandleProjectionOfSingleElement(m, s => NHEX.Projections.Min(s));
break;
case "Max":
HandleProjectionOfSingleElement(m, s => NHEX.Projections.Max(s));
break;
case "Average":
HandleProjectionOfSingleElement(m, s => NHEX.Projections.Avg(s));
break;
case "GroupBy":
HandleGroupBy(m);
break;
default:
Console.WriteLine("Unknown method " + m.Method.Name);
break;
}
}
return(base.VisitMethodCall(m));
}
