public static bool IsJoinExpression(this VfpExpression e)
{
return(VfpExpressionKind.CrossJoin == e.ExpressionKind ||
VfpExpressionKind.FullOuterJoin == e.ExpressionKind ||
VfpExpressionKind.InnerJoin == e.ExpressionKind ||
VfpExpressionKind.LeftOuterJoin == e.ExpressionKind);
}
public static VfpExpression Rewrite(VfpProviderManifest vfpManifest, VfpExpression expression)
{
expression = RedundantCaseExpressionRemover.Remove(expression);
expression = FlattenFilterRewritter.Rewrite(expression);
expression = ApplyRewritter.Rewrite(expression);
expression = InRewritter.Rewrite(expression);
expression = XmlToCursorRewritter.Rewrite(expression);
//expression = XmlToCursorMoveToInnerExpressionRewriter.Rewrite(expression);
expression = XmlToCursorJoinRewriter.Rewrite(expression);
expression = ComparisonRewritter.Rewrite(expression);
expression = LikeRewritter.Rewrite(expression);
expression = LikeCRewritter.Rewrite(expression);
expression = CaseWithNullRewriter.Rewrite(expression);
expression = SingleRowTableRewritter.Rewrite(expression);
expression = MissingOrderByRewritter.Rewrite(expression);
expression = VariableReferenceRewritter.Rewrite(expression);
expression = ConstantToParameterRewritter.Rewrite(expression);
expression = FilterProjectRewritter.Rewrite(expression);
expression = DecimalPropertyRewritter.Rewrite(vfpManifest, expression);
return(expression);
}
public static ReadOnlyCollection <EntityType> Gather(VfpExpression expression)
{
var visitor = new EntityTypeGatherer();
visitor.Visit(expression);
return(visitor._entityTypes.AsReadOnly());
}
public static ReadOnlyCollection <VfpParameterExpression> Gather(VfpExpression expression)
{
var visitor = new ParameterGatherer();
visitor.Visit(expression);
return(visitor._expressions.AsReadOnly());
}
public static VfpExpression Rewrite(VfpExpression expression)
{
var rewriter = new MissingOrderByRewritter {
_rootExpression = expression
};
return(rewriter.Visit(expression));
}
public static bool CanRewrite(VfpExpression expression)
{
var rewriter = new VfpPropertyExpressionChecker();
rewriter.Visit(expression);
return(rewriter._canRewrite);
}
private IEnumerable <XmlToCursorData> GetXmlToCursors(VfpExpression expression)
{
return(XmlToCursorExpressionGatherer.Gather(expression)
.Where(x => !x.CursorName.StartsWith(XmlToCursorMoveToInnerExpressionRewriter.CursorNamePrefix)) // TODO: figure out how to rewrite these as inner joins
.Select(x => new XmlToCursorData(x))
.Where(x => x.TableProperty != null)
.Select(x => x).ToList().AsReadOnly());
}
public static ReadOnlyCollection <VfpConstantExpression> Gather(VfpExpression expression)
{
var visitor = new ConstantGatherer();
visitor.Visit(expression);
return(visitor._expressions.AsReadOnly());
}
internal static VfpExpression Rewrite(VfpExpression expression)
{
var rewriter = new XmlToCursorJoinRewriter(expression);
expression = rewriter.Visit(expression);
return(expression);
}
public static VfpExpression Remove(VfpExpression expression, string cursorName)
{
ArgumentUtility.CheckNotNullOrEmpty("cursorName", cursorName);
var visitor = new XmlToCursorExpressionRemover(cursorName);
return(visitor.Visit(expression));
}
public static ReadOnlyCollection <VfpVariableReferenceExpression> Gather(VfpExpression expression)
{
var visitor = new VariableReferenceGatherer();
visitor.Visit(expression);
return(visitor._expressions.AsReadOnly());
}
private static bool IsDecimalPropertyExpression(VfpExpression expression)
{
if (expression == null || expression.ExpressionKind != VfpExpressionKind.Property)
{
return(false);
}
return(expression.ResultType.IsPrimitiveType() && expression.ResultType.ToPrimitiveTypeKind() == PrimitiveTypeKind.Decimal);
}
protected virtual VfpExpression VisitPredicate(VfpExpression expr)
{
Visit(expr);
if (!IsPredicate(expr))
{
Write(" <> 0");
}
return(expr);
}
public static string Format(VfpProviderManifest vfpManifest, VfpExpression expression, out List <DbParameter> parameters)
{
expression = ExpressionRewritter.Rewrite(vfpManifest, expression);
var formatter = new SqlFormatter();
formatter.Visit(expression);
parameters = formatter.parameters;
return(formatter.ToString());
}
public static ReadOnlyCollection <VfpXmlToCursorExpression> Gather(VfpExpression expression)
{
var visitor = new XmlToCursorExpressionGatherer();
visitor.Visit(expression);
if (!visitor._canRewrite)
{
visitor._expressions.Clear();
}
return(visitor._expressions.AsReadOnly());
}
private static List <DbParameter> GetParameters(VfpExpression expression)
{
var parameterExpressions = ParameterGatherer.Gather(expression);
if (parameterExpressions.Any())
{
var parameterHelper = new VfpParameterHelper();
return(parameterExpressions.Select(x => parameterHelper.CreateVfpParameter(x.Name, x.ResultType, ParameterMode.In, x.Value.Value)).Cast <DbParameter>().ToList());
}
return(new List <DbParameter>());
}
public static bool IsPropertyOverVarRef(this VfpExpression expression)
{
var propertyExpression = expression as VfpPropertyExpression;
if (propertyExpression == null)
{
return(false);
}
var varRefExpression = propertyExpression.Instance as VfpVariableReferenceExpression;
return(varRefExpression != null);
}
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);
}
internal static VfpExpression Rewrite(VfpExpression expression)
{
var rewriter = new XmlToCursorMoveToInnerExpressionRewriter(expression);
if (!rewriter._xmlToCursors.Any())
{
return(expression);
}
expression = rewriter.Visit(expression);
foreach (var cursorName in rewriter._xmlToCursorsToBeRemoved)
{
expression = XmlToCursorExpressionRemover.Remove(expression, cursorName);
}
return(expression);
}
private VfpExpression GetVfpExpression(VfpExpression expression)
{
if (!IsDecimalPropertyExpression(expression))
{
return(expression);
}
var scale = GetScale(expression.ResultType);
if (scale == 0)
{
return(expression);
}
var castTypeUsage = _vfpManifest.GetDecimalTypeUsage(20, scale);
return(expression.Cast(castTypeUsage));
}
/// <summary>
/// Call this method to register a property value pair so the translator "remembers"
/// the values for members of the row being modified. These values can then be used
/// to form a predicate for server-generation (based on the key of the row)
/// </summary>
/// <param name="propertyExpression">VfpExpression containing the column reference (property expression).</param>
/// <param name="value">VfpExpression containing the value of the column.</param>
internal void RegisterMemberValue(VfpExpression propertyExpression, VfpExpression value)
{
if (memberValues == null)
{
return;
}
// register the value for this property
Debug.Assert(propertyExpression.ExpressionKind == VfpExpressionKind.Property, "DML predicates and setters must be of the form property = value");
// get name of left property
var property = ((VfpPropertyExpression)propertyExpression).Property;
// don't track null values
if (value.ExpressionKind == VfpExpressionKind.Null)
{
return;
}
Debug.Assert(value.ExpressionKind == VfpExpressionKind.Constant, "value must either constant or null");
// retrieve the last parameter added (which describes the parameter)
memberValues[property] = parameters[parameters.Count - 1];
}
protected virtual bool IsPredicate(VfpExpression expr)
{
switch (expr.ExpressionKind)
{
case VfpExpressionKind.And:
case VfpExpressionKind.Or:
return(((VfpBinaryExpression)expr).ResultType.IsBoolean());
case VfpExpressionKind.Not:
return(((VfpUnaryExpression)expr).ResultType.IsBoolean());
case VfpExpressionKind.Equals:
case VfpExpressionKind.NotEquals:
case VfpExpressionKind.LessThan:
case VfpExpressionKind.LessThanOrEquals:
case VfpExpressionKind.GreaterThan:
case VfpExpressionKind.GreaterThanOrEquals:
case VfpExpressionKind.IsNull:
return(true);
default:
return(false);
}
}
public static VfpExpression Rewrite(VfpExpression expression)
{
var rewriter = new VariableReferenceRewritter();
return(rewriter.Visit(expression));
}
private static IEnumerable <XmlToCursorData> GetXmlToCursorsThatHaveNestedProperties(VfpExpression expression)
{
return(XmlToCursorExpressionGatherer.Gather(expression)
.Select(x => new XmlToCursorData(x))
.Where(x => x.TableProperty != null)
.Where(x => x.TableProperty.Instance is VfpPropertyExpression)
.Select(x => x));
}
private XmlToCursorMoveToInnerExpressionRewriter(VfpExpression expression)
{
_xmlToCursors = GetXmlToCursorsThatHaveNestedProperties(expression).GroupBy(x => x.TableProperty.Property.Name, x => x)
.ToDictionary(x => x.Key, x => x.ToList());
}
public static VfpExpression Rewrite(VfpExpression expression)
{
var rewriter = new SingleRowTableRewritter();
return(rewriter.Visit(expression));
}
private XmlToCursorJoinRewriter(VfpExpression expression)
{
_xmlToCursors = GetXmlToCursors(expression).GroupBy(x => x.TableProperty.Property.Name, x => x)
.ToDictionary(x => x.Key, x => x.ToList());
}
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 static VfpExpression Replace(VfpVariableReferenceExpression variableReferenceExpression, VfpExpression expression)
{
var rewriter = new VariableReferenceReplacer(variableReferenceExpression);
return(rewriter.Visit(expression));
}
public static VfpExpression Remove(VfpExpression expression)
{
return(new RedundantCaseExpressionRemover().Visit(expression));
}