protected override void BuildPredicate(ISqlPredicate predicate)
{
var exprExpr = predicate as SelectQuery.Predicate.ExprExpr;
if (exprExpr != null)
{
var leftType = exprExpr.Expr1.SystemType;
var rightType = exprExpr.Expr2.SystemType;
if ((IsDateTime(leftType) || IsDateTime(rightType)) &&
!((exprExpr.Expr1 is IValueContainer && ((IValueContainer)exprExpr.Expr1).Value == null) ||
(exprExpr.Expr2 is IValueContainer && ((IValueContainer)exprExpr.Expr2).Value == null)))
{
if (leftType != null)
{
var l = new SqlFunction(leftType, "$Convert$", SqlDataType.GetDataType(leftType),
SqlDataType.GetDataType(leftType), exprExpr.Expr1);
exprExpr.Expr1 = l;
}
if (rightType != null)
{
var r = new SqlFunction(rightType, "$Convert$", SqlDataType.GetDataType(rightType),
SqlDataType.GetDataType(rightType), exprExpr.Expr2);
exprExpr.Expr2 = r;
}
}
}
base.BuildPredicate(predicate);
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
var newpredicate = predicate;
switch (predicate.ElementType)
{
case QueryElementType.LikePredicate:
var p = (SqlPredicate.Like)predicate;
var param2 = GetParm(p.Expr2 as IValueContainer, p.Expr1.SystemType);
if (param2 != null)
{
if (param2 is SqlValue value && value.Value == null)
{
if (p.IsNot)
{
newpredicate = new SqlPredicate.ExprExpr(p.Expr1, SqlPredicate.Operator.NotEqual, p.Expr2);
}
else
{
newpredicate = new SqlPredicate.ExprExpr(p.Expr1, SqlPredicate.Operator.Equal, p.Expr2);
}
}
else
{
newpredicate = new SqlPredicate.Like(p.Expr1, p.IsNot, param2, p.Escape);
}
}
break;
public override ISqlPredicate ConvertPredicate(ISqlPredicate predicate)
{
if (predicate is SqlQuery.Predicate.Like)
{
var l = (SqlQuery.Predicate.Like)predicate;
if (l.Escape != null)
{
if (l.Expr2 is SqlValue && l.Escape is SqlValue)
{
var text = ((SqlValue)l.Expr2).Value.ToString();
var val = new SqlValue(ReescapeLikeText(text, (char)((SqlValue)l.Escape).Value));
return(new SqlQuery.Predicate.Like(l.Expr1, l.IsNot, val, null));
}
if (l.Expr2 is SqlParameter)
{
var p = (SqlParameter)l.Expr2;
var v = "";
if (p.ValueConverter != null)
{
v = p.ValueConverter(" ") as string;
}
p.SetLikeConverter(v.StartsWith("%") ? "%" : "", v.EndsWith("%") ? "%" : "");
return(new SqlQuery.Predicate.Like(l.Expr1, l.IsNot, p, null));
}
}
}
return(base.ConvertPredicate(predicate));
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
if (predicate is SqlPredicate.ExprExpr exprExpr)
{
var leftType = exprExpr.Expr1.SystemType;
var rightType = exprExpr.Expr2.SystemType;
if ((IsDateTime(leftType) || IsDateTime(rightType)) &&
!(exprExpr.Expr1 is IValueContainer && ((IValueContainer)exprExpr.Expr1).Value == null ||
exprExpr.Expr2 is IValueContainer && ((IValueContainer)exprExpr.Expr2).Value == null))
{
if (leftType != null && !(exprExpr.Expr1 is SqlFunction func1 && (func1.Name == "$Convert$" || func1.Name == "DateTime")))
{
var l = new SqlFunction(leftType, "$Convert$", SqlDataType.GetDataType(leftType),
SqlDataType.GetDataType(leftType), exprExpr.Expr1);
exprExpr.Expr1 = l;
}
if (rightType != null && !(exprExpr.Expr2 is SqlFunction func2 && (func2.Name == "$Convert$" || func2.Name == "DateTime")))
{
var r = new SqlFunction(rightType, "$Convert$", SqlDataType.GetDataType(rightType),
SqlDataType.GetDataType(rightType), exprExpr.Expr2);
exprExpr.Expr2 = r;
}
}
}
base.BuildPredicate(predicate);
}
public override ISqlPredicate ConvertPredicateImpl(ISqlPredicate predicate, ConvertVisitor <RunOptimizationContext> visitor)
{
if (predicate is SqlPredicate.ExprExpr exprExpr)
{
var leftType = QueryHelper.GetDbDataType(exprExpr.Expr1);
var rightType = QueryHelper.GetDbDataType(exprExpr.Expr2);
if ((IsDateTime(leftType) || IsDateTime(rightType)) &&
!(exprExpr.Expr1.TryEvaluateExpression(visitor.Context.OptimizationContext.Context, out var value1) && value1 == null ||
exprExpr.Expr2.TryEvaluateExpression(visitor.Context.OptimizationContext.Context, out var value2) && value2 == null))
{
if (!(exprExpr.Expr1 is SqlFunction func1 && (func1.Name == "$Convert$" || func1.Name == "DateTime")))
{
var left = new SqlFunction(leftType.SystemType, "$Convert$", SqlDataType.GetDataType(leftType.SystemType),
new SqlDataType(leftType), exprExpr.Expr1);
exprExpr = new SqlPredicate.ExprExpr(left, exprExpr.Operator, exprExpr.Expr2, null);
}
if (!(exprExpr.Expr2 is SqlFunction func2 && (func2.Name == "$Convert$" || func2.Name == "DateTime")))
{
var right = new SqlFunction(rightType.SystemType, "$Convert$", new SqlDataType(rightType),
new SqlDataType(rightType), exprExpr.Expr2);
exprExpr = new SqlPredicate.ExprExpr(exprExpr.Expr1, exprExpr.Operator, right, null);
}
predicate = exprExpr;
}
}
predicate = base.ConvertPredicateImpl(predicate, visitor);
return(predicate);
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
if (predicate.ElementType == QueryElementType.ExprExprPredicate)
{
var expr = (SelectQuery.Predicate.ExprExpr)predicate;
if (expr.Operator == SelectQuery.Predicate.Operator.Equal ||
expr.Operator == SelectQuery.Predicate.Operator.NotEqual)
{
ConvertEmptyStringToNullIfNeeded(expr.Expr1);
ConvertEmptyStringToNullIfNeeded(expr.Expr2);
}
}
base.BuildPredicate(predicate);
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
if (predicate.ElementType == QueryElementType.ExprExprPredicate)
{
var expr = (SelectQuery.Predicate.ExprExpr)predicate;
if (expr.Operator == SelectQuery.Predicate.Operator.Equal ||
expr.Operator == SelectQuery.Predicate.Operator.NotEqual)
{
ConvertEmptyStringToNullIfNeeded(expr.Expr1);
ConvertEmptyStringToNullIfNeeded(expr.Expr2);
}
}
base.BuildPredicate(predicate);
}
public override ISqlPredicate ConvertPredicateImpl(ISqlPredicate predicate, ConvertVisitor <RunOptimizationContext> visitor)
{
switch (predicate.ElementType)
{
case QueryElementType.ExprExprPredicate:
{
var expr = (SqlPredicate.ExprExpr)predicate;
// Oracle saves empty string as null to database, so we need predicate modification before sending query
//
if (expr.WithNull == true &&
(expr.Operator == SqlPredicate.Operator.Equal ||
expr.Operator == SqlPredicate.Operator.NotEqual ||
expr.Operator == SqlPredicate.Operator.GreaterOrEqual ||
expr.Operator == SqlPredicate.Operator.LessOrEqual))
{
if (expr.Expr1.SystemType == typeof(string) &&
expr.Expr1.TryEvaluateExpression(visitor.Context.OptimizationContext.Context, out var value1) && value1 is string string1)
{
if (string1 == "")
{
var sc = new SqlSearchCondition();
sc.Conditions.Add(new SqlCondition(false, new SqlPredicate.ExprExpr(expr.Expr1, expr.Operator, expr.Expr2, null), true));
sc.Conditions.Add(new SqlCondition(false, new SqlPredicate.IsNull(expr.Expr2, false), true));
return(sc);
}
}
if (expr.Expr2.SystemType == typeof(string) &&
expr.Expr2.TryEvaluateExpression(visitor.Context.OptimizationContext.Context, out var value2) && value2 is string string2)
{
if (string2 == "")
{
var sc = new SqlSearchCondition();
sc.Conditions.Add(new SqlCondition(false, new SqlPredicate.ExprExpr(expr.Expr1, expr.Operator, expr.Expr2, null), true));
sc.Conditions.Add(new SqlCondition(false, new SqlPredicate.IsNull(expr.Expr1, false), true));
return(sc);
}
}
}
break;
}
}
predicate = base.ConvertPredicateImpl(predicate, visitor);
return(predicate);
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
var newpredicate = predicate;
if (predicate is SelectQuery.Predicate.Like)
{
var p = (SelectQuery.Predicate.Like)predicate;
var param2 = GetParm(p.Expr2 as IValueContainer, p.Expr1.SystemType);
if (param2 != null)
{
if (param2 is SqlValue && ((SqlValue)param2).Value == null)
{
if (p.IsNot)
{
newpredicate = new SelectQuery.Predicate.ExprExpr(p.Expr1, SelectQuery.Predicate.Operator.NotEqual, p.Expr2);
}
else
{
newpredicate = new SelectQuery.Predicate.ExprExpr(p.Expr1, SelectQuery.Predicate.Operator.Equal, p.Expr2);
}
}
else
{
newpredicate = new SelectQuery.Predicate.Like(p.Expr1, p.IsNot, param2, p.Escape);
}
}
}
if (predicate is SelectQuery.Predicate.ExprExpr)
{
var p = (SelectQuery.Predicate.ExprExpr)predicate;
if (p.Expr1 is SqlFunction && ((SqlFunction)p.Expr1).Name == "Date")
{
if (p.Expr2 != null && p.Expr2 is SqlParameter)
{
var p2 = ((SqlParameter)p.Expr2);
p2.DataType = DataType.Date;
}
}
}
base.BuildPredicate(newpredicate);
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
var exprExpr = predicate as SelectQuery.Predicate.ExprExpr;
if (exprExpr != null)
{
var leftType = exprExpr.Expr1.SystemType;
var rightType = exprExpr.Expr2.SystemType;
if (IsDateTime(leftType) || IsDateTime(rightType))
{
var l = new SqlFunction(leftType, "$Convert$", SqlDataType.GetDataType(leftType),
SqlDataType.GetDataType(leftType), exprExpr.Expr1);
var r = new SqlFunction(rightType, "$Convert$", SqlDataType.GetDataType(rightType),
SqlDataType.GetDataType(rightType), exprExpr.Expr2);
exprExpr.Expr1 = l;
exprExpr.Expr2 = r;
}
}
base.BuildPredicate(predicate);
}
IQueryElement ConvertInternal(IQueryElement element, ConvertFunc action)
{
if (element == null)
{
return(null);
}
IQueryElement newElement;
if (_visitedElements.TryGetValue(element, out newElement))
{
return(newElement);
}
switch (element.ElementType)
{
case QueryElementType.SqlFunction:
{
SqlFunction func = (SqlFunction)element;
ISqlExpression[] parms = Convert(func.Parameters, action);
if (parms != null && !ReferenceEquals(parms, func.Parameters))
{
newElement = new SqlFunction(func.SystemType, func.Name, func.Precedence, parms);
}
break;
}
case QueryElementType.SqlExpression:
{
SqlExpression expr = (SqlExpression)element;
ISqlExpression[] parameter = Convert(expr.Parameters, action);
if (parameter != null && !ReferenceEquals(parameter, expr.Parameters))
{
newElement = new SqlExpression(expr.SystemType, expr.Expr, expr.Precedence, parameter);
}
break;
}
case QueryElementType.SqlBinaryExpression:
{
SqlBinaryExpression bexpr = (SqlBinaryExpression)element;
ISqlExpression expr1 = (ISqlExpression)ConvertInternal(bexpr.Expr1, action);
ISqlExpression expr2 = (ISqlExpression)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 QueryElementType.SqlTable:
{
SqlTable table = (SqlTable)element;
SqlField[] fields1 = ToArray(table.Fields);
SqlField[] fields2 = Convert(fields1, action, delegate(SqlField f) { return(new SqlField(f)); });
List <Join> joins = Convert(table.Joins, action, delegate(Join j) { return(j.Clone()); });
bool fe = fields2 == null || ReferenceEquals(fields1, fields2);
bool je = joins == null || ReferenceEquals(table.Joins, joins);
if (!fe || !je)
{
if (fe)
{
fields2 = fields1;
for (int i = 0; i < fields2.Length; i++)
{
SqlField field = fields2[i];
fields2[i] = new SqlField(field);
_visitedElements[field] = fields2[i];
}
}
newElement = new SqlTable(table, fields2, joins ?? table.Joins);
_visitedElements[((SqlTable)newElement).All] = table.All;
}
break;
}
case QueryElementType.Join:
{
Join join = (Join)element;
List <JoinOn> ons = Convert(join.JoinOns, action);
if (ons != null && !ReferenceEquals(join.JoinOns, ons))
{
newElement = new Join(join.TableName, join.Alias, ons);
}
break;
}
case QueryElementType.Column:
{
SqlQuery.Column col = (SqlQuery.Column)element;
ISqlExpression expr = (ISqlExpression)ConvertInternal(col.Expression, action);
IQueryElement parent;
_visitedElements.TryGetValue(col.Parent, out parent);
if (parent != null || expr != null && !ReferenceEquals(expr, col.Expression))
{
newElement = new SqlQuery.Column(parent == null ? col.Parent : (SqlQuery)parent, expr ?? col.Expression, col._alias);
}
break;
}
case QueryElementType.TableSource:
{
SqlQuery.TableSource table = (SqlQuery.TableSource)element;
ISqlTableSource source = (ISqlTableSource)ConvertInternal(table.Source, action);
List <SqlQuery.JoinedTable> joins = Convert(table.Joins, action);
if (source != null && !ReferenceEquals(source, table.Source) ||
joins != null && !ReferenceEquals(table.Joins, joins))
{
newElement = new SqlQuery.TableSource(source ?? table.Source, table._alias, joins ?? table.Joins);
}
break;
}
case QueryElementType.JoinedTable:
{
SqlQuery.JoinedTable join = (SqlQuery.JoinedTable)element;
SqlQuery.TableSource table = (SqlQuery.TableSource)ConvertInternal(join.Table, action);
SqlQuery.SearchCondition cond = (SqlQuery.SearchCondition)ConvertInternal(join.Condition, action);
if (table != null && !ReferenceEquals(table, join.Table) ||
cond != null && !ReferenceEquals(cond, join.Condition))
{
newElement = new SqlQuery.JoinedTable(join.JoinType, table ?? join.Table, join.IsWeak, cond ?? join.Condition);
}
break;
}
case QueryElementType.SearchCondition:
{
SqlQuery.SearchCondition sc = (SqlQuery.SearchCondition)element;
List <SqlQuery.Condition> conds = Convert(sc.Conditions, action);
if (conds != null && !ReferenceEquals(sc.Conditions, conds))
{
newElement = new SqlQuery.SearchCondition(conds);
}
break;
}
case QueryElementType.Condition:
{
SqlQuery.Condition c = (SqlQuery.Condition)element;
ISqlPredicate p = (ISqlPredicate)ConvertInternal(c.Predicate, action);
if (p != null && !ReferenceEquals(c.Predicate, p))
{
newElement = new SqlQuery.Condition(c.IsNot, p, c.IsOr);
}
break;
}
case QueryElementType.ExprPredicate:
{
SqlQuery.Predicate.Expr p = (SqlQuery.Predicate.Expr)element;
ISqlExpression e = (ISqlExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new SqlQuery.Predicate.Expr(e, p.Precedence);
}
break;
}
case QueryElementType.NotExprPredicate:
{
SqlQuery.Predicate.NotExpr p = (SqlQuery.Predicate.NotExpr)element;
ISqlExpression e = (ISqlExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new SqlQuery.Predicate.NotExpr(e, p.IsNot, p.Precedence);
}
break;
}
case QueryElementType.ExprExprPredicate:
{
SqlQuery.Predicate.ExprExpr p = (SqlQuery.Predicate.ExprExpr)element;
ISqlExpression e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
ISqlExpression e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2))
{
newElement = new SqlQuery.Predicate.ExprExpr(e1 ?? p.Expr1, p.Operator, e2 ?? p.Expr2);
}
break;
}
case QueryElementType.LikePredicate:
{
SqlQuery.Predicate.Like p = (SqlQuery.Predicate.Like)element;
ISqlExpression e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
ISqlExpression e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
ISqlExpression es = (ISqlExpression)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 SqlQuery.Predicate.Like(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, es ?? p.Escape);
}
break;
}
case QueryElementType.BetweenPredicate:
{
SqlQuery.Predicate.Between p = (SqlQuery.Predicate.Between)element;
ISqlExpression e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
ISqlExpression e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
ISqlExpression e3 = (ISqlExpression)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 SqlQuery.Predicate.Between(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, e3 ?? p.Expr3);
}
break;
}
case QueryElementType.IsNullPredicate:
{
SqlQuery.Predicate.IsNull p = (SqlQuery.Predicate.IsNull)element;
ISqlExpression e = (ISqlExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new SqlQuery.Predicate.IsNull(e, p.IsNot);
}
break;
}
case QueryElementType.InSubqueryPredicate:
{
SqlQuery.Predicate.InSubQuery p = (SqlQuery.Predicate.InSubQuery)element;
ISqlExpression e = (ISqlExpression)ConvertInternal(p.Expr1, action);
SqlQuery q = (SqlQuery)ConvertInternal(p.SubQuery, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || q != null && !ReferenceEquals(p.SubQuery, q))
{
newElement = new SqlQuery.Predicate.InSubQuery(e ?? p.Expr1, p.IsNot, q ?? p.SubQuery);
}
break;
}
case QueryElementType.InListPredicate:
{
SqlQuery.Predicate.InList p = (SqlQuery.Predicate.InList)element;
ISqlExpression e = (ISqlExpression)ConvertInternal(p.Expr1, action);
List <ISqlExpression> v = Convert(p.Values, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || v != null && !ReferenceEquals(p.Values, v))
{
newElement = new SqlQuery.Predicate.InList(e ?? p.Expr1, p.IsNot, v ?? p.Values);
}
break;
}
case QueryElementType.FuncLikePredicate:
{
SqlQuery.Predicate.FuncLike p = (SqlQuery.Predicate.FuncLike)element;
SqlFunction f = (SqlFunction)ConvertInternal(p.Function, action);
if (f != null && !ReferenceEquals(p.Function, f))
{
newElement = new SqlQuery.Predicate.FuncLike(f);
}
break;
}
case QueryElementType.SetExpression:
{
SqlQuery.SetExpression s = (SqlQuery.SetExpression)element;
ISqlExpression c = (ISqlExpression)ConvertInternal(s.Column, action);
ISqlExpression e = (ISqlExpression)ConvertInternal(s.Expression, action);
if (c != null && !ReferenceEquals(s.Column, c) || e != null && !ReferenceEquals(s.Expression, e))
{
newElement = new SqlQuery.SetExpression(c ?? s.Column, e ?? s.Expression);
}
break;
}
case QueryElementType.SetClause:
{
SqlQuery.SetClause s = (SqlQuery.SetClause)element;
SqlTable t = s.Into != null ? (SqlTable)ConvertInternal(s.Into, action) : null;
List <SqlQuery.SetExpression> i = Convert(s.Items, action);
if (t != null && !ReferenceEquals(s.Into, t) || i != null && !ReferenceEquals(s.Items, i))
{
SqlQuery.SetClause sc = new SqlQuery.SetClause();
sc.Into = t ?? sc.Into;
sc.Items.AddRange(i);
newElement = sc;
}
break;
}
case QueryElementType.SelectClause:
{
SqlQuery.SelectClause sc = (SqlQuery.SelectClause)element;
List <SqlQuery.Column> cols = Convert(sc.Columns, action);
ISqlExpression take = (ISqlExpression)ConvertInternal(sc.TakeValue, action);
ISqlExpression skip = (ISqlExpression)ConvertInternal(sc.SkipValue, action);
IQueryElement parent;
_visitedElements.TryGetValue(sc.SqlQuery, 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 SqlQuery.SelectClause(sc.IsDistinct, take ?? sc.TakeValue, skip ?? sc.SkipValue, cols ?? sc.Columns);
((SqlQuery.SelectClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.FromClause:
{
SqlQuery.FromClause fc = (SqlQuery.FromClause)element;
List <SqlQuery.TableSource> ts = Convert(fc.Tables, action);
IQueryElement parent;
_visitedElements.TryGetValue(fc.SqlQuery, out parent);
if (parent != null || ts != null && !ReferenceEquals(fc.Tables, ts))
{
newElement = new SqlQuery.FromClause(ts ?? fc.Tables);
((SqlQuery.FromClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.WhereClause:
{
SqlQuery.WhereClause wc = (SqlQuery.WhereClause)element;
SqlQuery.SearchCondition cond = (SqlQuery.SearchCondition)ConvertInternal(wc.SearchCondition, action);
IQueryElement parent;
_visitedElements.TryGetValue(wc.SqlQuery, out parent);
if (parent != null || cond != null && !ReferenceEquals(wc.SearchCondition, cond))
{
newElement = new SqlQuery.WhereClause(cond ?? wc.SearchCondition);
((SqlQuery.WhereClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.GroupByClause:
{
SqlQuery.GroupByClause gc = (SqlQuery.GroupByClause)element;
List <ISqlExpression> es = Convert(gc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(gc.SqlQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(gc.Items, es))
{
newElement = new SqlQuery.GroupByClause(es ?? gc.Items);
((SqlQuery.GroupByClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.OrderByClause:
{
SqlQuery.OrderByClause oc = (SqlQuery.OrderByClause)element;
List <SqlQuery.OrderByItem> es = Convert(oc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(oc.SqlQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(oc.Items, es))
{
newElement = new SqlQuery.OrderByClause(es ?? oc.Items);
((SqlQuery.OrderByClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.OrderByItem:
{
SqlQuery.OrderByItem i = (SqlQuery.OrderByItem)element;
ISqlExpression e = (ISqlExpression)ConvertInternal(i.Expression, action);
if (e != null && !ReferenceEquals(i.Expression, e))
{
newElement = new SqlQuery.OrderByItem(e, i.IsDescending);
}
break;
}
case QueryElementType.Union:
{
SqlQuery.Union u = (SqlQuery.Union)element;
SqlQuery q = (SqlQuery)ConvertInternal(u.SqlQuery, action);
if (q != null && !ReferenceEquals(u.SqlQuery, q))
{
newElement = new SqlQuery.Union(q, u.IsAll);
}
break;
}
case QueryElementType.SqlQuery:
{
SqlQuery q = (SqlQuery)element;
IQueryElement parent = null;
bool doConvert = q.ParentSql != null && !_visitedElements.TryGetValue(q.ParentSql, out parent);
if (!doConvert)
{
doConvert = null != Find(q, delegate(IQueryElement e)
{
IQueryElement ret = action(e);
if (ret != null && !ReferenceEquals(e, ret))
{
_visitedElements.Add(e, ret);
return(true);
}
return(false);
});
}
if (!doConvert)
{
break;
}
SqlQuery nq = new SqlQuery();
_visitedElements.Add(q, nq);
SqlQuery.FromClause fc = (SqlQuery.FromClause)ConvertInternal(q.From, action) ?? q.From;
SqlQuery.SelectClause sc = (SqlQuery.SelectClause)ConvertInternal(q.Select, action) ?? q.Select;
SqlQuery.SetClause tc = q.QueryType == QueryType.Update || q.QueryType == QueryType.Insert ? ((SqlQuery.SetClause)ConvertInternal(q.Set, action) ?? q.Set) : null;
SqlQuery.WhereClause wc = (SqlQuery.WhereClause)ConvertInternal(q.Where, action) ?? q.Where;
SqlQuery.GroupByClause gc = (SqlQuery.GroupByClause)ConvertInternal(q.GroupBy, action) ?? q.GroupBy;
SqlQuery.WhereClause hc = (SqlQuery.WhereClause)ConvertInternal(q.Having, action) ?? q.Having;
SqlQuery.OrderByClause oc = (SqlQuery.OrderByClause)ConvertInternal(q.OrderBy, action) ?? q.OrderBy;
List <SqlQuery.Union> us = q.HasUnion ? Convert(q.Unions, action) : q.Unions;
List <SqlParameter> ps = new List <SqlParameter>(q.Parameters.Count);
foreach (SqlParameter p in q.Parameters)
{
IQueryElement e;
if (_visitedElements.TryGetValue(p, out e))
{
if (e == null)
{
ps.Add(p);
}
else if (e is SqlParameter)
{
ps.Add((SqlParameter)e);
}
}
}
nq.Init(tc, sc, fc, wc, gc, hc, oc, us, (SqlQuery)parent, q.ParameterDependent, ps);
_visitedElements[q] = action(nq) ?? nq;
return(nq);
}
}
newElement = newElement == null?action(element) : (action(newElement) ?? newElement);
_visitedElements.Add(element, newElement);
return(newElement);
}
public SqlCondition(bool isNot, ISqlPredicate predicate)
{
IsNot = isNot;
Predicate = predicate;
}
public SqlCondition(bool isNot, ISqlPredicate predicate, bool isOr)
{
IsNot = isNot;
Predicate = predicate;
IsOr = isOr;
}
public override ISqlPredicate ConvertPredicate(ISqlPredicate predicate)
{
if (predicate is SqlQuery.Predicate.Like)
{
var l = (SqlQuery.Predicate.Like)predicate;
if (l.Escape != null)
{
if (l.Expr2 is SqlValue && l.Escape is SqlValue)
{
var text = ((SqlValue) l.Expr2).Value.ToString();
var val = new SqlValue(ReescapeLikeText(text, (char)((SqlValue)l.Escape).Value));
return new SqlQuery.Predicate.Like(l.Expr1, l.IsNot, val, null);
}
if (l.Expr2 is SqlParameter)
{
var p = (SqlParameter)l.Expr2;
var v = "";
if (p.ValueConverter != null)
v = p.ValueConverter(" ") as string;
p.SetLikeConverter(v.StartsWith("%") ? "%" : "", v.EndsWith("%") ? "%" : "");
return new SqlQuery.Predicate.Like(l.Expr1, l.IsNot, p, null);
}
}
}
return base.ConvertPredicate(predicate);
}
T2 Add(ISqlPredicate predicate)
{
_condition.Search.Conditions.Add(new SqlCondition(_isNot, predicate));
return(_condition.GetNext());
}
protected override void BuildPredicate(ISqlPredicate predicate)
{
var exprExpr = predicate as SelectQuery.Predicate.ExprExpr;
if (exprExpr != null)
{
var leftType = exprExpr.Expr1.SystemType;
var rightType = exprExpr.Expr2.SystemType;
if (IsDateTime(leftType) || IsDateTime(rightType))
{
var l = new SqlFunction(leftType, "$Convert$", SqlDataType.GetDataType(leftType),
SqlDataType.GetDataType(leftType), exprExpr.Expr1);
var r = new SqlFunction(rightType, "$Convert$", SqlDataType.GetDataType(rightType),
SqlDataType.GetDataType(rightType), exprExpr.Expr2);
exprExpr.Expr1 = l;
exprExpr.Expr2 = r;
}
}
base.BuildPredicate(predicate);
}
public ISqlPredicate Convert(IParseContext context, ISqlPredicate predicate)
{
SqlProvider.SqlQuery = context.SqlQuery;
return SqlProvider.ConvertPredicate(predicate);
}
