public override LegacyCommandTrees.DbExpression Visit(DbArithmeticExpression expression)
{
Debug.Assert(expression != null, "expression != null");
switch (expression.ExpressionKind)
{
case DbExpressionKind.Plus:
return(expression.Arguments[0].Accept(this).Plus(expression.Arguments[1].Accept(this)));
case DbExpressionKind.Minus:
return(expression.Arguments[0].Accept(this).Minus(expression.Arguments[1].Accept(this)));
case DbExpressionKind.Multiply:
return(expression.Arguments[0].Accept(this).Multiply(expression.Arguments[1].Accept(this)));
case DbExpressionKind.Divide:
return(expression.Arguments[0].Accept(this).Divide(expression.Arguments[1].Accept(this)));
case DbExpressionKind.Modulo:
return(expression.Arguments[0].Accept(this).Modulo(expression.Arguments[1].Accept(this)));
case DbExpressionKind.UnaryMinus:
return(expression.Arguments[0].Accept(this).UnaryMinus());
}
Debug.Fail("Unknown arithmetic operator.");
throw new NotSupportedException();
}
public override void Visit(DbArithmeticExpression expression)
{
Write(expression);
_depth++;
Write("Arguments", expression.Arguments);
_depth--;
}
public override void Visit(DbArithmeticExpression e)
{
Check.NotNull <DbArithmeticExpression>(e, nameof(e));
this.Begin((DbExpression)e);
this.Dump((IEnumerable <DbExpression>)e.Arguments, "Arguments", "Argument");
this.End((DbExpression)e);
}
public override SqlFragment Visit(DbArithmeticExpression expression)
{
if (expression.ExpressionKind == DbExpressionKind.UnaryMinus)
{
ListFragment f = new ListFragment();
f.Append("-(");
f.Append(expression.Arguments[0].Accept(this));
f.Append(")");
return(f);
}
string op = String.Empty;
switch (expression.ExpressionKind)
{
case DbExpressionKind.Divide:
op = "/"; break;
case DbExpressionKind.Minus:
op = "-"; break;
case DbExpressionKind.Modulo:
op = "%"; break;
case DbExpressionKind.Multiply:
op = "*"; break;
case DbExpressionKind.Plus:
op = "+"; break;
default:
throw new NotSupportedException();
}
return(VisitBinaryExpression(expression.Arguments[0], expression.Arguments[1], op));
}
public override ISqlFragment Visit(DbArithmeticExpression e)
{
switch (e.ExpressionKind)
{
case DbExpressionKind.Plus:
return(VisitBinaryExpression("+", e.Arguments[0], e.Arguments[1]));
case DbExpressionKind.Minus:
return(VisitBinaryExpression("-", e.Arguments[0], e.Arguments[1]));
case DbExpressionKind.Multiply:
return(VisitBinaryExpression("*", e.Arguments[0], e.Arguments[1]));
case DbExpressionKind.Divide:
return(VisitBinaryExpression("/", e.Arguments[0], e.Arguments[1]));
case DbExpressionKind.Modulo:
return(VisitFunction("mod", e.Arguments[0], e.Arguments[1]));
case DbExpressionKind.UnaryMinus:
return(new SqlBuilder(" -(", e.Arguments[0].Accept(this), ")"));
default:
throw new InvalidOperationException();
}
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbArithmeticExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbArithmeticExpression"/> that is visited.</param>
public override void Visit(DbArithmeticExpression expression)
{
foreach (DbExpression ex in expression.Arguments)
{
ex.Accept(this);
}
}
public override void Visit(DbArithmeticExpression expression)
{
if (expression == null)
{
throw new ArgumentException("expression");
}
VisitExpressionList(expression.Arguments);
}
public override void Visit(DbArithmeticExpression e)
{
Check.NotNull(e, "e");
Begin(e);
Dump(e.Arguments, "Arguments", "Argument");
End(e);
}
public override object Visit(DbArithmeticExpression expression)
{
foreach (var arg in expression.Arguments)
{
this.Visit(arg);
}
return(null);
}
public override TreeNode Visit(DbArithmeticExpression e)
{
Check.NotNull <DbArithmeticExpression>(e, nameof(e));
if (DbExpressionKind.UnaryMinus != e.ExpressionKind)
{
return(this.VisitInfix(e.Arguments[0], ExpressionPrinter.PrinterVisitor._opMap[e.ExpressionKind], e.Arguments[1]));
}
return(this.Visit(ExpressionPrinter.PrinterVisitor._opMap[e.ExpressionKind], e.Arguments[0]));
}
public override void Visit(DbArithmeticExpression e)
{
VisitExprKind(e.ExpressionKind);
foreach (var a in e.Arguments)
{
_key.Append('(');
a.Accept(this);
_key.Append(')');
}
}
public override TreeNode Visit(DbArithmeticExpression e)
{
if (DbExpressionKind.UnaryMinus == e.ExpressionKind)
{
return(this.Visit(_opMap[e.ExpressionKind], e.Arguments[0]));
}
else
{
return(this.VisitInfix(e, e.Arguments[0], _opMap[e.ExpressionKind], e.Arguments[1]));
}
}
public override void Visit(DbArithmeticExpression e)
{
Check.NotNull <DbArithmeticExpression>(e, nameof(e));
this.VisitExprKind(e.ExpressionKind);
foreach (DbExpression dbExpression in (IEnumerable <DbExpression>)e.Arguments)
{
this._key.Append('(');
dbExpression.Accept((DbExpressionVisitor)this);
this._key.Append(')');
}
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbArithmeticExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbArithmeticExpression"/> that is visited.</param>
public override void Visit(DbArithmeticExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
foreach (DbExpression ex in expression.Arguments)
{
ex.Accept(this);
}
}
public override TreeNode Visit(DbArithmeticExpression e)
{
Check.NotNull(e, "e");
if (DbExpressionKind.UnaryMinus
== e.ExpressionKind)
{
return(Visit(_opMap[e.ExpressionKind], e.Arguments[0]));
}
else
{
return(VisitInfix(e.Arguments[0], _opMap[e.ExpressionKind], e.Arguments[1]));
}
}
private void ConvertAndVerifyArithmeticExpression(DbArithmeticExpression arithmeticExpression)
{
var legacyArithmeticExpression =
_legacyDbExpressionConverter.Visit(arithmeticExpression) as LegacyCommandTrees.DbArithmeticExpression;
Assert.NotNull(arithmeticExpression);
Assert.Equal((int)arithmeticExpression.ExpressionKind, (int)legacyArithmeticExpression.ExpressionKind);
Assert.Equal(arithmeticExpression.Arguments.Count, legacyArithmeticExpression.Arguments.Count);
Assert.True(
arithmeticExpression.Arguments.Zip(
legacyArithmeticExpression.Arguments,
(e1, e2) => ((DbConstantExpression)e1).Value == ((LegacyCommandTrees.DbConstantExpression)e2).Value)
.All(r => r));
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyArithmeticExpression.ResultType, arithmeticExpression.ResultType);
}
private static void ExtractAssociativeArguments(DbExpressionKind expressionKind, List <DbExpression> argumentList, DbExpression expression)
{
if (expression.ExpressionKind != expressionKind)
{
argumentList.Add(expression);
}
else
{
DbBinaryExpression binaryExpression = expression as DbBinaryExpression;
if (binaryExpression != null)
{
CommandTreeUtils.ExtractAssociativeArguments(expressionKind, argumentList, binaryExpression.Left);
CommandTreeUtils.ExtractAssociativeArguments(expressionKind, argumentList, binaryExpression.Right);
}
else
{
DbArithmeticExpression arithmeticExpression = (DbArithmeticExpression)expression;
CommandTreeUtils.ExtractAssociativeArguments(expressionKind, argumentList, arithmeticExpression.Arguments[0]);
CommandTreeUtils.ExtractAssociativeArguments(expressionKind, argumentList, arithmeticExpression.Arguments[1]);
}
}
}
public override Expression Visit(DbArithmeticExpression expression)
{
Expression[] args = new Expression[expression.Arguments.Count];
for (int i = 0; i < expression.Arguments.Count; i++)
{
args[i] = this.Visit(expression.Arguments[i]);
}
// This check needs because of UnaryMinus, which has a single argument
if (args.Length == 2)
{
ExpressionHelper.TryUnifyValueTypes(ref args[0], ref args[1]);
}
switch (expression.ExpressionKind)
{
case DbExpressionKind.Plus:
return(Expression.Add(args[0], args[1]));
case DbExpressionKind.Minus:
return(Expression.Subtract(args[0], args[1]));
case DbExpressionKind.Multiply:
return(Expression.Multiply(args[0], args[1]));
case DbExpressionKind.Divide:
return(Expression.Divide(args[0], args[1]));
case DbExpressionKind.Modulo:
return(Expression.Modulo(args[0], args[1]));
case DbExpressionKind.UnaryMinus:
return(Expression.Negate(args[0]));
}
throw new InvalidOperationException("The ExpressionKind cannot be " + expression.ExpressionKind.ToString());
}
public override Expression Visit(DbArithmeticExpression expression)
{
Expression[] args = new Expression[expression.Arguments.Count];
for (int i = 0; i < expression.Arguments.Count; i++)
{
args[i] = this.Visit(expression.Arguments[i]);
}
// This check needs because of UnaryMinus, which has a single argument
if (args.Length == 2)
{
ExpressionHelper.TryUnifyValueTypes(ref args[0], ref args[1]);
}
switch (expression.ExpressionKind)
{
case DbExpressionKind.Plus:
return Expression.Add(args[0], args[1]);
case DbExpressionKind.Minus:
return Expression.Subtract(args[0], args[1]);
case DbExpressionKind.Multiply:
return Expression.Multiply(args[0], args[1]);
case DbExpressionKind.Divide:
return Expression.Divide(args[0], args[1]);
case DbExpressionKind.Modulo:
return Expression.Modulo(args[0], args[1]);
case DbExpressionKind.UnaryMinus:
return Expression.Negate(args[0]);
}
throw new InvalidOperationException("The ExpressionKind cannot be " + expression.ExpressionKind.ToString());
}
/// <summary>
/// Helper method for FlattenAssociativeExpression.
/// Creates a flat list of the associative arguments and appends to the given argument list.
/// For example, for ((A1 + (A2 - A3)) + A4) it will add A1, (A2 - A3), A4 to the list.
/// Only 'unfolds' the given expression if it is of the given expression kind.
/// </summary>
/// <param name="expressionKind"></param>
/// <param name="argumentList"></param>
/// <param name="expression"></param>
private static void ExtractAssociativeArguments(DbExpressionKind expressionKind, List <DbExpression> argumentList, DbExpression expression)
{
if (expression.ExpressionKind != expressionKind)
{
argumentList.Add(expression);
return;
}
//All associative expressions are binary, thus we must be dealing with a DbBinaryExpresson or
// a DbNaryExpression with 2 arguments.
DbBinaryExpression binaryExpression = expression as DbBinaryExpression;
if (binaryExpression != null)
{
ExtractAssociativeArguments(expressionKind, argumentList, binaryExpression.Left);
ExtractAssociativeArguments(expressionKind, argumentList, binaryExpression.Right);
return;
}
DbArithmeticExpression naryExpression = (DbArithmeticExpression)expression;
ExtractAssociativeArguments(expressionKind, argumentList, naryExpression.Arguments[0]);
ExtractAssociativeArguments(expressionKind, argumentList, naryExpression.Arguments[1]);
}
public override void Visit(DbArithmeticExpression expression)
{
throw new NotSupportedException("Visit(\"ArithmeticExpression\") is not supported.");
}
public override void Visit(DbArithmeticExpression e)
{
Check.NotNull(e, "e");
Begin(e);
Dump(e.Arguments, "Arguments", "Argument");
End(e);
}
/// <summary>
/// Visitor pattern method for <see cref="DbArithmeticExpression" />.
/// </summary>
/// <param name="expression"> The DbArithmeticExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbArithmeticExpression expression)
{
VisitExpressionList(Check.NotNull(expression, "expression").Arguments);
}
/// <summary> /// Typed visitor pattern method for DbArithmeticExpression. /// </summary> /// <param name="expression"> The DbArithmeticExpression that is being visited. </param> /// <returns> An instance of TResultType. </returns> public abstract TResultType Visit(DbArithmeticExpression expression);
public override DbExpressionEntitySetInfo Visit(DbArithmeticExpression expression)
{
Check.NotNull(expression, "expression");
return(null);
}
public override void Visit(DbArithmeticExpression e)
{
VisitExprKind(e.ExpressionKind);
foreach (var a in e.Arguments)
{
_key.Append('(');
a.Accept(this);
_key.Append(')');
}
}
/// <summary> /// Visitor pattern method for DbArithmeticExpression. /// </summary> /// <param name="expression"> The DbArithmeticExpression that is being visited. </param> public abstract void Visit(DbArithmeticExpression expression);
public override void Visit(DbArithmeticExpression expression)
{
Contract.Requires(expression != null);
}
public override TReturn Visit(DbArithmeticExpression expression)
{
Check.NotNull <DbArithmeticExpression>(expression, nameof(expression));
throw this.ConstructNotSupportedException((DbExpression)expression);
}
public override TReturn Visit(DbArithmeticExpression expression)
{
throw ConstructNotSupportedException(expression);
}
/// <summary>
/// Visitor pattern method for <see cref="DbArithmeticExpression"/>.
/// </summary>
/// <param name="expression">The DbArithmeticExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override void Visit(DbArithmeticExpression expression)
{
VisitExpressionList(expression.Arguments);
}
public override void Visit(DbArithmeticExpression e)
{
Begin(e);
Dump(e.Arguments, "Arguments", "Argument");
End(e);
}
/// <summary> /// Visitor pattern method for DbArithmeticExpression. /// </summary> /// <param name="expression"> The DbArithmeticExpression that is being visited. </param> public abstract void Visit(DbArithmeticExpression expression);
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbArithmeticExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbArithmeticExpression"/> that is visited.</param>
public override void Visit(DbArithmeticExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
foreach (DbExpression ex in expression.Arguments)
{
ex.Accept(this);
}
}
public override bool Visit(DbArithmeticExpression expression)
{
Check.NotNull <DbArithmeticExpression>(expression, nameof(expression));
return(this.VisitExpressionList(expression.Arguments));
}
public override void Visit(DbArithmeticExpression expression)
{
if (expression == null) throw new ArgumentException("expression");
VisitExpressionList(expression.Arguments);
}
private void ConvertAndVerifyArithmeticExpression(DbArithmeticExpression arithmeticExpression)
{
var legacyArithmeticExpression =
_legacyDbExpressionConverter.Visit(arithmeticExpression) as LegacyCommandTrees.DbArithmeticExpression;
Assert.NotNull(arithmeticExpression);
Assert.Equal((int)arithmeticExpression.ExpressionKind, (int)legacyArithmeticExpression.ExpressionKind);
Assert.Equal(arithmeticExpression.Arguments.Count, legacyArithmeticExpression.Arguments.Count);
Assert.True(
arithmeticExpression.Arguments.Zip(
legacyArithmeticExpression.Arguments,
(e1, e2) => ((DbConstantExpression)e1).Value == ((LegacyCommandTrees.DbConstantExpression)e2).Value)
.All(r => r));
TypeUsageVerificationHelper
.VerifyTypeUsagesEquivalent(legacyArithmeticExpression.ResultType, arithmeticExpression.ResultType);
}
public override DbExpressionEntitySetInfo Visit(DbArithmeticExpression expression)
{
return(null);
}
public override void Visit(DbArithmeticExpression expression)
{
this.VisitExpressionList(EntityUtils.CheckArgumentNull <DbArithmeticExpression>(expression, nameof(expression)).Arguments);
}
public override VfpExpression Visit(DbArithmeticExpression expression)
{
return(new VfpArithmeticExpression((VfpExpressionKind)expression.ExpressionKind,
expression.ResultType,
CreateDbExpressionList(expression.Arguments)));
}
public override bool Visit(DbArithmeticExpression expression)
{
return(VisitExpressionList(expression.Arguments));
}
public override void Visit(DbArithmeticExpression expression)
{
throw new NotSupportedException("Visit(\"DbArithmeticExpression\") is not supported.");
}
/// <summary>
/// Visitor pattern method for <see cref="DbArithmeticExpression"/>.
/// </summary>
/// <param name="expression">The DbArithmeticExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override void Visit(DbArithmeticExpression expression)
{
VisitExpressionList(EntityUtil.CheckArgumentNull(expression, "expression").Arguments);
}
public override void Visit(DbArithmeticExpression expression) { }
