// <summary>
// The only entry point.
// Rewrites the given tree by replacing expressions that are not directly supported on SQL Server 2000
// with alterntive translations.
// </summary>
// <param name="originalTree"> The tree to rewrite </param>
// <returns> The new tree </returns>
internal static DbQueryCommandTree Rewrite(DbQueryCommandTree originalTree)
{
DebugCheck.NotNull(originalTree);
var rewriter = new Sql8ExpressionRewriter(originalTree.MetadataWorkspace);
var newQuery = rewriter.VisitExpression(originalTree.Query);
#if DEBUG
return(new DbQueryCommandTree(originalTree.MetadataWorkspace, originalTree.DataSpace, newQuery));
#else
return(new DbQueryCommandTree(originalTree.MetadataWorkspace, originalTree.DataSpace, newQuery, validate: false));
#endif
}
/// <summary>
/// The only entry point.
/// Rewrites the given tree by replacing expressions that are not directly supported on SQL Server 2000
/// with alterntive translations.
/// </summary>
/// <param name="originalTree">The tree to rewrite</param>
/// <returns>The new tree</returns>
internal static DbQueryCommandTree Rewrite(DbQueryCommandTree originalTree)
{
Debug.Assert(originalTree != null, "OriginalTree is null");
var rewriter = new Sql8ExpressionRewriter(originalTree.MetadataWorkspace);
var newQuery = rewriter.VisitExpression(originalTree.Query);
#if DEBUG
return new DbQueryCommandTree(originalTree.MetadataWorkspace, originalTree.DataSpace, newQuery);
#else
return new DbQueryCommandTree(originalTree.MetadataWorkspace, originalTree.DataSpace, newQuery, validate: false);
#endif
}
private static bool HasMatchInList(
DbPropertyExpression expr,
IList <DbPropertyExpression> list,
string exprBindingVariableName,
string listExpressionsBindingVariableName)
{
for (int index = 0; index < list.Count; ++index)
{
if (Sql8ExpressionRewriter.AreMatching(expr, list[index], exprBindingVariableName, listExpressionsBindingVariableName))
{
list.RemoveAt(index);
return(true);
}
}
return(false);
}
private static bool RemoveNonSortProperties(
IList <DbPropertyExpression> list1,
IList <DbPropertyExpression> list2,
IList <DbPropertyExpression> sortList,
string list1BindingVariableName,
string sortExpressionsBindingVariableName)
{
bool flag = false;
for (int index = list1.Count - 1; index >= 0; --index)
{
if (!Sql8ExpressionRewriter.HasMatchInList(list1[index], sortList, list1BindingVariableName, sortExpressionsBindingVariableName))
{
list1.RemoveAt(index);
list2.RemoveAt(index);
flag = true;
}
}
return(flag);
}
private static bool AreMatching(
DbPropertyExpression expr1,
DbPropertyExpression expr2,
string expr1BindingVariableName,
string expr2BindingVariableName)
{
if (expr1.Property.Name != expr2.Property.Name || expr1.Instance.ExpressionKind != expr2.Instance.ExpressionKind)
{
return(false);
}
if (expr1.Instance.ExpressionKind == DbExpressionKind.Property)
{
return(Sql8ExpressionRewriter.AreMatching((DbPropertyExpression)expr1.Instance, (DbPropertyExpression)expr2.Instance, expr1BindingVariableName, expr2BindingVariableName));
}
DbVariableReferenceExpression instance1 = (DbVariableReferenceExpression)expr1.Instance;
DbVariableReferenceExpression instance2 = (DbVariableReferenceExpression)expr2.Instance;
if (string.Equals(instance1.VariableName, expr1BindingVariableName, StringComparison.Ordinal))
{
return(string.Equals(instance2.VariableName, expr2BindingVariableName, StringComparison.Ordinal));
}
return(false);
}
private DbExpression TransformIntersectOrExcept(
DbExpression left,
DbExpression right,
DbExpressionKind expressionKind,
IList <DbPropertyExpression> sortExpressionsOverLeft,
string sortExpressionsBindingVariableName)
{
bool flag1 = expressionKind == DbExpressionKind.Except || expressionKind == DbExpressionKind.Skip;
bool flag2 = expressionKind == DbExpressionKind.Except || expressionKind == DbExpressionKind.Intersect;
DbExpressionBinding input = left.Bind();
DbExpressionBinding expressionBinding = right.Bind();
IList <DbPropertyExpression> propertyExpressionList1 = (IList <DbPropertyExpression>) new List <DbPropertyExpression>();
IList <DbPropertyExpression> propertyExpressionList2 = (IList <DbPropertyExpression>) new List <DbPropertyExpression>();
this.FlattenProperties((DbExpression)input.Variable, propertyExpressionList1);
this.FlattenProperties((DbExpression)expressionBinding.Variable, propertyExpressionList2);
if (expressionKind == DbExpressionKind.Skip && Sql8ExpressionRewriter.RemoveNonSortProperties(propertyExpressionList1, propertyExpressionList2, sortExpressionsOverLeft, input.VariableName, sortExpressionsBindingVariableName))
{
expressionBinding = Sql8ExpressionRewriter.CapWithProject(expressionBinding, propertyExpressionList2);
}
DbExpression dbExpression1 = (DbExpression)null;
for (int index = 0; index < propertyExpressionList1.Count; ++index)
{
DbExpression right1 = (DbExpression)propertyExpressionList1[index].Equal((DbExpression)propertyExpressionList2[index]).Or((DbExpression)propertyExpressionList1[index].IsNull().And((DbExpression)propertyExpressionList2[index].IsNull()));
dbExpression1 = index != 0 ? (DbExpression)dbExpression1.And(right1) : right1;
}
DbExpression dbExpression2 = (DbExpression)expressionBinding.Any(dbExpression1);
DbExpression predicate = !flag1 ? dbExpression2 : (DbExpression)dbExpression2.Not();
DbExpression dbExpression3 = (DbExpression)input.Filter(predicate);
if (flag2)
{
dbExpression3 = (DbExpression)dbExpression3.Distinct();
}
return(dbExpression3);
}
internal static DbQueryCommandTree Rewrite(DbQueryCommandTree originalTree)
{
DbExpression query = new Sql8ExpressionRewriter(originalTree.MetadataWorkspace).VisitExpression(originalTree.Query);
return(new DbQueryCommandTree(originalTree.MetadataWorkspace, originalTree.DataSpace, query, false));
}
