using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Ant.Core;
using Ant.Query.QueryExpressions;
using Ant.Infrastructure;
using Ant.Query.Internals;
using System.Diagnostics;
using Ant.Utility;
using System.Reflection;
using Ant.DbExpressions;
using Ant.ORM;
using Ant.ORM;
using Ant.Common;
using Ant.Data;
using Ant.Frame;

namespace Ant.Query
{
    class Queryable<T> : QueryBase, IQuery<T>
    {
        static readonly List<Expression> EmptyParameterList = new List<Expression>(0);

        AntORM _dbContext;
        QueryExpression _expression;

        internal bool _trackEntity = false;//是否开启跟踪
        public AntORM DbContext { get { return this._dbContext; } }//数据库连接
        public static Stopwatch sw = new Stopwatch();
        public Queryable(AntORM dbContext)
            : this(dbContext, new RootQueryExpression(typeof(T)), false)
        {
            if (!sw.IsRunning)
            {
                sw = new Stopwatch();
                sw.Start();
            }
            //这边可以用于开始记时
        }
        public Queryable(AntORM dbContext, QueryExpression exp)
            : this(dbContext, exp, false)
        {
            if (!sw.IsRunning)
            {
                sw = new Stopwatch();
                sw.Start();
            }
        }
        public Queryable(AntORM dbContext, QueryExpression exp, bool trackEntity)
        {
            if (!sw.IsRunning)
            {
                sw = new Stopwatch();
                sw.Start();
            }
            this._dbContext = dbContext;
            this._expression = exp;
            this._trackEntity = trackEntity;
        }

        /// <summary>
        /// 数据库配置
        /// </summary>
        public DataAccess db
        {
            get; set;
        }





        /// <summary>
        /// 显示列
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="selector"></param>
        /// <returns></returns>
        public IQuery<TResult> Select<TResult>(Expression<Func<T, TResult>> selector)
        {
            AntUtils.CheckNull(selector);
            SelectExpression e = new SelectExpression(typeof(TResult), _expression, selector);
            return new Queryable<TResult>(this._dbContext, e, this._trackEntity);
        }



