public override VfpExpression Visit(VfpFilterExpression expression)
{
var isEmptyExpression = expression.Predicate as VfpIsEmptyExpression;
if (isEmptyExpression == null)
{
return(base.Visit(expression));
}
var projectExpression = isEmptyExpression.Argument as VfpProjectExpression;
if (projectExpression == null)
{
return(base.Visit(expression));
}
var filterExpression = projectExpression.Input.Expression as VfpFilterExpression;
var variables = VariableReferenceGatherer.Gather(filterExpression);
if (variables.All(x => expression.Input.VariableName != x.VariableName))
{
return(base.Visit(expression));
}
// TODO: verify inner join
//var joinExpression = VfpExpression.Join(VfpExpressionKind.InnerJoin, expression.ResultType, expression.Input, filterExpression.Input, filterExpression.Predicate);
//var binding = VfpExpression.Binding(joinExpression, VfpExpression.VariableRef(PrimitiveTypeKind.String.ToTypeUsage(), "X" + (++_count)));
//return base.Visit(binding);
return(base.Visit(expression));
}
private static VfpExpression GetProjection(VfpFilterExpression filterExpression, string filterVariableName, VfpExpression projectionExpression)
{
var newInstanceExpression = projectionExpression as VfpNewInstanceExpression;
if (newInstanceExpression == null)
{
return(projectionExpression);
}
var newInstanceVariableNames = VariableReferenceGatherer.Gather(newInstanceExpression)
.Select(x => x.VariableName)
.Distinct()
.ToArray();
if (newInstanceVariableNames.Length != 1)
{
return(projectionExpression);
}
if (filterVariableName != newInstanceVariableNames.First())
{
return(projectionExpression);
}
return(VariableReferenceReplacer.Replace(filterExpression.Input.Variable, newInstanceExpression));
}
public override VfpExpression Visit(VfpOrExpression expression)
{
var list = OrComparisonGatherer.Gather(expression);
if (!list.Any())
{
return(base.Visit(expression));
}
var comparison = list.Select(x => new {
x.ExpressionKind,
LeftExpression = x.Left,
LeftDbConstantExpression = ConstantGatherer.Gather(x.Left).FirstOrDefault(),
RightExpression = x.Right,
RightDbPropertyExpression = PropertyGatherer.Gather(x.Right).FirstOrDefault(),
RightDbVariableReferenceExpression = VariableReferenceGatherer.Gather(x.Right).FirstOrDefault()
}).First();
if (comparison.ExpressionKind != VfpExpressionKind.Equals && comparison.ExpressionKind != VfpExpressionKind.NotEquals)
{
return(base.Visit(expression));
}
if (comparison.LeftDbConstantExpression == null || comparison.RightDbPropertyExpression == null || comparison.RightDbVariableReferenceExpression == null)
{
return(base.Visit(expression));
}
var expressions = list.Select(x => new {
x.ExpressionKind,
LeftExpression = x.Left,
LeftDbConstantExpression = ConstantGatherer.Gather(x.Left).FirstOrDefault(),
RightExpression = x.Right,
RightDbPropertyExpression = PropertyGatherer.Gather(x.Right).FirstOrDefault(),
RightDbVariableReferenceExpression = VariableReferenceGatherer.Gather(x.Right).FirstOrDefault()
})
.Where(x => x.LeftDbConstantExpression != null)
.Where(x => x.RightDbPropertyExpression != null)
.Where(x => x.RightDbVariableReferenceExpression != null)
.ToList();
if (list.Count != expressions.Count)
{
return(base.Visit(expression));
}
if (!expressions.All(x => x.LeftDbConstantExpression.ConstantKind == comparison.LeftDbConstantExpression.ConstantKind &&
x.LeftDbConstantExpression.ResultType == comparison.LeftDbConstantExpression.ResultType &&
x.RightDbPropertyExpression.Property == comparison.RightDbPropertyExpression.Property &&
x.RightDbVariableReferenceExpression.VariableName == comparison.RightDbVariableReferenceExpression.VariableName))
{
return(base.Visit(expression));
}
var inExpression = comparison.RightExpression.In(list.Select(x => x.Left).ToList().List());
return(base.Visit(inExpression));
}
private static VfpExpressionBinding GetSortBinding(IEnumerable <EdmMember> keyMembers, VfpExpressionBinding binding, VfpExpression expression)
{
var allVarialbes = VariableReferenceGatherer.Gather(expression).ToList();
var entityTypeVariables = allVarialbes.Where(x => x.ResultType.EdmType is EntityType).ToList().GroupBy(x => x.VariableName).Select(x => x.First()).ToList();
var keyMembersWithVariables = keyMembers.Join(entityTypeVariables, x => x.DeclaringType, x => x.ResultType.EdmType, (k, v) => new { KeyMember = k, Variable = v }).ToList();
var sortClauses = keyMembersWithVariables.Select(x => new VfpSortClause(new VfpPropertyVariableNameExpression(x.KeyMember.TypeUsage, x.KeyMember, x.Variable.VariableName), true, string.Empty)).ToList();
var sortExpression = binding.Sort(sortClauses);
return(sortExpression.BindAs(binding.Variable));
}
private static VfpExpression GetScanProperty(VfpVariableReferenceExpression variable, VfpExpression property)
{
var expression = VariableReferenceReplacer.Replace(variable, property);
var scanProperty = expression as VfpPropertyExpression;
if (scanProperty == null)
{
return(expression);
}
var variables = VariableReferenceGatherer.Gather(expression);
if (!variables.Any())
{
return(expression);
}
var scanVariable = variables.First();
return(scanVariable.Property(scanProperty.ResultType, scanProperty.Property));
}
public override VfpExpression Visit(VfpFilterExpression expression)
{
expression = (VfpFilterExpression)base.Visit(expression);
var innerFilter = expression.Input.Expression as VfpFilterExpression;
if (innerFilter == null)
{
return(expression);
}
var variables = VariableReferenceGatherer.Gather(innerFilter.Predicate);
if (!variables.Any() || variables.Select(x => x.VariableName).Distinct().Count() > 1)
{
return(expression);
}
var predicate = VariableReferenceReplacer.Replace(variables.First(), expression.Predicate);
return(innerFilter.Input.Filter(predicate.And(innerFilter.Predicate)));
}
private IList <string> GetVariableNames()
{
var list = VariableReferenceGatherer.Gather(_rootExpression);
return(list.Select(x => x.VariableName).ToList());
}
