Exemple #1
0
        protected override void BuildLikePredicate(StringBuilder sb, SqlQuery.Predicate.Like predicate)
        {
            if (predicate.Escape != null)
            {
                if (predicate.Expr2 is SqlValue && predicate.Escape is SqlValue)
                {
                    var text = ((SqlValue)predicate.Expr2).Value.ToString();
                    var val  = new SqlValue(ReescapeLikeText(text, (char)((SqlValue)predicate.Escape).Value));

                    predicate = new SqlQuery.Predicate.Like(predicate.Expr1, predicate.IsNot, val, null);
                }
                else if (predicate.Expr2 is SqlParameter)
                {
                    var p = (SqlParameter)predicate.Expr2;

                    if (p.LikeStart != null)
                    {
                        var value = (string)p.Value;

                        if (value != null)
                        {
                            value = value.Replace("[", "[[]").Replace("~%", "[%]").Replace("~_", "[_]").Replace("~~", "[~]");
                            p     = new SqlParameter(p.SystemType, p.Name, value)
                            {
                                DbSize = p.DbSize, DbType = p.DbType
                            };
                            predicate = new SqlQuery.Predicate.Like(predicate.Expr1, predicate.IsNot, p, null);
                        }
                    }
                }
            }

            base.BuildLikePredicate(sb, predicate);
        }
Exemple #2
0
        public override ISqlPredicate ConvertPredicate(ISqlPredicate predicate)
        {
            if (predicate is SqlQuery.Predicate.Like)
            {
                SqlQuery.Predicate.Like l = (SqlQuery.Predicate.Like)predicate;

                if (l.Escape != null)
                {
                    if (l.Expr2 is SqlValue && l.Escape is SqlValue)
                    {
                        string   text = ((SqlValue)l.Expr2).Value.ToString();
                        SqlValue 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)
                    {
                        SqlParameter p = (SqlParameter)l.Expr2;
                        string       v = "";

                        if (p.ValueConverter != null)
                        {
                            v = p.ValueConverter(" ") as string;
                        }

                        p.ValueConverter = GetLikeEscaper(v.StartsWith("%") ? "%" : "", v.EndsWith("%") ? "%" : "");

                        return(new SqlQuery.Predicate.Like(l.Expr1, l.IsNot, p, null));
                    }
                }
            }

            return(base.ConvertPredicate(predicate));
        }
        protected override void BuildLikePredicate(StringBuilder sb, SqlQuery.Predicate.Like predicate)
        {
            if (predicate.IsNot)
            {
                sb.Append("NOT ");
            }

            int precedence = GetPrecedence(predicate);

            BuildExpression(sb, precedence, predicate.Expr1);
            sb.Append(" LIKE ");
            BuildExpression(sb, precedence, predicate.Expr2);

            if (predicate.Escape != null)
            {
                sb.Append(" ESCAPE ");
                BuildExpression(sb, precedence, predicate.Escape);
            }
        }
