예제 #1
0
        private static QueryData GetQueryData(ISelectQuery selectQuery)
        {
            var data = new QueryData
            {
                Query = selectQuery
            };

            QueryVisitor.FindParentFirst(
                selectQuery,
                e =>
            {
                switch (e.ElementType)
                {
                case EQueryElementType.SqlField:
                    {
                        var field = (ISqlField)e;

                        if (field.Name.Length != 1 || field.Name[0] != '*')
                        {
                            data.Fields.Add(field);
                        }

                        break;
                    }

                case EQueryElementType.SqlQuery:
                    {
                        if (e != selectQuery)
                        {
                            data.Queries.Add(GetQueryData((ISelectQuery)e));
                            return(null);
                        }

                        break;
                    }

                case EQueryElementType.Column:
                    return(((IColumn)e).Parent == selectQuery ? e : null);

                case EQueryElementType.SqlTable:
                    return(null);
                }

                return(e);
            });

            return(data);
        }
예제 #2
0
        private static void ResolveFields(QueryData data)
        {
            if (data.Queries.Count == 0)
            {
                return;
            }

            var dic = new Dictionary <IQueryExpression, IQueryExpression>();

            foreach (ISqlField field in data.Fields)
            {
                if (dic.ContainsKey(field))
                {
                    continue;
                }

                var found = false;

                foreach (var table in data.Query.From.Tables)
                {
                    found = FindField(field, table) != null;

                    if (found)
                    {
                        break;
                    }
                }

                if (!found)
                {
                    var expr = GetColumn(data, field);

                    if (expr != null)
                    {
                        dic.Add(field, expr);
                    }
                }
            }

            if (dic.Count > 0)
            {
                QueryVisitor.FindParentFirst(
                    data.Query,
                    e =>
                {
                    IQueryExpression ex;

                    switch (e.ElementType)
                    {
                    case EQueryElementType.SqlQuery:
                        return(e == data.Query ? e : null);

                    case EQueryElementType.SqlFunction:
                        {
                            var parms = ((ISqlFunction)e).Parameters;

                            for (var i = 0; i < parms.Length; i++)
                            {
                                if (dic.TryGetValue(parms[i], out ex))
                                {
                                    parms[i] = ex;
                                }
                            }

                            break;
                        }

                    case EQueryElementType.SqlExpression:
                        {
                            var parms = ((ISqlExpression)e).Parameters;

                            for (var i = 0; i < parms.Length; i++)
                            {
                                if (dic.TryGetValue(parms[i], out ex))
                                {
                                    parms[i] = ex;
                                }
                            }

                            break;
                        }

                    case EQueryElementType.SqlBinaryExpression:
                        {
                            var expr = (ISqlBinaryExpression)e;
                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }
                            if (dic.TryGetValue(expr.Expr2, out ex))
                            {
                                expr.Expr2 = ex;
                            }
                            break;
                        }

                    case EQueryElementType.ExprPredicate:
                    case EQueryElementType.NotExprPredicate:
                    case EQueryElementType.IsNullPredicate:
                    case EQueryElementType.InSubQueryPredicate:
                        {
                            var expr = (IExpr)e;
                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }
                            break;
                        }

                    case EQueryElementType.ExprExprPredicate:
                        {
                            var expr = (IExprExpr)e;
                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }
                            if (dic.TryGetValue(expr.Expr2, out ex))
                            {
                                expr.Expr2 = ex;
                            }
                            break;
                        }

                    case EQueryElementType.LikePredicate:
                        {
                            var expr = (ILike)e;
                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }
                            if (dic.TryGetValue(expr.Expr2, out ex))
                            {
                                expr.Expr2 = ex;
                            }
                            if (dic.TryGetValue(expr.Escape, out ex))
                            {
                                expr.Escape = ex;
                            }
                            break;
                        }

                    case EQueryElementType.HierarhicalPredicate:
                        {
                            var expr = (IHierarhicalPredicate)e;
                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }
                            if (dic.TryGetValue(expr.Expr2, out ex))
                            {
                                expr.Expr2 = ex;
                            }
                            break;
                        }

                    case EQueryElementType.BetweenPredicate:
                        {
                            var expr = (IBetween)e;
                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }
                            if (dic.TryGetValue(expr.Expr2, out ex))
                            {
                                expr.Expr2 = ex;
                            }
                            if (dic.TryGetValue(expr.Expr3, out ex))
                            {
                                expr.Expr3 = ex;
                            }
                            break;
                        }

                    case EQueryElementType.InListPredicate:
                        {
                            var expr = (IInList)e;

                            if (dic.TryGetValue(expr.Expr1, out ex))
                            {
                                expr.Expr1 = ex;
                            }

                            for (var i = 0; i < expr.Values.Count; i++)
                            {
                                if (dic.TryGetValue(expr.Values[i], out ex))
                                {
                                    expr.Values[i] = ex;
                                }
                            }

                            break;
                        }

                    case EQueryElementType.Column:
                        {
                            var expr = (IColumn)e;

                            if (expr.Parent != data.Query)
                            {
                                return(null);
                            }

                            if (dic.TryGetValue(expr.Expression, out ex))
                            {
                                expr.Expression = ex;
                            }

                            break;
                        }

                    case EQueryElementType.SetExpression:
                        {
                            var expr = (ISetExpression)e;
                            if (dic.TryGetValue(expr.Expression, out ex))
                            {
                                expr.Expression = ex;
                            }
                            break;
                        }

                    case EQueryElementType.GroupByClause:
                        {
                            var expr = (IGroupByClause)e;

                            expr.Items.ForEach(
                                node =>
                            {
                                if (dic.TryGetValue(node.Value, out ex))
                                {
                                    node.Value = ex;
                                }
                            });

                            break;
                        }

                    case EQueryElementType.OrderByItem:
                        {
                            var expr = (IOrderByItem)e;
                            if (dic.TryGetValue(expr.Expression, out ex))
                            {
                                expr.Expression = ex;
                            }
                            break;
                        }
                    }

                    return(e);
                });
            }

            foreach (var query in data.Queries)
            {
                if (query.Queries.Count > 0)
                {
                    ResolveFields(query);
                }
            }
        }