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); }