public void VisitBooleanNotExpr(bool a, ValueType expected)
{
var target = new TypeCheckingVisitor();
var aExpression = new ConstantExpr(a);
var expr = new NotExpr(aExpression);
var actual = target.Visit(expr, scope);
Assert.AreEqual(expected, actual);
}
public void VisitBooleanNotExpr(bool a, bool expected)
{
var target = new EvaluateVisitor();
var aExpression = new ConstantExpr(a);
var expr = new NotExpr(aExpression);
var actual = target.Visit(expr, _scope);
Assert.AreEqual(expected, actual.ToBoolean());
}
/// <summary>
/// Rule: NotExpr -> (NOT)? CompExpr ;
/// </summary>
protected override object EvalNotExpr(ParseTree tree, params object[] paramlist)
{
if (GetNode(TokenType.NOT) == null)
{
return((ExpressionBase)GetNode(TokenType.CompExpr).Eval(tree));
}
var unaryExpr = new NotExpr {
First = (ExpressionBase)GetNode(TokenType.CompExpr).Eval(tree), Node = this
};
return(unaryExpr);
}
protected override ICloneableElement Clone(Dictionary <ICloneableElement, ICloneableElement> objectTree, Predicate <ICloneableElement> doClone)
{
if (!doClone(this))
{
return(this);
}
if (!objectTree.TryGetValue(this, out var clone))
{
objectTree.Add(this, clone = new NotExpr((ISqlExpression)Expr1.Clone(objectTree, doClone), IsNot, Precedence));
}
return(clone);
}
internal override BoolExpr<DomainConstraint<BoolLiteral, Constant>> FixRange(Set<Constant> range, MemberDomainMap memberDomainMap)
{
Debug.Assert(range.Count == 1, "For BoolLiterals, there should be precisely one value - true or false");
var scalar = (ScalarConstant)range.First();
var expr = GetDomainBoolExpression(memberDomainMap);
if ((bool)scalar.Value == false)
{
// The range of the variable was "inverted". Return a NOT of
// the expression
expr = new NotExpr<DomainConstraint<BoolLiteral, Constant>>(expr);
}
return expr;
}
internal override BoolExpr <DomainConstraint <BoolLiteral, Constant> > FixRange(Set <Constant> range, MemberDomainMap memberDomainMap)
{
Debug.Assert(range.Count == 1, "For BoolLiterals, there should be precisely one value - true or false");
var scalar = (ScalarConstant)range.First();
var expr = GetDomainBoolExpression(memberDomainMap);
if ((bool)scalar.Value == false)
{
// The range of the variable was "inverted". Return a NOT of
// the expression
expr = new NotExpr <DomainConstraint <BoolLiteral, Constant> >(expr);
}
return(expr);
}
internal override StringBuilder VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
this.m_skipIsNotNull = false;
TermExpr <DomainConstraint <BoolLiteral, Constant> > child = expression.Child as TermExpr <DomainConstraint <BoolLiteral, Constant> >;
if (child != null)
{
return(BoolExpression.GetBoolLiteral(child).AsNegatedUserString(this.m_builder, this.m_blockAlias, this.m_skipIsNotNull));
}
this.m_builder.Append("NOT(");
expression.Child.Accept <StringBuilder>((Visitor <DomainConstraint <BoolLiteral, Constant>, StringBuilder>) this);
this.m_builder.Append(")");
return(this.m_builder);
}
public dynamic Visit(NotExpr expr)
{
Visit((ExpressionBase)expr);
if (OptimizeMode.ExpressionSimplify)
{
var left = expr.First as LiteralExpr;
if (left != null)
{
left.Value = !left.Value;
return(left);
}
}
return(expr);
}
public void VisitBooleanNotExpr(bool a, string expected)
{
var target = new PrintVisitor();
var aExpression = new ConstantExpr(a);
var expr = new NotExpr(aExpression);
var actual = target.Visit(expr, scope);
Assert.AreEqual(expected, actual);
}
public dynamic Visit(NotExpr expr)
{
var v = _codeGen.Local(Visit((dynamic)expr.First)) as Operand;
return(v.LogicalNot());
}
internal override DomainBoolExpr VisitNot(NotExpr <DomainConstraint> expression)
{
return(expression.Child.Accept(NonNegatedTreeVisitor.Instance));
}
internal override int VisitNot(NotExpr <DomainConstraint> expression)
{
return(expression.Child.Accept(NonNegatedNnfSplitCounter.Instance));
}
/// <summary>
/// end表示字符串最后一个字符的后一个位置
/// </summary>
/// <param name="begin"></param>
/// <param name="end"></param>
/// <returns></returns>
private Expression parse(int begin, int end)
{
if (begin >= end)
{
kernel.IssueError(ErrorType.ExpressionSyntaxError, loc.Offset(begin));
return(null);
}
while (isWhiteSpace(expr[begin]))
{
begin++;
}
while (isWhiteSpace(expr[end - 1]))
{
end--;
}
int currentParenLevel;
bool hasSideParren = true;
while (expr[begin] == '(' && hasSideParren)
{
currentParenLevel = 0;
int currentPos;
for (currentPos = begin; currentPos < end; currentPos++)
{
if (expr[currentPos] == '(')
{
currentParenLevel++;
}
else if (expr[currentPos] == ')')
{
currentParenLevel--;
if (currentParenLevel == 0)
{
if (currentPos == end - 1)
{
begin++;
end--;
}
else
{
hasSideParren = false;
}
break;
}
}
}
if (currentPos == end && currentParenLevel > 0)
{
kernel.IssueError(ErrorType.SingleParen, loc.Offset(begin));
return(null);
}
}
currentParenLevel = 0;
OpLevel currentLevel = OpLevel.Null;
OpLevel minLevel = OpLevel.Null;
int minPos = -1;
int minOpLength = 0;
bool findOp = false;
string op = null;
MatchTokenResult matchTokenResult;
//找到当前应处理的操作符
for (int currentPos = begin; currentPos < end; currentPos = matchTokenResult.EndPos)
{
//if (expr[currentPos] == ' ' || expr[currentPos] == '\t' || expr[currentPos] == '\n'
// || Environment.NewLine.IndexOf(expr[currentPos]) != -1)
//{
// op = null;
// continue;
//}
matchTokenResult = MatchToken(currentPos, end);
if (matchTokenResult.TokenType == TokenType.Error)
{
return(null);
}
if (matchTokenResult.TokenType != TokenType.Operator)
{
continue;
}
op = matchTokenResult.Matched;
if (op != "(" && op != ")")
{
findOp = true;
}
if (op == "(")
{
currentParenLevel++;
continue;
}
else if (op == ")")
{
currentParenLevel--;
continue;
}
else if (currentParenLevel > 0)
{
continue;
}
else if (currentParenLevel < 0)
{
kernel.IssueError(ErrorType.SingleParen, loc.Offset(currentPos));
return(null);
}
if (currentParenLevel == 0 &&
(
(int)(currentLevel = getOpLevel(op)) < (int)minLevel) ||
((int)currentLevel == (int)minLevel && op != "=") //=为右结合
)
{
minLevel = currentLevel;
minPos = matchTokenResult.BeginPos;
minOpLength = op.Length;
}
}
if (currentParenLevel != 0)
{
kernel.IssueError(ErrorType.SingleParen, loc.Offset(begin));
return(null);
}
if (!findOp) //单个数据
{
string str = expr.Substring(begin, end - begin);
int currentPos = begin;
matchTokenResult = MatchToken(currentPos, end);
switch (matchTokenResult.TokenType)
{
case TokenType.Int:
RightValueExpr intResult = new RightValueExpr();
IntConst intConst = new IntConst();
intConst.Value = int.Parse(matchTokenResult.Matched);
intResult.DataType = DataType.Int;
intResult.RightValue = intConst;
intResult.Location = loc.Offset(begin);
return(intResult);
case TokenType.Float:
RightValueExpr floatResult = new RightValueExpr();
FloatConst floatConst = new FloatConst();
floatConst.Value = float.Parse(matchTokenResult.Matched);
floatResult.DataType = DataType.Float; //modified by Wander @ 2011
floatResult.RightValue = floatConst;
floatResult.Location = loc.Offset(begin);
return(floatResult);
case TokenType.String:
RightValueExpr strResult = new RightValueExpr();
StringConst strConst = new StringConst();
strConst.Value = matchTokenResult.Matched;
strResult.DataType = DataType.String;
strResult.RightValue = strConst;
strResult.Location = loc.Offset(begin);
return(strResult);
case TokenType.Bool:
RightValueExpr boolResult = new RightValueExpr();
BoolConst boolConst = new BoolConst();
boolConst.Value = bool.Parse(matchTokenResult.Matched);
boolResult.DataType = DataType.Bool;
boolResult.RightValue = boolConst;
boolResult.Location = loc.Offset(begin);
return(boolResult);
case TokenType.Variable:
VarRef varRef = new VarRef();
varRef.VarName = matchTokenResult.Matched;
LeftValueExpr leftValueResult = new LeftValueExpr();
leftValueResult.DataType = DataType.Unknown;
leftValueResult.Location = loc.Offset(begin);
leftValueResult.LeftValue = varRef;
return(leftValueResult);
default:
kernel.IssueError(ErrorType.ExpressionSyntaxError, loc.Offset(begin));
return(null);
}
}
Expression left;
Expression right;
matchTokenResult = MatchToken(minPos, end);
op = matchTokenResult.Matched;
left = (begin != minPos) ? parse(begin, minPos) : null; //null表示单目运算符
right = parse(matchTokenResult.EndPos, end);
Location currentLoc = loc.Offset(begin);
if (right == null)
{
return(null);
}
switch (op)
{
case "=":
if (!(left is LeftValueExpr))
{
kernel.IssueError(ErrorType.NotLeftValue, currentLoc);
return(null);
}
AssignExpr assignExpr = new AssignExpr();
assignExpr.LeftExpr = left as LeftValueExpr;
assignExpr.RightExpr = right;
assignExpr.DataType = right.DataType;
assignExpr.Location = currentLoc;
return(assignExpr);
case "&&":
return(processBinaryLogicExpr(
new AndExpr(),
left, right, currentLoc));
case "||":
return(processBinaryLogicExpr(
new OrExpr(),
left, right, currentLoc));
case "==":
return(processBinaryCmpExpr(new EquExpr(), left, right, currentLoc));
case "!=":
return(processBinaryCmpExpr(new NeqExpr(), left, right, currentLoc));
case ">":
return(processBinaryCmpExpr(new GreatExpr(), left, right, currentLoc));
case ">=":
return(processBinaryCmpExpr(new GreatEquExpr(), left, right, currentLoc));
case "<":
return(processBinaryCmpExpr(new LessExpr(), left, right, currentLoc));
case "<=":
return(processBinaryCmpExpr(new LessEquExpr(), left, right, currentLoc));
case "+":
return(processBinaryAlgoExpr(new AddExpr(), left, right, currentLoc));
case "-":
if (left == null)
{
NegativeExpr negExpr = new NegativeExpr();
if (right.DataType == DataType.Bool || right.DataType == DataType.String)
{
kernel.IssueError(ErrorType.OprandTypeError, currentLoc);
return(null);
}
else if (right.DataType == DataType.Int)
{
negExpr.DataType = DataType.Int;
}
else if (right.DataType == DataType.Float)
{
negExpr.DataType = DataType.Float;
}
else
{
negExpr.DataType = DataType.Unknown;
}
negExpr.Op = right;
negExpr.Location = currentLoc;
return(negExpr);
}
else
{
return(processBinaryAlgoExpr(new SubExpr(), left, right, currentLoc));
}
case "*":
return(processBinaryAlgoExpr(new MulExpr(), left, right, currentLoc));
case "/":
return(processBinaryAlgoExpr(new DivExpr(), left, right, currentLoc));
case "^":
return(processBinaryAlgoExpr(new PowExpr(), left, right, currentLoc));
case "!":
if (left != null)
{
kernel.IssueError(ErrorType.ExpressionSyntaxError, currentLoc);
return(null);
}
else
{
NotExpr notExpr = new NotExpr();
notExpr.DataType = DataType.Bool;
notExpr.Op = right;
notExpr.Location = currentLoc;
return(notExpr);
}
}
return(null);
}
public void VisitBooleanNotExpr(bool a, bool expected)
{
var target = new EvaluateVisitor();
var aExpression = new ConstantExpr(a);
var expr = new NotExpr(aExpression);
var actual = target.Visit(expr, _scope);
Assert.AreEqual(expected, actual.ToBoolean());
}
internal override BoolExpr <DomainConstraint <BoolLiteral, Constant> > VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
return(base.VisitNot(expression));
}
protected override DbExpression NotExprAsCql(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
return((DbExpression)expression.Child.Accept <DbExpression>((Visitor <DomainConstraint <BoolLiteral, Constant>, DbExpression>) this).Not());
}
protected abstract T_Return NotExprAsCql(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression);
internal override T_Return VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
this.m_skipIsNotNull = false;
return(this.NotExprAsCql(expression));
}
internal override bool VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
return(expression.Child.Accept <bool>((Visitor <DomainConstraint <BoolLiteral, Constant>, bool>) this));
}
internal override DomainBoolExpr VisitNot(NotExpr <DomainConstraint> expression)
{
Debug.Assert(false, "Negations should not happen at this point");
return(base.VisitNot(expression));
}
internal override DomainBoolExpr VisitNot(NotExpr <DomainConstraint> expression)
{
return(expression);
}
internal override BoolExpr <DomainConstraint <BoolLiteral, Constant> > VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
return(expression.Child.Accept <BoolExpr <DomainConstraint <BoolLiteral, Constant> > >((Visitor <DomainConstraint <BoolLiteral, Constant>, BoolExpr <DomainConstraint <BoolLiteral, Constant> > >)FragmentQueryKBChaseSupport.Normalizer.NonNegatedTreeVisitor.Instance));
}
internal override int VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
return(expression.Child.Accept <int>((Visitor <DomainConstraint <BoolLiteral, Constant>, int>)FragmentQueryKBChaseSupport.Normalizer.NonNegatedNnfSplitCounter.Instance));
}
public void VisitBooleanNotExpr(bool a, ValueType expected)
{
var target = new TypeCheckingVisitor();
var aExpression = new ConstantExpr(a);
var expr = new NotExpr(aExpression);
var actual = target.Visit(expr, scope);
Assert.AreEqual(expected, actual);
}
public string Visit(NotExpr expr, Scope scope)
{
return("!" + expr.Right.Accept(this, scope));
}
internal override int VisitNot(NotExpr <T_Identifier> expression)
{
return(expression.Child.Accept <int>((Visitor <T_Identifier, int>) this));
}
internal override CellTreeNode VisitNot(NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
throw new NotImplementedException();
}
private IQueryElement ConvertInternal(IQueryElement element, Func <IQueryElement, IQueryElement> action)
{
if (element == null)
{
return(null);
}
IQueryElement newElement;
if (_visitedElements.TryGetValue(element, out newElement))
{
return(newElement);
}
switch (element.ElementType)
{
case EQueryElementType.SqlFunction:
{
var func = (ISqlFunction)element;
var parms = Convert(func.Parameters, action);
if (parms != null && !ReferenceEquals(parms, func.Parameters))
{
newElement = new SqlFunction(func.SystemType, func.Name, func.Precedence, parms);
}
break;
}
case EQueryElementType.SqlExpression:
{
var expr = (ISqlExpression)element;
var parameter = Convert(expr.Parameters, action);
if (parameter != null && !ReferenceEquals(parameter, expr.Parameters))
{
newElement = new SqlExpression(expr.SystemType, expr.Expr, expr.Precedence, parameter);
}
break;
}
case EQueryElementType.SqlBinaryExpression:
{
var bexpr = (ISqlBinaryExpression)element;
var expr1 = (IQueryExpression)ConvertInternal(bexpr.Expr1, action);
var expr2 = (IQueryExpression)ConvertInternal(bexpr.Expr2, action);
if (expr1 != null && !ReferenceEquals(expr1, bexpr.Expr1) ||
expr2 != null && !ReferenceEquals(expr2, bexpr.Expr2))
{
newElement = new SqlBinaryExpression(bexpr.SystemType, expr1 ?? bexpr.Expr1, bexpr.Operation,
expr2 ?? bexpr.Expr2, bexpr.Precedence);
}
break;
}
case EQueryElementType.SqlTable:
{
var table = (ISqlTable)element;
var fields1 = ToArray(table.Fields);
var fields2 = Convert(fields1, action, f => new SqlField(f));
var targs = table.TableArguments == null
? null
: Convert(table.TableArguments, action);
var fe = fields2 == null || ReferenceEquals(fields1, fields2);
var ta = ReferenceEquals(table.TableArguments, targs);
if (!fe || !ta)
{
if (fe)
{
fields2 = fields1;
for (var i = 0; i < fields2.Length; i++)
{
var field = fields2[i];
fields2[i] = new SqlField(field);
_visitedElements[field] = fields2[i];
}
}
newElement = new SqlTable(table, fields2, targs ?? table.TableArguments);
}
break;
}
case EQueryElementType.Column:
{
var col = (IColumn)element;
var expr = (IQueryExpression)ConvertInternal(col.Expression, action);
IQueryElement parent;
_visitedElements.TryGetValue(col.Parent, out parent);
if (parent != null || expr != null && !ReferenceEquals(expr, col.Expression))
{
newElement = new Column(parent == null
? col.Parent
: (ISelectQuery)parent, expr ?? col.Expression, col.Alias);
}
break;
}
case EQueryElementType.TableSource:
{
var table = (ITableSource)element;
var source = (ISqlTableSource)ConvertInternal(table.Source, action);
var joins = Convert(table.Joins, action);
if (source != null && !ReferenceEquals(source, table.Source) ||
joins != null && !ReferenceEquals(table.Joins, joins))
{
newElement = new TableSource(source ?? table.Source, table.Alias, joins ?? table.Joins);
}
break;
}
case EQueryElementType.JoinedTable:
{
var join = (IJoinedTable)element;
var table = (ITableSource)ConvertInternal(join.Table, action);
var cond = (ISearchCondition)ConvertInternal(join.Condition, action);
if (table != null && !ReferenceEquals(table, join.Table) ||
cond != null && !ReferenceEquals(cond, join.Condition))
{
newElement = new JoinedTable(join.JoinType, table ?? join.Table, join.IsWeak,
cond ?? join.Condition);
}
break;
}
case EQueryElementType.SearchCondition:
{
var sc = (ISearchCondition)element;
var conds = Convert(sc.Conditions, action);
if (conds != null && !ReferenceEquals(sc.Conditions, conds))
{
newElement = new SearchCondition(conds);
}
break;
}
case EQueryElementType.Condition:
{
var c = (Condition)element;
var p = (ISqlPredicate)ConvertInternal(c.Predicate, action);
if (p != null && !ReferenceEquals(c.Predicate, p))
{
newElement = new Condition(c.IsNot, p, c.IsOr);
}
break;
}
case EQueryElementType.ExprPredicate:
{
var p = (IExpr)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new Expr(e, p.Precedence);
}
break;
}
case EQueryElementType.NotExprPredicate:
{
var p = (INotExpr)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new NotExpr(e, p.IsNot, p.Precedence);
}
break;
}
case EQueryElementType.ExprExprPredicate:
{
var p = (IExprExpr)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2))
{
newElement = new ExprExpr(e1 ?? p.Expr1, p.EOperator, e2 ?? p.Expr2);
}
break;
}
case EQueryElementType.LikePredicate:
{
var p = (ILike)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
var es = (IQueryExpression)ConvertInternal(p.Escape, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2) ||
es != null && !ReferenceEquals(p.Escape, es))
{
newElement = new Like(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, es ?? p.Escape);
}
break;
}
case EQueryElementType.HierarhicalPredicate:
{
var p = (IHierarhicalPredicate)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2))
{
newElement = new HierarhicalPredicate(e1 ?? p.Expr1, e2 ?? p.Expr2, p.Flow);
}
break;
}
case EQueryElementType.BetweenPredicate:
{
var p = (IBetween)element;
var e1 = (IQueryExpression)ConvertInternal(p.Expr1, action);
var e2 = (IQueryExpression)ConvertInternal(p.Expr2, action);
var e3 = (IQueryExpression)ConvertInternal(p.Expr3, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2) ||
e3 != null && !ReferenceEquals(p.Expr3, e3))
{
newElement = new Between(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, e3 ?? p.Expr3);
}
break;
}
case EQueryElementType.IsNullPredicate:
{
var p = (IIsNull)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new IsNull(e, p.IsNot);
}
break;
}
case EQueryElementType.InSubQueryPredicate:
{
var p = (IInSubQuery)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
var q = (ISelectQuery)ConvertInternal(p.SubQuery, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || q != null && !ReferenceEquals(p.SubQuery, q))
{
newElement = new InSubQuery(e ?? p.Expr1, p.IsNot, q ?? p.SubQuery);
}
break;
}
case EQueryElementType.InListPredicate:
{
var p = (IInList)element;
var e = (IQueryExpression)ConvertInternal(p.Expr1, action);
var v = Convert(p.Values, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || v != null && !ReferenceEquals(p.Values, v))
{
newElement = new InList(e ?? p.Expr1, p.IsNot, v ?? p.Values);
}
break;
}
case EQueryElementType.FuncLikePredicate:
{
var p = (IFuncLike)element;
var f = (ISqlFunction)ConvertInternal(p.Function, action);
if (f != null && !ReferenceEquals(p.Function, f))
{
newElement = new FuncLike(f);
}
break;
}
case EQueryElementType.SetExpression:
{
var s = (ISetExpression)element;
var c = (IQueryExpression)ConvertInternal(s.Column, action);
var e = (IQueryExpression)ConvertInternal(s.Expression, action);
if (c != null && !ReferenceEquals(s.Column, c) || e != null && !ReferenceEquals(s.Expression, e))
{
newElement = new SetExpression(c ?? s.Column, e ?? s.Expression);
}
break;
}
case EQueryElementType.InsertClause:
{
var s = (IInsertClause)element;
var t = s.Into != null
? (ISqlTable)ConvertInternal(s.Into, action)
: null;
var i = Convert(s.Items, action);
if (t != null && !ReferenceEquals(s.Into, t) || i != null && !ReferenceEquals(s.Items, i))
{
var sc = new InsertClause
{
Into = t ?? s.Into
};
(i ?? s.Items).ForEach(node => sc.Items.AddLast(node.Value));
sc.WithIdentity = s.WithIdentity;
newElement = sc;
}
break;
}
case EQueryElementType.UpdateClause:
{
var s = (IUpdateClause)element;
var t = s.Table != null
? (ISqlTable)ConvertInternal(s.Table, action)
: null;
var i = Convert(s.Items, action);
var k = Convert(s.Keys, action);
if (t != null && !ReferenceEquals(s.Table, t) || i != null && !ReferenceEquals(s.Items, i) ||
k != null && !ReferenceEquals(s.Keys, k))
{
var sc = new UpdateClause
{
Table = t ?? s.Table
};
(i ?? s.Items).ForEach(node => sc.Items.AddLast(node.Value));
(k ?? s.Keys).ForEach(node => sc.Keys.AddLast(node.Value));
newElement = sc;
}
break;
}
case EQueryElementType.DeleteClause:
{
var s = (IDeleteClause)element;
var t = s.Table != null
? (ISqlTable)ConvertInternal(s.Table, action)
: null;
if (t != null && !ReferenceEquals(s.Table, t))
{
newElement = new DeleteClause
{
Table = t
};
}
break;
}
case EQueryElementType.CreateTableStatement:
{
var s = (ICreateTableStatement)element;
var t = s.Table != null
? (ISqlTable)ConvertInternal(s.Table, action)
: null;
if (t != null && !ReferenceEquals(s.Table, t))
{
newElement = new CreateTableStatement
{
Table = t,
IsDrop = s.IsDrop
};
}
break;
}
case EQueryElementType.SelectClause:
{
var sc = (ISelectClause)element;
var cols = Convert(sc.Columns, action);
var take = (IQueryExpression)ConvertInternal(sc.TakeValue, action);
var skip = (IQueryExpression)ConvertInternal(sc.SkipValue, action);
IQueryElement parent;
_visitedElements.TryGetValue(sc.SelectQuery, out parent);
if (parent != null || cols != null && !ReferenceEquals(sc.Columns, cols) ||
take != null && !ReferenceEquals(sc.TakeValue, take) ||
skip != null && !ReferenceEquals(sc.SkipValue, skip))
{
newElement = new SelectClause(sc.IsDistinct, take ?? sc.TakeValue, skip ?? sc.SkipValue,
cols ?? sc.Columns);
((ISelectClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.FromClause:
{
var fc = (IFromClause)element;
var ts = Convert(fc.Tables, action);
IQueryElement parent;
_visitedElements.TryGetValue(fc.SelectQuery, out parent);
if (parent != null || ts != null && !ReferenceEquals(fc.Tables, ts))
{
newElement = new FromClause(ts ?? fc.Tables);
((IFromClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.WhereClause:
{
var wc = (IWhereClause)element;
var cond = (ISearchCondition)ConvertInternal(wc.Search, action);
IQueryElement parent;
_visitedElements.TryGetValue(wc.SelectQuery, out parent);
if (parent != null || cond != null && !ReferenceEquals(wc.Search, cond))
{
newElement = new WhereClause(cond ?? wc.Search);
((IWhereClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.GroupByClause:
{
var gc = (IGroupByClause)element;
var es = Convert(gc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(gc.SelectQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(gc.Items, es))
{
newElement = new GroupByClause(es ?? gc.Items);
((IGroupByClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.OrderByClause:
{
var oc = (IOrderByClause)element;
var es = Convert(oc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(oc.SelectQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(oc.Items, es))
{
newElement = new OrderByClause(es ?? oc.Items);
((IOrderByClause)newElement).SetSqlQuery((ISelectQuery)parent);
}
break;
}
case EQueryElementType.OrderByItem:
{
var i = (IOrderByItem)element;
var e = (IQueryExpression)ConvertInternal(i.Expression, action);
if (e != null && !ReferenceEquals(i.Expression, e))
{
newElement = new OrderByItem(e, i.IsDescending);
}
break;
}
case EQueryElementType.Union:
{
var u = (IUnion)element;
var q = (ISelectQuery)ConvertInternal(u.SelectQuery, action);
if (q != null && !ReferenceEquals(u.SelectQuery, q))
{
newElement = new Union(q, u.IsAll);
}
break;
}
case EQueryElementType.SqlQuery:
{
var q = (ISelectQuery)element;
IQueryElement parent = null;
var doConvert = false;
if (q.ParentSelect != null)
{
if (!_visitedElements.TryGetValue(q.ParentSelect, out parent))
{
doConvert = true;
parent = q.ParentSelect;
}
}
if (!doConvert)
{
doConvert = null != FindFirstOrDefault <IQueryElement>(q, e =>
{
if (_visitedElements.ContainsKey(e) && _visitedElements[e] != e)
{
return(true);
}
var ret = action(e);
if (ret != null && !ReferenceEquals(e, ret))
{
_visitedElements.Add(e, ret);
return(true);
}
return(false);
});
}
if (!doConvert)
{
break;
}
var nq = new SelectQuery
{
EQueryType = q.EQueryType
};
_visitedElements.Add(q, nq);
var fc = (IFromClause)ConvertInternal(q.From, action) ?? q.From;
var sc = (ISelectClause)ConvertInternal(q.Select, action) ?? q.Select;
var ic = q.IsInsert
? ((IInsertClause)ConvertInternal(q.Insert, action) ?? q.Insert)
: null;
var uc = q.IsUpdate
? ((IUpdateClause)ConvertInternal(q.Update, action) ?? q.Update)
: null;
var dc = q.IsDelete
? ((IDeleteClause)ConvertInternal(q.Delete, action) ?? q.Delete)
: null;
var wc = (IWhereClause)ConvertInternal(q.Where, action) ?? q.Where;
var gc = (IGroupByClause)ConvertInternal(q.GroupBy, action) ?? q.GroupBy;
var hc = (IWhereClause)ConvertInternal(q.Having, action) ?? q.Having;
var oc = (IOrderByClause)ConvertInternal(q.OrderBy, action) ?? q.OrderBy;
var us = q.HasUnion
? Convert(q.Unions, action)
: q.Unions;
var ps = new List <ISqlParameter>(q.Parameters.Count);
foreach (var p in q.Parameters)
{
IQueryElement e;
if (_visitedElements.TryGetValue(p, out e))
{
if (e == null)
{
ps.Add(p);
}
else
{
var sqlParameter = e as ISqlParameter;
if (sqlParameter != null)
{
ps.Add(sqlParameter);
}
}
}
}
nq.Init(ic, uc, dc, sc, fc, wc, gc, hc, oc, us, (ISelectQuery)parent, q.CreateTable,
q.IsParameterDependent, ps);
_visitedElements[q] = action(nq) ?? nq;
return(nq);
}
}
newElement = newElement == null
? action(element)
: (action(newElement) ?? newElement);
_visitedElements.Add(element, newElement);
return(newElement);
}
internal abstract T_Return VisitNot(NotExpr <T_Identifier> expression);
internal override int VisitNot(NotExpr <DomainConstraint> expr)
{
return(expr.Child.Accept(NegatedNnfSplitCountEstimator.Instance));
}
public dynamic Visit(NotExpr expr)
{
Visit((ExpressionBase)expr);
return(null);
}
internal override IEnumerable <TermExpr <DomainConstraint <BoolLiteral, Constant> > > VisitNot(
NotExpr <DomainConstraint <BoolLiteral, Constant> > expression)
{
return(this.VisitTreeNode((TreeExpr <DomainConstraint <BoolLiteral, Constant> >)expression));
}