        /// <summary>
        /// 查询条件
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public IQuery<T> Where(Expression<Func<T, bool>> predicate)
        {
            AntUtils.CheckNull(predicate);
            WhereExpression e = new WhereExpression(_expression, typeof(T), predicate);
            return new Queryable<T>(this._dbContext, e, this._trackEntity);
        }
        /// <summary>
        /// 用IN作为查询条件的SQL语句
        /// </summary>
        /// <param name="propertySelector"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        public IQuery<T> WhereIn(Expression<Func<T, object>> propertySelector, params object[] values)
        {
            return this.Where(BuildWhereInExpression(propertySelector, values));


        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TElement"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="propertySelector"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        private Expression<Func<T, bool>> BuildWhereInExpression(Expression<Func<T, object>> propertySelector, IEnumerable<object> values)
        {
            ParameterExpression p = propertySelector.Parameters.Single();
            if (!values.Any())
                return e => false;

            var equals = values.Select(value => (Expression)Expression.Equal(propertySelector.Body, Expression.Constant(value, typeof(object))));
            var body = equals.Aggregate<Expression>((accumulate, equal) => Expression.Or(accumulate, equal));

            return Expression.Lambda<Func<T, bool>>(body, p);
        }
        /// <summary>
        /// 默认升序排序
        /// </summary>
        /// <typeparam name="K"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public IOrderedQuery<T> OrderBy<K>(Expression<Func<T, K>> predicate)
        {
            AntUtils.CheckNull(predicate);
            OrderExpression e = new OrderExpression(QueryExpressionType.OrderBy, typeof(T), this._expression, predicate);
            return new OrderedQuery<T>(this._dbContext, e, this._trackEntity);
        }
        /// <summary>
        /// 降序排序
        /// </summary>
        /// <typeparam name="K"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public IOrderedQuery<T> OrderByDesc<K>(Expression<Func<T, K>> predicate)
        {
            AntUtils.CheckNull(predicate);
            OrderExpression e = new OrderExpression(QueryExpressionType.OrderByDesc, typeof(T), this._expression, predicate);
            return new OrderedQuery<T>(this._dbContext, e, this._trackEntity);
        }
        /// <summary>
        /// 跳过
        /// </summary>
        /// <param name="count"></param>
        /// <returns></returns>
        public IQuery<T> Skip(int count)
        {
            SkipExpression e = new SkipExpression(typeof(T), this._expression, count);
            return new Queryable<T>(this._dbContext, e, this._trackEntity);
        }
        /// <summary>
        /// TOP取条数据
        /// </summary>
        /// <param name="count"></param>
        /// <returns></returns>
        public IQuery<T> Top(int count)
        {
            TakeExpression e = new TakeExpression(typeof(T), this._expression, count);
            return new Queryable<T>(this._dbContext, e, this._trackEntity);
        }
        /// <summary>
        /// 分组
        /// </summary>
        /// <typeparam name="K"></typeparam>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public IGroupingQuery<T> GroupBy<K>(Expression<Func<T, K>> predicate)
        {
            AntUtils.CheckNull(predicate);
            return new GroupingQuery<T>(this, predicate);
        }
        /// <summary>
        /// 内连接
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <param name="q"></param>
        /// <param name="on"></param>
        /// <returns></returns>
        public IJoiningQuery<T, TSource> InnerJoin<TSource>(IQuery<TSource> q, Expression<Func<T, TSource, bool>> on)
        {
            AntUtils.CheckNull(q);
            AntUtils.CheckNull(on);
            return new JoiningQuery<T, TSource>(this, (Queryable<TSource>)q, JoinType.InnerJoin, on);
        }
        /// <summary>
        /// 左关联
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <param name="q"></param>
        /// <param name="on"></param>
        /// <returns></returns>
        public IJoiningQuery<T, TSource> LeftJoin<TSource>(IQuery<TSource> q, Expression<Func<T, TSource, bool>> on)
        {
            AntUtils.CheckNull(q);
            AntUtils.CheckNull(on);
            return new JoiningQuery<T, TSource>(this, (Queryable<TSource>)q, JoinType.LeftJoin, on);
        }
        /// <summary>
        /// 右关联
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <param name="q"></param>
        /// <param name="on"></param>
        /// <returns></returns>
        public IJoiningQuery<T, TSource> RightJoin<TSource>(IQuery<TSource> q, Expression<Func<T, TSource, bool>> on)
        {
            AntUtils.CheckNull(q);
            AntUtils.CheckNull(on);
            return new JoiningQuery<T, TSource>(this, (Queryable<TSource>)q, JoinType.RightJoin, on);
        }
        /// <summary>
        /// 全连接
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <param name="q"></param>
        /// <param name="on"></param>
        /// <returns></returns>
        public IJoiningQuery<T, TSource> FullJoin<TSource>(IQuery<TSource> q, Expression<Func<T, TSource, bool>> on)
        {
            AntUtils.CheckNull(q);
            AntUtils.CheckNull(on);
            return new JoiningQuery<T, TSource>(this, (Queryable<TSource>)q, JoinType.FullJoin, on);
        }

        public IJoiningQuery<T, TOther> InnerJoin<TOther>(Expression<Func<T, TOther, bool>> on)
        {
            return this.Join<TOther>(new Queryable<TOther>(this._dbContext), JoinType.InnerJoin, on);
        }
        public IJoiningQuery<T, TOther> Join<TOther>(IQuery<TOther> q, JoinType joinType, Expression<Func<T, TOther, bool>> on)
        {
            AntUtils.CheckNull(q);
            AntUtils.CheckNull(on);
            return new JoiningQuery<T, TOther>(this, (Queryable<TOther>)q, joinType, on);
        }
        public IJoiningQuery<T, TOther> LeftJoin<TOther>(Expression<Func<T, TOther, bool>> on)
        {
            return this.LeftJoin<TOther>(new Queryable<TOther>(this._dbContext), on);
        }
        public IJoiningQuery<T, TOther> RightJoin<TOther>(Expression<Func<T, TOther, bool>> on)
        {
            return this.RightJoin<TOther>(new Queryable<TOther>(this._dbContext), on);
        }
        public IJoiningQuery<T, TOther> FullJoin<TOther>(Expression<Func<T, TOther, bool>> on)
        {
            return this.FullJoin<TOther>(new Queryable<TOther>(this._dbContext), on);
        }





        #region 最终调用的方法

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public ResponseModel First()
        {
            ResponseModel reslut = new ResponseModel();

            var q = (Queryable<T>)this.Top(1);
            if (q.db.IsNull() || q.db.IsUnEnable)
                q.db = DbContext.db;
            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                return reslut;
            }
            DbContext.DbContextServiceProvider = DbContext.CreateDataAccess(q.db);
            //IEnumerable<T> iterator = q.GenerateIterator();//原始写法
            InternalQuery<T> iterator = q.GenerateIterator();
            var mod = iterator.First();
            sw.Stop();
            if (mod != null)
            {
                reslut.IsSuccess = true;
                reslut.ResultModel = mod;
                reslut.Message = "查询成功耗时：" + sw.ElapsedMilliseconds;
            }
            else
            {
                reslut.Message = "数据库中没有您要查询的数据";
            }

            reslut.StrSql = iterator.ToString();
            reslut.DBConfig = iterator.GetDataConnection();
            return reslut;
        }


