protected void VisitSource(VfpExpressionBinding source)
{
//bool saveIsNested = this.isNested;
//this.isNested = true;
//switch ((VfpExpressionType)source.NodeType) {
// case VfpExpressionType.Table:
// TableExpression table = (TableExpression)source;
// this.WriteTableName(table.Name);
// if (!this.HideTableAliases) {
// this.Write(" ");
// this.WriteAsAliasName(GetAliasName(table.Alias));
// }
// break;
// case VfpExpressionType.Select:
// SelectExpression select = (SelectExpression)source;
// this.Write("(");
// this.WriteLine(Indentation.Inner);
// this.Visit(select);
// this.WriteLine(Indentation.Same);
// this.Write(") ");
// this.WriteAsAliasName(GetAliasName(select.Alias));
// this.Indent(Indentation.Outer);
// break;
// case VfpExpressionType.Join:
// this.VisitJoin((JoinExpression)source);
// break;
// default:
// throw new InvalidOperationException("Select source is not valid type");
//}
//this.isNested = saveIsNested;
}
protected override VfpExpressionBinding VisitVfpExpressionBinding(VfpExpressionBinding binding)
{
var entityType = binding.VariableType.EdmType as EntityType;
if (entityType != null)
{
_entityTypes.Add(entityType);
}
return(base.VisitVfpExpressionBinding(binding));
}
protected override VfpExpressionBinding VisitVfpExpressionBinding(VfpExpressionBinding binding)
{
binding = base.VisitVfpExpressionBinding(binding);
var filterExpression = binding.Expression as VfpFilterExpression;
if (filterExpression == null)
{
return(binding);
}
var project = filterExpression.Input.Expression as VfpProjectExpression;
if (project == null)
{
return(binding);
}
var scan = project.Input.Expression as VfpScanExpression;
if (scan == null)
{
return(binding);
}
var newInstance = project.Projection as VfpNewInstanceExpression;
if (newInstance == null)
{
return(binding);
}
var properties = newInstance.Arguments.OfType <VfpPropertyExpression>().ToList().AsReadOnly();
if (!properties.Any())
{
return(binding);
}
if (!VfpPropertyExpressionChecker.CanRewrite(filterExpression.Predicate))
{
return(binding);
}
var newFilterPredicate = VfpPropertyExpressionRewriter.Rewrite(filterExpression.Predicate, properties);
var newFilterExpression = project.Input.Filter(newFilterPredicate);
var newFilterBinding = newFilterExpression.BindAs(binding.Variable.VariableName);
var newProjection = VfpVariableReferenceExpressionRewriter.Rewrite(project.Projection, binding.Variable);
var newProjectExpression = newFilterBinding.Project(newProjection);
var newBinding = newProjectExpression.BindAs(binding.Variable.VariableName);
return(newBinding);
}
private static IEnumerable <EdmMember> GetKeyMembers(VfpExpressionBinding expressionBinding, VfpExpression expression)
{
var keyMembers = GetKeyMembers(expressionBinding.VariableType.EdmType);
if (keyMembers.Any())
{
return(keyMembers);
}
var entityTypes = EntityTypeGatherer.Gather(expression);
return(GetKeyMembers(entityTypes));
}
protected override VfpExpressionBinding VisitVfpExpressionBinding(VfpExpressionBinding binding)
{
binding = base.VisitVfpExpressionBinding(binding);
if (!_xmlToCursors.ContainsKey(binding.VariableName))
{
return(binding);
}
var xmlToCursors = _xmlToCursors[binding.VariableName];
if (!xmlToCursors.Any())
{
return(binding);
}
var scan = binding.Expression as VfpScanExpression;
if (scan == null)
{
return(binding);
}
var scanBinding = scan.BindAs(CursorNamePrefix + (_count++));
VfpExpression predicate = null;
foreach (var xmlToCursor in xmlToCursors)
{
var scanProperty = scanBinding.Variable.Property(xmlToCursor.ColumnProperty.Property);
var xmlToCursorExpression = VfpExpressionBuilder.XmlToCursor(scanProperty, xmlToCursor.XmlToCursor.Parameter, CursorNamePrefix + xmlToCursor.XmlToCursor.CursorName, xmlToCursor.XmlToCursor.ItemType);
_xmlToCursorsToBeRemoved.Add(xmlToCursor.XmlToCursor.CursorName);
if (predicate == null)
{
predicate = xmlToCursorExpression;
}
else
{
predicate = predicate.And(xmlToCursorExpression);
}
}
var filter = scanBinding.Filter(predicate);
var filterBinding = filter.BindAs(binding.Variable.VariableName);
return(filterBinding);
}
private VfpLimitExpression GetVfpLimitExpression(VfpLimitExpression limitExpression, VfpScanExpression scanExpression)
{
if (scanExpression == null)
{
return(null);
}
var keyMembers = GetKeyMembers(scanExpression.Target.ElementType.KeyMembers);
if (!keyMembers.Any())
{
return(null);
}
var variableReference = new VfpVariableReferenceExpression(scanExpression.ResultType, GetUniqueVariableName());
var expressionBinding = new VfpExpressionBinding(scanExpression, variableReference);
var sortClauses = GetSortClauses(keyMembers, expressionBinding).ToList().AsReadOnly();
var sortExpression = new VfpSortExpression(scanExpression.ResultType, expressionBinding, sortClauses);
return(new VfpLimitExpression(limitExpression.ResultType,
sortExpression,
limitExpression.Limit,
limitExpression.WithTies));
}
protected override VfpExpressionBinding VisitVfpExpressionBinding(VfpExpressionBinding binding)
{
var isFilterBinding = binding.Expression is VfpFilterExpression;
if (isFilterBinding)
{
_filterBindings.Push(binding);
}
binding = base.VisitVfpExpressionBinding(binding);
if (isFilterBinding)
{
var expression = binding.Expression;
foreach (var cursorName in _xmlToCursorsToBeRemoved)
{
expression = XmlToCursorExpressionRemover.Remove(expression, cursorName);
}
_xmlToCursorsToBeRemoved.Clear();
_filterBindings.Pop();
binding = expression.BindAs(binding.Variable.VariableName);
}
if (!_filterBindings.Any())
{
return(binding);
}
var filterBinding = _filterBindings.Peek();
if (filterBinding == null)
{
return(binding);
}
var scan = binding.Expression as VfpScanExpression;
if (scan == null)
{
return(binding);
}
if (!_xmlToCursors.ContainsKey(binding.VariableName))
{
return(binding);
}
var xmlToCursors = _xmlToCursors[binding.VariableName];
if (!xmlToCursors.Any())
{
return(binding);
}
foreach (var xmlToCursor in xmlToCursors)
{
var xmlToCursorExpression = xmlToCursor.XmlToCursor;
_count++;
var variableReference = xmlToCursorExpression.ItemType.ToTypeUsage().Variable("Xml" + _count);
var xmlToCursorScan = VfpExpressionBuilder.XmlToCursorScan(xmlToCursorExpression.Parameter, xmlToCursorExpression.CursorName + "_j");
var xmlToCursorBinding = xmlToCursorScan.BindAs(variableReference.VariableName);
var xmlToCursorProperty = VfpExpressionBuilder.XmlToCursorProperty(variableReference.ResultType, variableReference);
var scanProperty = GetScanProperty(binding.Variable, xmlToCursorExpression.Property);
var comparison = scanProperty.ExpressionEquals(xmlToCursorProperty);
var joinVariableReference = binding.VariableType.Variable(binding.VariableName);
var joinExpression = binding.InnerJoin(xmlToCursorBinding, comparison, binding.Expression.ResultType);
_xmlToCursorsToBeRemoved.Add(xmlToCursorExpression.CursorName);
binding = joinExpression.BindAs(joinVariableReference.VariableName);
}
return(binding);
}
private static IEnumerable <VfpSortClause> GetSortClauses(IEnumerable <EdmMember> keyMembers, VfpExpressionBinding expressionBinding)
{
return(keyMembers.Select(x => new VfpSortClause(new VfpPropertyExpression(x.TypeUsage, x, expressionBinding.Variable), true, string.Empty)));
}
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 bool IsSingleRowTable(VfpExpressionBinding expression) {
return expression.VariableName.StartsWith("SingleRowTable");
}
private static VfpJoinExpression CreateJoin(VfpExpressionBinding left, VfpExpressionBinding right) {
var comparison = VfpExpressionBuilder.Constant(1).ExpressionEquals(VfpExpressionBuilder.Constant(1));
return left.LeftJoin(right, comparison, right.VariableType);
}
protected virtual VfpExpressionBinding VisitVfpExpressionBinding(VfpExpressionBinding binding)
{
return(new VfpExpressionBinding(binding.Expression.Accept(this), (VfpVariableReferenceExpression)binding.Variable.Accept(this)));
}