Exemple #4
0
        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:
            {
                var func  = (SqlFunction)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 QueryElementType.SqlExpression:
            {
                var expr      = (SqlExpression)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 QueryElementType.SqlBinaryExpression:
            {
                var bexpr = (SqlBinaryExpression)element;
                var expr1 = (ISqlExpression)ConvertInternal(bexpr.Expr1, action);
                var 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:
            {
                var table   = (SqlTable)element;
                var fields1 = ToArray(table.Fields);
                var fields2 = Convert(fields1, action, f => new SqlField(f));
                var joins   = Convert(table.Joins, action, j => j.Clone());
                var targs   = table.TableArguments == null ? null : Convert(table.TableArguments, action);

                var fe = fields2 == null || ReferenceEquals(fields1, fields2);
                var je = joins == null || ReferenceEquals(table.Joins, joins);
                var ta = ReferenceEquals(table.TableArguments, targs);

                if (!fe || !je || !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, joins ?? table.Joins, targs ?? table.TableArguments);

                    _visitedElements[((SqlTable)newElement).All] = table.All;
                }

                break;
            }

            case QueryElementType.Join:
            {
                var join = (Join)element;
                var ons  = Convert(join.JoinOns, action);

                if (ons != null && !ReferenceEquals(join.JoinOns, ons))
                {
                    newElement = new Join(join.TableName, join.Alias, ons);
                }

                break;
            }

            case QueryElementType.Column:
            {
                var col  = (SqlQuery.Column)element;
                var 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:
            {
                var table  = (SqlQuery.TableSource)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 SqlQuery.TableSource(source ?? table.Source, table._alias, joins ?? table.Joins);
                }

                break;
            }

            case QueryElementType.JoinedTable:
            {
                var join  = (SqlQuery.JoinedTable)element;
                var table = (SqlQuery.TableSource)ConvertInternal(join.Table, action);
                var 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:
            {
                var sc    = (SqlQuery.SearchCondition)element;
                var conds = Convert(sc.Conditions, action);

                if (conds != null && !ReferenceEquals(sc.Conditions, conds))
                {
                    newElement = new SqlQuery.SearchCondition(conds);
                }

                break;
            }

            case QueryElementType.Condition:
            {
                var c = (SqlQuery.Condition)element;
                var 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:
            {
                var p = (SqlQuery.Predicate.Expr)element;
                var 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:
            {
                var p = (SqlQuery.Predicate.NotExpr)element;
                var 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:
            {
                var p  = (SqlQuery.Predicate.ExprExpr)element;
                var e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
                var 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:
            {
                var p  = (SqlQuery.Predicate.Like)element;
                var e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
                var e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
                var 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:
            {
                var p  = (SqlQuery.Predicate.Between)element;
                var e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
                var e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
                var 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:
            {
                var p = (SqlQuery.Predicate.IsNull)element;
                var 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:
            {
                var p = (SqlQuery.Predicate.InSubQuery)element;
                var e = (ISqlExpression)ConvertInternal(p.Expr1, action);
                var 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:
            {
                var p = (SqlQuery.Predicate.InList)element;
                var e = (ISqlExpression)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 SqlQuery.Predicate.InList(e ?? p.Expr1, p.IsNot, v ?? p.Values);
                }

                break;
            }

            case QueryElementType.FuncLikePredicate:
            {
                var p = (SqlQuery.Predicate.FuncLike)element;
                var f = (SqlFunction)ConvertInternal(p.Function, action);

                if (f != null && !ReferenceEquals(p.Function, f))
                {
                    newElement = new SqlQuery.Predicate.FuncLike(f);
                }

                break;
            }

            case QueryElementType.SetExpression:
            {
                var s = (SqlQuery.SetExpression)element;
                var c = (ISqlExpression)ConvertInternal(s.Column, action);
                var 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:
            {
                var s = (SqlQuery.SetClause)element;
                var t = s.Into != null ? (SqlTable)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 SqlQuery.SetClause();
                    sc.Into = t ?? sc.Into;
                    sc.Items.AddRange(i ?? s.Items);
                    sc.WithIdentity = s.WithIdentity;

                    newElement = sc;
                }

                break;
            }

            case QueryElementType.SelectClause:
            {
                var sc   = (SqlQuery.SelectClause)element;
                var cols = Convert(sc.Columns, action);
                var take = (ISqlExpression)ConvertInternal(sc.TakeValue, action);
                var 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:
            {
                var fc = (SqlQuery.FromClause)element;
                var 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:
            {
                var wc   = (SqlQuery.WhereClause)element;
                var 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:
            {
                var gc = (SqlQuery.GroupByClause)element;
                var 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:
            {
                var oc = (SqlQuery.OrderByClause)element;
                var 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:
            {
                var i = (SqlQuery.OrderByItem)element;
                var e = (ISqlExpression)ConvertInternal(i.Expression, action);

                if (e != null && !ReferenceEquals(i.Expression, e))
                {
                    newElement = new SqlQuery.OrderByItem(e, i.IsDescending);
                }

                break;
            }

            case QueryElementType.Union:
            {
                var u = (SqlQuery.Union)element;
                var q = (SqlQuery)ConvertInternal(u.SqlQuery, action);

                if (q != null && !ReferenceEquals(u.SqlQuery, q))
                {
                    newElement = new SqlQuery.Union(q, u.IsAll);
                }

                break;
            }

            case QueryElementType.SqlQuery:
            {
                var           q      = (SqlQuery)element;
                IQueryElement parent = null;

                var doConvert = q.ParentSql != null && !_visitedElements.TryGetValue(q.ParentSql, out parent);

                if (!doConvert)
                {
                    doConvert = null != Find(q, e =>
                        {
                            var ret = action(e);

                            if (ret != null && !ReferenceEquals(e, ret))
                            {
                                _visitedElements.Add(e, ret);
                                return(true);
                            }

                            return(false);
                        });
                }

                if (!doConvert)
                {
                    break;
                }

                var nq = new SqlQuery {
                    QueryType = q.QueryType
                };

                _visitedElements.Add(q, nq);

                var fc = (SqlQuery.FromClause)ConvertInternal(q.From, action) ?? q.From;
                var sc = (SqlQuery.SelectClause)ConvertInternal(q.Select, action) ?? q.Select;
                var tc = q.QueryType == QueryType.Update || q.QueryType == QueryType.Insert ? ((SqlQuery.SetClause)ConvertInternal(q.Set, action) ?? q.Set) : null;
                var wc = (SqlQuery.WhereClause)ConvertInternal(q.Where, action) ?? q.Where;
                var gc = (SqlQuery.GroupByClause)ConvertInternal(q.GroupBy, action) ?? q.GroupBy;
                var hc = (SqlQuery.WhereClause)ConvertInternal(q.Having, action) ?? q.Having;
                var oc = (SqlQuery.OrderByClause)ConvertInternal(q.OrderBy, action) ?? q.OrderBy;
                var us = q.HasUnion ? Convert(q.Unions, action) : q.Unions;

                var ps = new List <SqlParameter>(q.Parameters.Count);

                foreach (var 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);
        }
        protected override void BuildLikePredicate(StringBuilder sb, SqlQuery.Predicate.Like predicate)
        {
            if (predicate.Escape != null)
            {
                if (predicate.Expr2 is SqlValue && predicate.Escape is SqlValue)
                {
                    var text = ((SqlValue)predicate.Expr2).Value.ToString();
                    var val  = new SqlValue(ReescapeLikeText(text, (char)((SqlValue)predicate.Escape).Value));

                    predicate = new SqlQuery.Predicate.Like(predicate.Expr1, predicate.IsNot, val, null);
                }
                else if (predicate.Expr2 is SqlParameter)
                {
                    var p = (SqlParameter)predicate.Expr2;

                    if (p.LikeStart != null)
                    {
                        var value = (string)p.Value;

                        if (value != null)
                        {
                            value     = value.Replace("[", "[[]").Replace("~%", "[%]").Replace("~_", "[_]").Replace("~~", "[~]");
                            p         = new SqlParameter(p.SystemType, p.Name, value) { DbSize = p.DbSize, DbType = p.DbType };
                            predicate = new SqlQuery.Predicate.Like(predicate.Expr1, predicate.IsNot, p, null);
                        }
                    }
                }
            }

            base.BuildLikePredicate(sb, predicate);
        }
Exemple #6
0
        public IQueryElement Find(IQueryElement element, FindFunc find)
        {
            if (element == null || find(element))
            {
                return(element);
            }

            switch (element.ElementType)
            {
            case QueryElementType.SqlFunction: return(Find(((SqlFunction)element).Parameters, find));

            case QueryElementType.SqlExpression: return(Find(((SqlExpression)element).Parameters, find));

            case QueryElementType.Join: return(Find(((Join)element).JoinOns, find));

            case QueryElementType.Column: return(Find(((SqlQuery.Column)element).Expression, find));

            case QueryElementType.SearchCondition: return(Find(((SqlQuery.SearchCondition)element).Conditions, find));

            case QueryElementType.Condition: return(Find(((SqlQuery.Condition)element).Predicate, find));

            case QueryElementType.ExprPredicate: return(Find(((SqlQuery.Predicate.Expr)element).Expr1, find));

            case QueryElementType.NotExprPredicate: return(Find(((SqlQuery.Predicate.NotExpr)element).Expr1, find));

            case QueryElementType.IsNullPredicate: return(Find(((SqlQuery.Predicate.IsNull)element).Expr1, find));

            case QueryElementType.FromClause: return(Find(((SqlQuery.FromClause)element).Tables, find));

            case QueryElementType.WhereClause: return(Find(((SqlQuery.WhereClause)element).SearchCondition, find));

            case QueryElementType.GroupByClause: return(Find(((SqlQuery.GroupByClause)element).Items, find));

            case QueryElementType.OrderByClause: return(Find(((SqlQuery.OrderByClause)element).Items, find));

            case QueryElementType.OrderByItem: return(Find(((SqlQuery.OrderByItem)element).Expression, find));

            case QueryElementType.Union: return(Find(((SqlQuery.Union)element).SqlQuery, find));

            case QueryElementType.FuncLikePredicate: return(Find(((SqlQuery.Predicate.FuncLike)element).Function, find));

            case QueryElementType.SqlBinaryExpression:
            {
                SqlBinaryExpression bexpr = (SqlBinaryExpression)element;
                return
                    (Find(bexpr.Expr1, find) ??
                     Find(bexpr.Expr2, find));
            }

            case QueryElementType.SqlTable:
            {
                SqlTable table = (SqlTable)element;
                return
                    (Find(table.All, find) ??
                     Find(table.Fields.Values, find) ??
                     Find(table.Joins, find));
            }

            case QueryElementType.TableSource:
            {
                SqlQuery.TableSource table = (SqlQuery.TableSource)element;
                return
                    (Find(table.Source, find) ??
                     Find(table.Joins, find));
            }

            case QueryElementType.JoinedTable:
            {
                SqlQuery.JoinedTable join = (SqlQuery.JoinedTable)element;
                return
                    (Find(join.Table, find) ??
                     Find(join.Condition, find));
            }

            case QueryElementType.ExprExprPredicate:
            {
                SqlQuery.Predicate.ExprExpr p = (SqlQuery.Predicate.ExprExpr)element;
                return
                    (Find(p.Expr1, find) ??
                     Find(p.Expr2, find));
            }

            case QueryElementType.LikePredicate:
            {
                SqlQuery.Predicate.Like p = (SqlQuery.Predicate.Like)element;
                return
                    (Find(p.Expr1, find) ??
                     Find(p.Expr2, find) ??
                     Find(p.Escape, find));
            }

            case QueryElementType.BetweenPredicate:
            {
                SqlQuery.Predicate.Between p = (SqlQuery.Predicate.Between)element;
                return
                    (Find(p.Expr1, find) ??
                     Find(p.Expr2, find) ??
                     Find(p.Expr3, find));
            }

            case QueryElementType.InSubqueryPredicate:
            {
                SqlQuery.Predicate.InSubQuery p = (SqlQuery.Predicate.InSubQuery)element;
                return
                    (Find(p.Expr1, find) ??
                     Find(p.SubQuery, find));
            }

            case QueryElementType.InListPredicate:
            {
                SqlQuery.Predicate.InList p = (SqlQuery.Predicate.InList)element;
                return
                    (Find(p.Expr1, find) ??
                     Find(p.Values, find));
            }

            case QueryElementType.SetExpression:
            {
                SqlQuery.SetExpression s = (SqlQuery.SetExpression)element;
                return
                    (Find(s.Column, find) ??
                     Find(s.Expression, find));
            }

            case QueryElementType.SetClause:
            {
                SqlQuery.SetClause sc = (SqlQuery.SetClause)element;
                return
                    (Find(sc.Into, find) ??
                     Find(sc.Items, find));
            }

            case QueryElementType.SelectClause:
            {
                SqlQuery.SelectClause sc = (SqlQuery.SelectClause)element;
                return
                    (Find(sc.TakeValue, find) ??
                     Find(sc.SkipValue, find) ??
                     Find(sc.Columns, find));
            }

            case QueryElementType.SqlQuery:
            {
                SqlQuery q = (SqlQuery)element;

                return
                    (Find(q.Select, find) ??
                     (q.QueryType == QueryType.Update || q.QueryType == QueryType.Insert ? Find(q.Set, find) : null) ??
                     Find(q.From, find) ??
                     Find(q.Where, find) ??
                     Find(q.GroupBy, find) ??
                     Find(q.Having, find) ??
                     Find(q.OrderBy, find) ??
                     (q.HasUnion ? Find(q.Unions, find) : null));
            }
            }

            return(null);
        }
Exemple #7
0
        void Visit(IQueryElement element, bool all, VisitFunc action)
        {
            if (element == null || !all && _visitedElements.ContainsKey(element))
            {
                return;
            }

            switch (element.ElementType)
            {
            case QueryElementType.SqlFunction:
            {
                foreach (ISqlExpression p in ((SqlFunction)element).Parameters)
                {
                    Visit(p, all, action);
                }
                break;
            }

            case QueryElementType.SqlExpression:
            {
                foreach (ISqlExpression v in ((SqlExpression)element).Parameters)
                {
                    Visit(v, all, action);
                }
                break;
            }

            case QueryElementType.SqlBinaryExpression:
            {
                SqlBinaryExpression bexpr = (SqlBinaryExpression)element;
                Visit(bexpr.Expr1, all, action);
                Visit(bexpr.Expr2, all, action);
                break;
            }

            case QueryElementType.SqlTable:
            {
                SqlTable table = (SqlTable)element;

                Visit(table.All, all, action);
                foreach (SqlField field in table.Fields.Values)
                {
                    Visit(field, all, action);
                }
                foreach (Join join  in table.Joins)
                {
                    Visit(join, all, action);
                }
                break;
            }

            case QueryElementType.Join:
            {
                foreach (JoinOn j in ((Join)element).JoinOns)
                {
                    Visit(j, all, action);
                }
                break;
            }

            case QueryElementType.Column:
            {
                Visit(((SqlQuery.Column)element).Expression, all, action);
                break;
            }

            case QueryElementType.TableSource:
            {
                SqlQuery.TableSource table = (SqlQuery.TableSource)element;

                Visit(table.Source, all, action);
                foreach (SqlQuery.JoinedTable j in table.Joins)
                {
                    Visit(j, all, action);
                }
                break;
            }

            case QueryElementType.JoinedTable:
            {
                SqlQuery.JoinedTable join = (SqlQuery.JoinedTable)element;
                Visit(join.Table, all, action);
                Visit(join.Condition, all, action);
                break;
            }

            case QueryElementType.SearchCondition:
            {
                foreach (SqlQuery.Condition c in ((SqlQuery.SearchCondition)element).Conditions)
                {
                    Visit(c, all, action);
                }
                break;
            }

            case QueryElementType.Condition:
            {
                Visit(((SqlQuery.Condition)element).Predicate, all, action);
                break;
            }

            case QueryElementType.ExprPredicate:
            {
                Visit(((SqlQuery.Predicate.Expr)element).Expr1, all, action);
                break;
            }

            case QueryElementType.NotExprPredicate:
            {
                Visit(((SqlQuery.Predicate.NotExpr)element).Expr1, all, action);
                break;
            }

            case QueryElementType.ExprExprPredicate:
            {
                SqlQuery.Predicate.ExprExpr p = (SqlQuery.Predicate.ExprExpr)element;
                Visit(p.Expr1, all, action);
                Visit(p.Expr2, all, action);
                break;
            }

            case QueryElementType.LikePredicate:
            {
                SqlQuery.Predicate.Like p = (SqlQuery.Predicate.Like)element;
                Visit(p.Expr1, all, action);
                Visit(p.Expr2, all, action);
                Visit(p.Escape, all, action);
                break;
            }

            case QueryElementType.BetweenPredicate:
            {
                SqlQuery.Predicate.Between p = (SqlQuery.Predicate.Between)element;
                Visit(p.Expr1, all, action);
                Visit(p.Expr2, all, action);
                Visit(p.Expr3, all, action);
                break;
            }

            case QueryElementType.IsNullPredicate:
            {
                Visit(((SqlQuery.Predicate.IsNull)element).Expr1, all, action);
                break;
            }

            case QueryElementType.InSubqueryPredicate:
            {
                SqlQuery.Predicate.InSubQuery p = (SqlQuery.Predicate.InSubQuery)element;
                Visit(p.Expr1, all, action);
                Visit(p.SubQuery, all, action);
                break;
            }

            case QueryElementType.InListPredicate:
            {
                SqlQuery.Predicate.InList p = (SqlQuery.Predicate.InList)element;
                Visit(p.Expr1, all, action);
                foreach (ISqlExpression value in p.Values)
                {
                    Visit(value, all, action);
                }
                break;
            }

            case QueryElementType.FuncLikePredicate:
            {
                SqlQuery.Predicate.FuncLike p = (SqlQuery.Predicate.FuncLike)element;
                Visit(p.Function, all, action);
                break;
            }

            case QueryElementType.SetExpression:
            {
                SqlQuery.SetExpression s = (SqlQuery.SetExpression)element;
                Visit(s.Column, all, action);
                Visit(s.Expression, all, action);
                break;
            }

            case QueryElementType.SetClause:
            {
                SqlQuery.SetClause sc = (SqlQuery.SetClause)element;

                if (sc.Into != null)
                {
                    Visit(sc.Into, all, action);
                }

                foreach (SqlQuery.SetExpression c in sc.Items.ToArray())
                {
                    Visit(c, all, action);
                }
                break;
            }

            case QueryElementType.SelectClause:
            {
                SqlQuery.SelectClause sc = (SqlQuery.SelectClause)element;
                Visit(sc.TakeValue, all, action);
                Visit(sc.SkipValue, all, action);

                foreach (SqlQuery.Column c in sc.Columns.ToArray())
                {
                    Visit(c, all, action);
                }
                break;
            }

            case QueryElementType.FromClause:
            {
                foreach (SqlQuery.TableSource t in ((SqlQuery.FromClause)element).Tables)
                {
                    Visit(t, all, action);
                }
                break;
            }

            case QueryElementType.WhereClause:
            {
                Visit(((SqlQuery.WhereClause)element).SearchCondition, all, action);
                break;
            }

            case QueryElementType.GroupByClause:
            {
                foreach (ISqlExpression i in ((SqlQuery.GroupByClause)element).Items)
                {
                    Visit(i, all, action);
                }
                break;
            }

            case QueryElementType.OrderByClause:
            {
                foreach (SqlQuery.OrderByItem i in ((SqlQuery.OrderByClause)element).Items)
                {
                    Visit(i, all, action);
                }
                break;
            }

            case QueryElementType.OrderByItem:
            {
                Visit(((SqlQuery.OrderByItem)element).Expression, all, action);
                break;
            }

            case QueryElementType.Union:
                Visit(((SqlQuery.Union)element).SqlQuery, all, action);
                break;

            case QueryElementType.SqlQuery:
            {
                if (all)
                {
                    if (_visitedElements.ContainsKey(element))
                    {
                        return;
                    }
                    _visitedElements.Add(element, element);
                }

                SqlQuery q = (SqlQuery)element;

                if (q.QueryType == QueryType.Update || q.QueryType == QueryType.Insert)
                {
                    Visit(q.Set, all, action);
                }
                else
                {
                    Visit(q.Select, all, action);
                }

                Visit(q.From, all, action);
                Visit(q.Where, all, action);
                Visit(q.GroupBy, all, action);
                Visit(q.Having, all, action);
                Visit(q.OrderBy, all, action);

                if (q.HasUnion)
                {
                    foreach (SqlQuery.Union i in q.Unions)
                    {
                        if (i.SqlQuery == q)
                        {
                            throw new InvalidOperationException();
                        }

                        Visit(i, all, action);
                    }
                }

                break;
            }
            }

            action(element);

            if (!all)
            {
                _visitedElements.Add(element, element);
            }
        }