        /// <summary>
        /// 返回序列中的第一个元素，如果数据库查不到数据就会报错（注：用此方法就要保证数据能查到数据）
        /// </summary>
        /// <returns></returns>
        public ResponseModel First(RequestModel request)
        {
            ResponseModel reslut = new ResponseModel();

            var q = (Queryable<T>)this.Top(1);
            if (q.db.IsNull() || q.db.IsUnEnable)
                q.db = request.db;
            if (q.db.IsNull() || q.db.IsUnEnable)
                q.db = _dbContext.db;
            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                return reslut;
            }
            DbContext.DbContextServiceProvider = DbContext.CreateDataAccess(q.db);
            //IEnumerable<T> iterator = q.GenerateIterator();//原始写法
            InternalQuery<T> iterator = q.GenerateIterator();
            var mod = iterator.First();
            sw.Stop();
            if (mod != null)
            {
                reslut.IsSuccess = true;
                reslut.ResultModel = mod;
                reslut.Message = "查询成功耗时：" + sw.ElapsedMilliseconds;
            }
            else
            {
                reslut.Message = "数据库中没有您要查询的数据";
            }

            reslut.StrSql = iterator.ToString();
            reslut.DBConfig = iterator.GetDataConnection();
            return reslut;
        }
        /// <summary>
        /// 返回序列中的第一个元素
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public ResponseModel First(Expression<Func<T, bool>> predicate)
        {
            ResponseModel reslut = new ResponseModel();
            if (this.DbContext.db.IsNull() || this.DbContext.db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                return reslut;
            }
            var mod = this.Where(predicate).First();
            if (mod != null)
            {
                reslut.IsSuccess = true;
                reslut.ResultModel = mod;
                DbContext.TrackEntity(mod);//这时只会更新被修改的字段
                reslut.Message = "数据返回成功";
            }
            else
            {
                reslut.Message = "数据库中没有您要查询的数据";
            }
            reslut.StrSql = this.ToString();
            reslut.DBConfig = this.GetDataConnection();
            return reslut;
        }
        /// <summary>
        /// 获取一条数据
        /// </summary>
        /// <returns></returns>
        public ResponseModel FirstOrDefault()
        {
            ResponseModel reslut = new ResponseModel();
            var q = (Queryable<T>)this.Top(1);
            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                q.db = DbContext.db;
            }
            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                return reslut;
            }
            _dbContext.DbContextServiceProvider = DbContext.CreateDataAccess(q.db);
            //IEnumerable<T> iterator = q.GenerateIterator();//原始写法
            InternalQuery<T> iterator = q.GenerateIterator();
            var mod = iterator.FirstOrDefault();
            sw.Stop();
            if (mod != null)
            {
                reslut.IsSuccess = true;
                DbContext.TrackEntity(mod);//这时只会更新被修改的字段
                reslut.ResultModel = mod;
                reslut.Message = "查询成功耗时：" + sw.ElapsedMilliseconds;
            }
            else
            {
                reslut.Message = "数据库中没有您要查询的数据";
            }
            reslut.StrSql = iterator.ToString();
            reslut.DBConfig = iterator.GetDataConnection();
            return reslut;
        }

        /// <summary>
        /// 获取一条数据
        /// </summary>
        /// <returns></returns>
        public ResponseModel FirstOrDefault(RequestModel request)
        {
            ResponseModel reslut = new ResponseModel();
            try
            {
                var q = (Queryable<T>)this.Top(1);
                //IEnumerable<T> iterator = q.GenerateIterator();//原始写法
                if (q.db.IsNull() || q.db.IsUnEnable)
                    q.db = DbContext.db;
                if (q.db.IsNull() || q.db.IsUnEnable)
                    q.db = request.db;
                if (q.db.IsNull() || q.db.IsUnEnable)
                {
                    reslut.IsSuccess = false;
                    reslut.Message = "连接数据库配置不能为空";
                    return reslut;
                }
                _dbContext.DbContextServiceProvider = DbContext.CreateDataAccess(q.db);
                InternalQuery<T> iterator = q.GenerateIterator();
                reslut.StrSql = iterator.ToString();
                reslut.DBConfig = iterator.GetDataConnection();
                var mod = iterator.FirstOrDefault();
                sw.Stop();
                if (mod != null)
                {
                    reslut.IsSuccess = true;
                    if (request.Tracking)
                    {
                        DbContext.TrackEntity(mod);//这时只会更新被修改的字段
                    }
                    reslut.ResultModel = mod;
                    reslut.Message = "查询成功耗时：" + sw.ElapsedMilliseconds;
                }
                else
                {
                    reslut.Message = "数据库中没有您要查询的数据";
                }

            }
            catch (Exception ex)
            {
                reslut.IsSuccess = false;
                reslut.Message = ex.ToString();
            }
            return reslut;
        }


        /// <summary>
        /// 获取一条数据
        /// </summary>
        /// <param name="predicate"></param>
        ///  <param name="request"></param>
        /// <returns></returns>
        public ResponseModel FirstOrDefault(Expression<Func<T, bool>> predicate, RequestModel request)
        {
            ResponseModel reslut = new ResponseModel();
            var q = (Queryable<T>)this.Top(1);
            if (q.db.IsNull() || q.db.IsUnEnable)
                q.db = DbContext.db;
            if (q.db.IsNull() || q.db.IsUnEnable)
                q.db = request.db;
            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                return reslut;
            }
            var mod = q.Where(predicate).FirstOrDefault();
            if (request.Tracking)
            {
                DbContext.TrackEntity(mod);//这时只会更新被修改的字段
            }
            reslut.ResultModel = mod;
            sw.Stop();
            if (mod != null)
            {
                reslut.IsSuccess = true;
                reslut.ResultModel = mod;
                reslut.Message = "查询成功耗时：" + sw.ElapsedMilliseconds;
            }
            else
            {
                reslut.Message = "数据库中没有您要查询的数据";
            }
            reslut.StrSql = this.ToString();
            reslut.DBConfig = this.GetDataConnection();
            return reslut;
        }
        /// <summary>
        /// 获取列表
        /// </summary>
        /// <returns></returns>
        public ResponseModel ToList()
        {
            ResponseModel reslut = new ResponseModel();
            if (db.IsNull() || db.IsUnEnable)
            {
                db = DbContext.db;

            }
            if (db.IsNull() || db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                return reslut;
            }
            this._dbContext.DbContextServiceProvider = DbContext.CreateDataAccess(db);

            //IEnumerable<T> iterator = this.GenerateIterator();//原始写法
            InternalQuery<T> iterator = this.GenerateIterator();
            reslut.StrSql = iterator.ToString();
            reslut.DBConfig = iterator.GetDataConnection();
            var modlist = iterator.ToList();
            if (modlist != null)
            {
                if (modlist.Count > 0)
                {
                    reslut.ResultModel = modlist;
                    reslut.RecordNum = modlist.Count;
                    reslut.IsSuccess = true;
                    sw.Stop();
                    reslut.Message = string.Format("查询成功记录条数：{0}耗时：{1}", modlist.Count(), sw.ElapsedMilliseconds);
                }
                else
                {
                    reslut.Message = "数据库中没有您要查询的数据";
                }
            }
            else
            {
                reslut.Message = "数据库中没有您要查询的数据";
            }
            return reslut;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ResponseModel ToList(RequestModel request)
        {
            ResponseModel reslut = new ResponseModel();
            try
            {
                if (db.IsNull() || db.IsUnEnable)
                    db = DbContext.db;
                if (db.IsNull() || db.IsUnEnable)
                    db = request.db;
                this._dbContext.DbContextServiceProvider = DbContext.CreateDataAccess(db);

                InternalQuery<T> iterator = this.GenerateIterator();
                if (db.IsNull() || db.IsUnEnable)
                {
                    reslut.IsSuccess = false;
                    reslut.Message = "连接数据库配置不能为空";
                    return reslut;
                }
                var modlist = iterator.ToList();
                reslut.ResultModel = modlist;
                reslut.RecordNum = modlist.Count;
                sw.Stop();
                if (modlist != null)
                {
                    if (modlist.Count > 0)
                    {
                        reslut.IsSuccess = true;
                        reslut.Message = string.Format("查询成功记录条数：{0}耗时：{1}", modlist.Count(), sw.ElapsedMilliseconds);
                    }
                    else
                    {
                        reslut.Message = "数据库中没有您要查询的数据";
                    }
                }
                else
                {
                    reslut.Message = "数据库中没有您要查询的数据";
                }
                reslut.StrSql = iterator.ToString();
                reslut.DBConfig = iterator.GetDataConnection();
            }
            catch(Exception ex)
            {

            }
           
            return reslut;
        }

        #endregion


        /// <summary>
        /// 是否存在这条记录
        /// </summary>
        /// <returns></returns>
        public ResponseModel Any()
        {
            ResponseModel reslut = new ResponseModel();
            var q = (Queryable<string>)this.Select(a => "1").Top(1);
            if (q.db.IsNull() || q.db.IsUnEnable)
                q.db = DbContext.db;
            reslut.IsSuccess = q.GenerateIterator().Any();
            return reslut;
        }
        /// <summary>
        /// 确定序列中是否有元素满足条件
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public ResponseModel Any(Expression<Func<T, bool>> predicate)
        {
            ResponseModel reslut = new ResponseModel();
            var q = this.Where(predicate);
            reslut.IsSuccess = q.Any().IsSuccess;
            return reslut;
        }
        /// <summary>
        /// 查询记录数
        /// </summary>
        /// <returns></returns>
        public int Count()
        {
            var getmethod = GetCalledMethod(() => default(IQuery<T>).Count());
            var reslut = this.ExecuteAggregateQuery<int>(getmethod, null, null, false).Item1;
            return reslut;
        }

        public ResponseModel Count(RequestModel request)
        {


            var num = this.ExecuteAggregateQuery<int>(GetCalledMethod(() => default(IQuery<T>).Count()), null, request, false).Item2;
            return num;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public ResponseModel LongCount()
        {
            return this.ExecuteAggregateQuery<long>(GetCalledMethod(() => default(IQuery<T>).LongCount()), null, null, false).Item2;
        }
        /// <summary>
        /// 最大记录
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="selector"></param>
        /// <returns></returns>
        public TResult Max<TResult>(Expression<Func<T, TResult>> selector)
        {
            return ExecuteAggregateQuery<TResult>(GetCalledMethod(() => default(IQuery<T>).Max(default(Expression<Func<T, TResult>>))), selector).Item1;
        }
        /// <summary>
        /// 最小记录
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="selector"></param>
        /// <returns></returns>
        public TResult Min<TResult>(Expression<Func<T, TResult>> selector)
        {
            return ExecuteAggregateQuery<TResult>(GetCalledMethod(() => default(IQuery<T>).Min(default(Expression<Func<T, TResult>>))), selector).Item1;
        }

        #region Sum
        /// <summary>
        /// 
        /// </summary>
        /// <param name="selector"></param>
        /// <returns></returns>
        public Tuple<int, ResponseModel> Sum(Expression<Func<T, int>> selector, RequestModel request = null)
        {
            var reslut = this.ExecuteAggregateQuery<int>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, int>>), request)), selector, request);

            return reslut;
        }
        public Tuple<int?, ResponseModel> Sum(Expression<Func<T, int?>> selector, RequestModel request = null)
        {
            var reslut = this.ExecuteAggregateQuery<int?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, int?>>), request)), selector, request);
            return reslut;
        }
        public Tuple<long, ResponseModel> Sum(Expression<Func<T, long>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<long>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, long>>), request)), selector, request);

            return reslut;
        }

        public Tuple<long?, ResponseModel> Sum(Expression<Func<T, long?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<long?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, long?>>), request)), selector, request);

            return reslut;

        }
        public Tuple<decimal, ResponseModel> Sum(Expression<Func<T, decimal>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<decimal>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, decimal>>), request)), selector, request);

            return reslut;
        }
        public Tuple<decimal?, ResponseModel> Sum(Expression<Func<T, decimal?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<decimal?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, decimal?>>), request)), selector, request);

            return reslut;
        }
        public Tuple<double, ResponseModel> Sum(Expression<Func<T, double>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<double>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, double>>), request)), selector, request);

            return reslut;
        }
        public Tuple<double?, ResponseModel> Sum(Expression<Func<T, double?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<double?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, double?>>), request)), selector, request);

            return reslut;
        }
        public Tuple<float, ResponseModel> Sum(Expression<Func<T, float>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<float>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, float>>), request)), selector, request);

            return reslut;
        }
        public Tuple<float?, ResponseModel> Sum(Expression<Func<T, float?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<float?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, float?>>), request)), selector, request);

            return reslut;
        }
        #endregion

        #region  Average
        public Tuple<int, ResponseModel> Average(Expression<Func<T, int>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<int>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, int>>), request)), selector, request);

            return reslut;
        }
        public Tuple<int?, ResponseModel> Average(Expression<Func<T, int?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<int?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, int?>>), request)), selector, request);

            return reslut;
        }
        public Tuple<long, ResponseModel> Average(Expression<Func<T, long>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<long>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, long>>), request)), selector, request);

            return reslut;
        }
        public Tuple<long?, ResponseModel> Average(Expression<Func<T, long?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<long?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, long?>>), request)), selector, request);

            return reslut;
        }
        public Tuple<decimal, ResponseModel> Average(Expression<Func<T, decimal>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<decimal>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, decimal>>), request)), selector, request);

            return reslut;
        }
        public Tuple<decimal?, ResponseModel> Average(Expression<Func<T, decimal?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<decimal?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, decimal?>>), request)), selector, request);

            return reslut;
        }
        public Tuple<double, ResponseModel> Average(Expression<Func<T, double>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<double>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, double>>), request)), selector, request);

            return reslut;
        }
        public Tuple<double?, ResponseModel> Average(Expression<Func<T, double?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<double?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, double?>>), request)), selector, request);

            return reslut;
        }
        public Tuple<float, ResponseModel> Average(Expression<Func<T, float>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<float>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, float>>), request)), selector, request);

            return reslut;
        }
        public Tuple<float?, ResponseModel> Average(Expression<Func<T, float?>> selector, RequestModel request = null)
        {
            var reslut = ExecuteAggregateQuery<float?>(GetCalledMethod(() => default(IQuery<T>).Sum(default(Expression<Func<T, float?>>), request)), selector, request);

            return reslut;
        }

        #endregion

        public override QueryExpression QueryExpression { get { return this._expression; } }
        public override bool TrackEntity { get { return this._trackEntity; } }

        public IQuery<T> AsTracking()
        {
            return new Queryable<T>(this._dbContext, this.QueryExpression, true);
        }
        public IEnumerable<T> AsEnumerable()
        {
            return this.GenerateIterator();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        InternalQuery<T> GenerateIterator()
        {
            InternalQuery<T> internalQuery = new InternalQuery<T>(this);
            return internalQuery;
        }



        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="method"></param>
        /// <param name="parameter"></param>
        /// <param name="request"></param>
        /// <param name="checkParameter"></param>
        /// <returns></returns>
        Tuple<TResult, ResponseModel> ExecuteAggregateQuery<TResult>(MethodInfo method, Expression parameter, RequestModel request = null, bool checkParameter = true)
        {
            ResponseModel reslut = new ResponseModel();
            if (checkParameter)
                AntUtils.CheckNull(parameter);

            if (db.IsNull() || db.IsUnEnable)
                db = DbContext.db;
            if (db.IsNull() || db.IsUnEnable)
                db = request.db;
            this._dbContext.DbContextServiceProvider = DbContext.CreateDataAccess(db);
            List<Expression> parameters = parameter == null ? EmptyParameterList : new List<Expression>(1) { parameter };

            AggregateQueryExpression e = new AggregateQueryExpression(this._expression, method, parameters);


            var q = new Queryable<TResult>(this._dbContext, e, false);
            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                q.db = db;
            }

            if (q.db.IsNull() || q.db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "连接数据库配置不能为空";
                TResult obj = Activator.CreateInstance<TResult>();
                Tuple<TResult, ResponseModel> resluterro = new Tuple<TResult, ResponseModel>(obj, reslut);
                return resluterro;
            }

            IEnumerable<TResult> iterator = this.CreateAggregateQuery<TResult>(q);
            reslut.IsSuccess = true;
            reslut.ResultModel = iterator.Single();
            Tuple<TResult, ResponseModel> resluts = new Tuple<TResult, ResponseModel>(iterator.Single(), reslut);
            return resluts;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="q"></param>
        /// <returns></returns>
        InternalQuery<TResult> CreateAggregateQuery<TResult>(Queryable<TResult> q)
        {
            InternalQuery<TResult> iterator = q.GenerateIterator();
            return iterator;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="exp"></param>
        /// <returns></returns>
        MethodInfo GetCalledMethod<TResult>(Expression<Func<TResult>> exp)
        {
            var body = (MethodCallExpression)exp.Body;
            return body.Method;
        }

        /// <summary>
        /// 获取SQL语句
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            InternalQuery<T> internalQuery = this.GenerateIterator();
            return internalQuery.ToString();
        }
        /// <summary>
        /// 获取数据库连接
        /// </summary>
        /// <returns></returns>
        public string GetDataConnection()
        {
            InternalQuery<T> internalQuery = this.GenerateIterator();
            return internalQuery.GetDataConnection();
        }
    }
}