MESProductionWeb/AntORM/Ant.ORM/Tool/AntORM.cs

using Ant.Query;
using Ant.Query.Internals;
using Ant.Utility;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using Ant.Descriptors;
using Ant.Core;
using Ant.Infrastructure;
using Ant.DbExpressions;
using System.Reflection;
using Ant.Exceptions;
using Ant.Core.Visitors;
using Ant.Common;
using Ant.Data;
using Ant.Frame;
using System.Data;
using System.Globalization;

namespace Ant.ORM
{
    /// <summary>
    /// 
    /// </summary>
    public class AntORM : IAntORM, IDisposable
    {


        bool _disposed = false;

        Dictionary<Type, TrackEntityCollection> _trackingEntityContainer;
        /// <summary>
        /// 跟踪实体值
        /// </summary>
        Dictionary<Type, TrackEntityCollection> TrackingEntityContainer
        {
            get
            {
                if (this._trackingEntityContainer == null)
                {
                    this._trackingEntityContainer = new Dictionary<Type, TrackEntityCollection>();
                }

                return this._trackingEntityContainer;
            }
        }

        /// <summary>
        /// 创建用哪种数据库解析SQL语句
        /// </summary>
        public IDbContextServiceProvider DbContextServiceProvider { get; set; }

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

        private string _moduleName;
        /// <summary>
        /// 模块
        /// </summary>
        public string ModuleName
        {
            get { return _moduleName; }
            set { _moduleName = value; }
        }


        #region 保存数据包含新增和修改
        /// <summary>
        /// 保存数据(新增和更新)数据库没有Null值
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel Save<T>(T entity, RequestModel request)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                if (db.IsNull() || db.IsUnEnable)
                    db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable)
                    db = request.db;
                if (db.IsNull() || db.IsUnEnable)
                    db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable)
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (md.PersistType == EntityPersistType.Update)
                {
                    if (md.UpdateColumns.IsNull()) md.UpdateColumns = new Dictionary<string, DbColumn>();
                    IEntityState entityState = this.TryGetTrackedEntityState(entity);//监控实体是否有变化
                    foreach (var kv in md.FiledMeta.MappingMemberDescriptors)
                    {
                        MemberInfo member = kv.Key;
                        MappingMemberDescriptor memberDescriptor = kv.Value;
                        if (member == md.FiledMeta.PrimaryKey.MemberInfo)
                        {
                            continue;
                        }
                        if (memberDescriptor.IsAutoIncrement)
                            continue;
                        object val = memberDescriptor.GetValue(entity);
                        if (entityState != null && !entityState.HasChanged(memberDescriptor, val))
                            continue;

                        md.UpdateColumns.Add(memberDescriptor.Column.Name, memberDescriptor.Column);
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                qcBuilder.Md = md;//所有实体属性
                qcBuilder.PersistType = md.PersistType;

                cmd = qcBuilder.GetQueryCommand();//解析SQL语句

                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }
                result.DBConfig = db.ConnectionString;
                int num = 0; var location = cmd.CommandText.EndsWith(ConstSql.SQL_SCOPE_IDENTITY, StringComparison.CurrentCultureIgnoreCase);
                if (location)
                {
                    num = (!cmd.CommandText.IsEmpty()) ? db.ExecuteScalar(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters).ToInt32() : 0;//执行SQL语句
                    result.RecordNum = num;
                }
                else
                {
                    num = (!cmd.CommandText.IsEmpty()) ? db.ExecuteNonQuery(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters).ToInt32() : 0;
                }
                result.IsSuccess = num > 0;
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.Message = "保存成功,用时：" + str;
                sw = null;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                if (db.IfNotNull()) db.Close();
            }
            return result;
        }



        /// <summary>
        /// 根据实体来进行插入数据库的表中带Null值
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel SaveHaveNull<T>(T entity, RequestModel request)
        {
            MetaData typeDescriptor = MetaDataManager.GetMetaData(entity);
            ResponseModel reslut = new ResponseModel();
            switch (typeDescriptor.PersistType)
            {
                case EntityPersistType.Save:
                    {
                        #region 新增

                        AntUtils.CheckNull(entity);
                        EnsureEntityHasPrimaryKey(typeDescriptor.FiledMeta);
                        MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.FiledMeta.PrimaryKey;
                        MemberInfo keyMember = typeDescriptor.FiledMeta.PrimaryKey.MemberInfo;

                        object keyValue = null;

                        if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                        {
                            reslut.IsSuccess = false;
                            reslut.Message = "备注信息不能为空";
                            return reslut;
                        }
                        if (db.IsNull() || db.IsUnEnable)
                            db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                        if (db.IsNull() || db.IsUnEnable)
                        {
                            db = request.db;
                        }
                        if (db.IsNull() || db.ConnectionString.IsEmpty())
                            db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                        if (db.IsNull() || db.IsUnEnable)
                        {
                            reslut.IsSuccess = false;
                            reslut.Message = "数据库配置不正确";
                            return reslut;
                        }
                        if (db.IfNotNull())
                        {
                            CreateDataAccess(db);
                        }

                        MappingMemberDescriptor autoIncrementMemberDescriptor = typeDescriptor.FiledMeta.AutoIncrement;

                        Dictionary<MappingMemberDescriptor, DbExpression> insertColumns = new Dictionary<MappingMemberDescriptor, DbExpression>();
                        foreach (var kv in typeDescriptor.FiledMeta.MemberColumnMap)
                        {
                            MemberInfo member = kv.Key;
                            MappingMemberDescriptor memberDescriptor = MetaDataManager.TryGetMappingMemberDescriptor(member, typeDescriptor.FiledMeta);

                            if (memberDescriptor == autoIncrementMemberDescriptor)
                                continue;

                            object val = memberDescriptor.GetValue(entity);

                            if (memberDescriptor == keyMemberDescriptor)
                            {
                                keyValue = val;
                            }

                            DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
                            insertColumns.Add(memberDescriptor, valExp);
                        }

                        //主键为空并且主键又不是自增列
                        if (keyValue == null && keyMemberDescriptor != autoIncrementMemberDescriptor)
                        {
                            reslut.Message = string.Format("主键 '{0}' 不能为null值", keyMemberDescriptor.MemberInfo.Name);
                            reslut.IsSuccess = false;
                            return reslut;
                            //throw new AntORMException(string.Format("主键 '{0}' 不能为null值", keyMemberDescriptor.MemberInfo.Name));
                        }

                        DbInsertExpression e = new DbInsertExpression(typeDescriptor.FiledMeta.Table);

                        foreach (var kv in insertColumns)
                        {
                            e.InsertColumns.Add(kv.Key.Column, kv.Value);
                        }

                        if (autoIncrementMemberDescriptor == null)
                        {
                            reslut = this.ExecuteSqlCommand(e, db);
                            reslut.ResultModel = entity;
                            return reslut;
                        }

                        IDbExpressionTranslator translator = DbContextServiceProvider.CreateDbExpressionTranslator();
                        List<DbParam> parameters;
                        string sql = translator.Translate(e, out parameters);

                        string strsql = SqlDataAccess.AppendDbCommandInfo(sql, parameters.ToArray());//用户记录SQL语句

                        if (keyMemberDescriptor != autoIncrementMemberDescriptor)
                            sql = string.Concat(sql, ";", this.GetSelectLastInsertIdClause(db.DatabaseType));

                        //SELECT @@IDENTITY 返回的是 decimal 类型
                        object retIdentity = db.ExecuteScalar(sql, parameters.ToArray());

                        if (retIdentity.ToInt32() > 0)
                        {
                            reslut.RecordNum = retIdentity.ToInt32();
                            reslut.IsSuccess = true;
                        }
                        #endregion
                    }
                    break;
                case EntityPersistType.Update:
                    {
                        reslut = UpdateById(entity, request);
                    }
                    break;
            }

            return reslut;
        }

        #endregion


        #region 更新方法单独实现修改   
        /// <summary>
        /// 通过主键更新操作只有发生变化的列才会被更新
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel UpdateById<T>(T entity, RequestModel request)
        {
            AntUtils.CheckNull(entity); ResponseModel reslut = new ResponseModel();
            MetaData typeDescriptor = MetaDataManager.GetMetaData(entity);
            EnsureEntityHasPrimaryKey(typeDescriptor.FiledMeta);
            MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.FiledMeta.PrimaryKey;
            MemberInfo keyMember = keyMemberDescriptor.MemberInfo;

            if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
            {
                reslut.IsSuccess = false;
                reslut.Message = "备注信息不能为空";
                return reslut;
            }
            if (db.IsNull() || db.IsUnEnable)
                db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                db = request.db;
            }
            if (db.IsNull() || db.IsUnEnable)
                db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "数据库配置不正确";
                return reslut;
            }
            if (db.IfNotNull())
            {
                CreateDataAccess(db);
            }
            if (keyMemberDescriptor.Column == null)
            {
                ResponseModel response = new ResponseModel();
                response.IsSuccess = false;
                response.RecordNum = 0;
                response.Message = string.Format("主键'{0}'不能为 null", keyMember.Name);
                return response;
                //throw new AntORMException(string.Format("主键'{0}'不能为 null", keyMember.Name));
            }
            IEntityState entityState = this.TryGetTrackedEntityState(entity);//监控实体是否有变化
            DbExpression left = new DbColumnAccessExpression(typeDescriptor.FiledMeta.Table, keyMemberDescriptor.Column);
            DbExpression right = DbExpression.Parameter(keyMemberDescriptor.Column.Value, keyMemberDescriptor.MemberInfoType);
            DbExpression conditionExp = new DbEqualExpression(left, right);

            DbUpdateExpression e = new DbUpdateExpression(typeDescriptor.FiledMeta.Table, conditionExp);
            foreach (var kv in typeDescriptor.FiledMeta.MappingMemberDescriptors)
            {
                MemberInfo member = kv.Key;
                MappingMemberDescriptor memberDescriptor = kv.Value;
                if (memberDescriptor.IsAutoIncrement)
                    continue;
                object val = memberDescriptor.GetValue(entity);
                if (!val.IsNull())
                {
                    if (entityState != null && !entityState.HasChanged(memberDescriptor, val))
                        continue;
                    DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
                    e.UpdateColumns.Add(memberDescriptor.Column, valExp);
                }
            }

            if (e.UpdateColumns.Count == 0)
            {
                ResponseModel response = new ResponseModel();
                response.IsSuccess = false;
                response.RecordNum = 0;
                return response;
            }
            if (!request.Oid.IsEmpty())
                e.whereSql = typeDescriptor.FiledMeta.PrimaryKey.MemberInfo.Name + "='" + request.Oid + "'";
            reslut = this.ExecuteSqlCommand(e, db);
            if (entityState != null)
                entityState.Refresh();
            return reslut;
        }

        /// <summary>
        /// 根据ResquestUpdateModel中QueryModel查询实体去批量更新数据
        /// </summary>
        /// <param name="entity">更新实体</param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel UpdateByQueryModel<T>(T entity, ResquestUpdateModel request)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                MetaData md = (request.QueryModel.IfNotNull()) ? MetaDataManager.GetMetaData(entity, request.QueryModel) : MetaDataManager.GetMetaData(entity);//获取实体的元数据

                if (db.IsNull() || db.IsUnEnable)
                    db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable) db = request.db;
                if (db.IsNull() || db.IsUnEnable) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable)
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Update;
                qcBuilder.Predicate = request.Predicate;
                cmd = qcBuilder.GetQueryCommand();//解析SQL语句
                int num = db.ExecuteNonQuery(cmd.CommandText, cmd.Parameters);//执行SQL语句
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = num > 0;
                result.Message = "数据更新成功，用时：" + str;
            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }

        /// <summary>
        /// 自定义更新的列通过Lambda表达式的条件更新操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="body"></param>
        /// <param name="condition"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel UpdateByLambda<T>(Expression<Func<T, T>> body, Expression<Func<T, bool>> condition, RequestModel request)
        {
            AntUtils.CheckNull(body);
            AntUtils.CheckNull(condition);

            ResponseModel reslut = new ResponseModel();

            if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
            {
                reslut.IsSuccess = false;
                reslut.Message = "备注信息不能为空";
                return reslut;
            }
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接

            if (db.IsNull() || db.IsUnEnable)
            {
                db = request.db;
            }
            if (db.IsNull() || db.IsUnEnable)
                db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            MetaData typeDescriptor = new MetaData();
            typeDescriptor.FiledMeta = MetaDataManager.GetMetaData(typeof(T));
            if (db.IsNull() || db.IsUnEnable)
            {
                db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            }
            if (db.IsNull() || db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "数据库配置不正确";
                return reslut;
            }
            if (db.IfNotNull())
            {
                CreateDataAccess(db);
            }

            Dictionary<MemberInfo, Expression> updateColumns = InitMemberExtractor.Extract(body);
            DbExpression conditionExp = typeDescriptor.FiledMeta.Visitor.VisitFilterPredicate(condition);

            DbUpdateExpression e = new DbUpdateExpression(typeDescriptor.FiledMeta.Table, conditionExp);

            foreach (var kv in updateColumns)
            {
                MemberInfo key = kv.Key;
                MappingMemberDescriptor memberDescriptor = MetaDataManager.TryGetMappingMemberDescriptor(key, typeDescriptor.FiledMeta);

                if (memberDescriptor == null)
                {
                    throw new AntORMException(string.Format("该成员'{0}'不映射任何列", key.Name));
                }

                if (memberDescriptor.IsPrimaryKey)
                {
                    throw new AntORMException(string.Format("不能更新主键'{0}'", memberDescriptor.Column.Name));
                }


                if (memberDescriptor.IsAutoIncrement)
                {
                    throw new AntORMException(string.Format("无法更新标识列'{0}'", memberDescriptor.Column.Name));
                }


                e.UpdateColumns.Add(memberDescriptor.Column, typeDescriptor.FiledMeta.Visitor.Visit(kv.Value));
            }

            if (e.UpdateColumns.Count == 0)
            {
                ResponseModel response = new ResponseModel();
                response.IsSuccess = false;
                response.RecordNum = 0;
                return response;
            }


            return this.ExecuteSqlCommand(e, db);
        }

        /// <summary>
        /// 根据表达式条件去更新数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="condition"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel UpdateByLambda<T>(T entity, Expression<Func<T, bool>> condition, RequestModel request)
        {
            AntUtils.CheckNull(entity);
            AntUtils.CheckNull(condition);
            ResponseModel reslut = new ResponseModel();

            if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
            {
                reslut.IsSuccess = false;
                reslut.Message = "备注信息不能为空";
                return reslut;
            }
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                db = request.db;
            }
            if (db.IsNull() || db.IsUnEnable)
                db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            MetaData typeDescriptor = MetaDataManager.GetMetaData(entity);
            if (db.IsNull() || db.IsUnEnable)
            {
                db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            }
            if (db.IsNull() || db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "数据库配置不正确";
                return reslut;
            }
            if (db.IfNotNull())
            {
                CreateDataAccess(db);
            }

            EnsureEntityHasPrimaryKey(typeDescriptor.FiledMeta);//判断是否存生主键

            DbExpression conditionExp = typeDescriptor.FiledMeta.Visitor.VisitFilterPredicate(condition);//解析表达式

            IEntityState entityState = this.TryGetTrackedEntityState(entity);//监控实体是否有变化

            DbUpdateExpression e = new DbUpdateExpression(typeDescriptor.FiledMeta.Table, conditionExp);


            //if (typeDescriptor.Values.IsNull() || typeDescriptor.Values.Count == 0)
            //{
            foreach (var kv in typeDescriptor.FiledMeta.MemberColumnMap)
            {
                MemberInfo member = kv.Key;
                MappingMemberDescriptor memberDescriptor = MetaDataManager.TryGetMappingMemberDescriptor(kv.Key, typeDescriptor.FiledMeta);
                if (member == typeDescriptor.FiledMeta.PrimaryKey.MemberInfo || memberDescriptor.IsAutoIncrement)
                {
                    continue;
                }
                object val = memberDescriptor.GetValue(entity);
                if (entityState != null && !entityState.HasChanged(memberDescriptor, val))
                    continue;

                DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
                e.UpdateColumns.Add(memberDescriptor.Column, valExp);
            }
            //}
            //else
            //{
            //    foreach (var kv in typeDescriptor.Values)
            //    {
            //        MappingMemberDescriptor memberDescriptor = MetaDataManager.GetMappingMemberDescriptor(kv.Key, typeDescriptor.FiledMeta);
            //        if (kv.Key == typeDescriptor.FiledMeta.PrimaryKey.MemberInfo.Name || memberDescriptor.IsAutoIncrement)
            //        {
            //            continue;
            //        }
            //        object val = memberDescriptor.GetValue(entity);
            //        DbExpression valExp = DbExpression.Parameter(val, memberDescriptor.MemberInfoType);
            //        e.UpdateColumns.Add(memberDescriptor.Column, valExp);
            //    }
            //}



            if (e.UpdateColumns.Count == 0)
            {
                reslut.IsSuccess = false;
                reslut.Message = "暂无更新记录的列";
                reslut.RecordNum = 0;
                return reslut;
            }
            return this.ExecuteSqlCommand(e, db);
        }

        #endregion


        #region 删除方法


        /// <summary>
        /// 通过实体值作为查询条件删除操作原始方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel DeleteByModel<T>(T entity, RequestModel request)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                MetaData md = MetaDataManager.GetMetaData(entity); //获取实体的元数据
                if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable) db = request.db;
                if (db.IsNull() || db.IsUnEnable) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable)
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(request.db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Delete;
                cmd = qcBuilder.GetQueryCommand();
                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }
                int num = db.ExecuteNonQuery(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);//执行SQL语句
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = num > 0;
                result.Message = "删除成功,用时：" + str;
                sw = null;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                //
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = request.db.ConnectionString;
                if (!request.db.IsNull()) request.db.Close();
            }
            return result;

        }


        /// <summary>
        /// 通过主键去删除操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public ResponseModel DeleteById<T>(RequestModel request)
        {
            ResponseModel reslut = new ResponseModel();

            if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
            {
                reslut.IsSuccess = false;
                reslut.Message = "备注信息不能为空";
                return reslut;
            }
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                db = request.db;
            }
            MetaData typeDescriptor = new MetaData();
            typeDescriptor.FiledMeta = MetaDataManager.GetMetaData(typeof(T));
            if (db.IsNull() || db.IsUnEnable)
            {
                db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            }
            if (db.IsNull() || db.IsUnEnable)
            {
                reslut.IsSuccess = false;
                reslut.Message = "数据库配置不正确";
                return reslut;
            }
            if (db.IfNotNull())
            {
                CreateDataAccess(db);
            }

            EnsureEntityHasPrimaryKey(typeDescriptor.FiledMeta);

            MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.FiledMeta.PrimaryKey;
            MemberInfo keyMember = typeDescriptor.FiledMeta.PrimaryKey.MemberInfo;
            var keyVal = request.Oid;
            if (keyVal.IsEmpty())
            {
                reslut.IsSuccess = false;
                reslut.Message = string.Format("主键'{0}'不能为 null", keyMember.Name);
                return reslut;
            }

            DbExpression left = new DbColumnAccessExpression(typeDescriptor.FiledMeta.Table, keyMemberDescriptor.Column);
            DbExpression right = new DbParameterExpression(keyVal);
            DbExpression conditionExp = new DbEqualExpression(left, right);

            DbDeleteExpression e = new DbDeleteExpression(typeDescriptor.FiledMeta.Table, conditionExp);
            return this.ExecuteSqlCommand(e, db);
        }

        /// <summary>
        /// 通过lambda表达式作为查询条件进行删除操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="condition"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel DeleteByLambda<T>(Expression<Func<T, bool>> condition, RequestModel request)
        {
            ResponseModel result = new ResponseModel();
            AntUtils.CheckNull(condition);

            if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
            {
                result.IsSuccess = false;
                result.Message = "备注信息不能为空";
                return result;
            }
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                db = request.db;
            }
            if (db.IsNull() || db.IsUnEnable) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                result.IsSuccess = false;
                result.Message = "数据库配置不正确";
                return result;
            }
            MetaData typeDescriptor = new MetaData();
            typeDescriptor.FiledMeta = MetaDataManager.GetMetaData(typeof(T));
            if (db.IfNotNull())
            {
                CreateDataAccess(db);
            }

            DbExpression conditionExp = typeDescriptor.FiledMeta.Visitor.VisitFilterPredicate(condition);

            DbDeleteExpression e = new DbDeleteExpression(typeDescriptor.FiledMeta.Table, conditionExp);
            result = ExecuteSqlCommand(e, db);
            return result;
        }



        #endregion


        #region 查询方法

        /// <summary>
        /// 组装SQL语句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IQuery<T> Queryable<T>() where T : new()
        {
            return new Queryable<T>(this);
        }

        /// <summary>
        /// 自定义SQL语句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="da"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public virtual IEnumerable<T> Sqlable<T>(string sql, DataAccess da, params DbParam[] parameters) where T : new()
        {

            AntUtils.CheckNull(sql, "sql");
            if (db.IsNull() || db.IsUnEnable)
            {
                db = da;
            }
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接

            var list = new ORMInternalSqlQuery<T>(db, sql, parameters);
            return list;
        }
        /// <summary>
        /// 自定义SQL语句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="da"></param>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public IEnumerable<T> SqlQuery<T>(string sql, dynamic param, DataAccess da = null, string moduleName = "") where T : new()
        {
            ResponseModel reslut = new ResponseModel();
            AntUtils.CheckNull(sql, "sql");
            object obj = param as object;
            var typeDescriptor = MetaDataManager.GetMetaData(obj);
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                if (moduleName.IsEmpty())
                {
                    db = da;
                }
                else
                {
                    db = DataAccessFactory.CreateDataConnection(moduleName);
                }
            }
            List<DbParam> parameters = new List<DbParam>();
            foreach (KeyValuePair<string, DbColumn> kv in typeDescriptor.FieldsColumns)
            {
                DbParam pa = new DbParam();
                pa.Name = kv.Value.Name;
                pa.Type = kv.Value.Type;
                pa.Value = kv.Value.Value;
                parameters.Add(pa);
            }
            var list = new ORMInternalSqlQuery<T>(db, sql, parameters.ToArray());
            reslut.ResultModel = list;
            reslut.IsSuccess = true;
            return list;
        }


        /// <summary>
        /// 单表操作通过主键来获取单个实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel GetEntity<T>(RequestModel request) where T : class
        {
            var result = new ResponseModel();
            if (request.Oid.IsEmpty())
            {
                result.IsSuccess = false;
                result.Message = "请求实体中Oid主键不能为空";
                return result;
            }
            if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
            {
                result.IsSuccess = false;
                result.Message = "备注信息不能为空";
                return result;
            }
            if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable) db = request.db;
            if (db.IsNull() || db.IsUnEnable) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
            if (db.IsNull() || db.IsUnEnable)
            {
                result.IsSuccess = false;
                result.Message = "数据库配置不正确";
                return result;
            }
            MetaData typeDescriptor = new MetaData();
            typeDescriptor.FiledMeta = MetaDataManager.GetMetaData(typeof(T));
            typeDescriptor.WhereSql = typeDescriptor.FiledMeta.PrimaryKey.MemberInfo.Name + "='" + request.Oid + "'";
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            T obj = Activator.CreateInstance<T>();
            QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {


                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType); //构建生成哪种SQL语句
                qcBuilder.Md = typeDescriptor;
                qcBuilder.PersistType = EntityPersistType.Query;
                //qcBuilder.SelectField = enty.SelectField;

                qcBuilder.Predicate = request.Predicate;
                qcBuilder.Top = "1";
                qcBuilder.SqlType = SqlEnum.MainSql;
                qcBuilder.Sort = request.Sort;
                cmd = qcBuilder.GetQueryCommand(); //生成SQL语句和参数
                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {

                    obj = DataToModel.Dr2En<T>(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = obj.IfNotNull();
                if (request.Tracking)
                {
                    this.TrackEntity(obj);//这时只会更新被修改的字段
                }
                result.ResultModel = obj;
                result.Message = "获取实体成功，用时：" + str;
                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }
        /// <summary>
        /// 单表操作获取单个实体最终方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel GetEntity<T>(T entity, RequestModel request) where T : class
        {
            var typeDescriptor = MetaDataManager.GetMetaData(entity);

            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            T obj = Activator.CreateInstance<T>();
            var result = new ResponseModel();

            QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable) db = request.db;
                if (db.IsNull() || db.IsUnEnable) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.IsUnEnable)
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType); //构建生成哪种SQL语句
                qcBuilder.Md = typeDescriptor;
                qcBuilder.PersistType = EntityPersistType.Query;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.Predicate = request.Predicate;
                qcBuilder.Top = "1";
                qcBuilder.SqlType = SqlEnum.MainSql;
                qcBuilder.Sort = request.Sort;
                cmd = qcBuilder.GetQueryCommand(); //生成SQL语句和参数
                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {

                    obj = DataToModel.Dr2En<T>(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = obj.IfNotNull();
                if (request.Tracking)
                {
                    this.TrackEntity(obj);//这时只会更新被修改的字段
                }

                result.ResultModel = obj;
                result.Message = "获取实体成功，用时：" + str;
                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }

        }


        /// <summary>
        /// 单表操作获取分页数据返回实体集合
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel GetPageList<T>(T entity, RequestModel request)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            var result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            var db = request.db;
            try
            {
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }

                MetaData typeDescriptor = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = request.db;
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.StartNum == 0)
                {
                    result.IsSuccess = false;
                    result.Message = "如果要用分页方法请求参数StartNum进行传值！";
                    return result;
                }
                if (request.PageSize == 0)
                {
                    result.IsSuccess = false;
                    result.Message = "如果要用分页方法请求参数PageSize进行传值";
                    return result;
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = typeDescriptor;//实体属性
                qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
                qcBuilder.PageNo = request.StartNum;
                qcBuilder.PageSize = request.PageSize;
                qcBuilder.ShowField = request.ShowField;
                qcBuilder.Predicate = request.Predicate;
                cmd = qcBuilder.GetQueryCommand();

                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                string sqlWithComment = string.Empty;
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                var dt = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);
                var objlist = DataToModel.Dr2EnList<T>(dt);
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = true;
                result.ResultModel = objlist;
                result.RecordNum = PageSumEnd(typeDescriptor, db, sqlWithComment).RecordNum;
                result.Message = "查询成功，用时：" + str;
                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                cmd = new QueryCommand();
                return result;
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }


        /// <summary>
        /// 通过DataReader返回List集合这种效率高
        /// </summary>
        /// <param name="entity">显示字段</param>
        /// <param name="request">数据对象</param>
        /// <returns>返回Object类型的数据</returns>
        public virtual ResponseModel GetDr2EnList<T>(T entity, RequestModel request)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            var result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }

                MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = request.db;
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.ShowField = request.ShowField;
                if (request.TopNum > 0)
                    qcBuilder.Top = request.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                qcBuilder.Predicate = request.Predicate;
                cmd = qcBuilder.GetQueryCommand();
                List<T> objlist = new List<T>();

                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                string sqlWithComment = string.Empty;
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {
                    objlist = DataToModel.Dr2EnList<T>(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = objlist.Count > 0;
                if (result.IsSuccess)
                {
                    result.ResultModel = objlist;
                    result.Message = string.Format("返回数据成功记录数：{0}耗时：{1}", objlist.Count, str);
                }
                else
                {
                    result.Message = "返回失败";
                    result.StrSql = cmd.SqlString;
                }

                return result;

            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {

                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public ResponseModel GetDataTableList(RequestItemSqlModel request)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            var result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }

                if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = request.db;
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                var dtt = db.ExecuteDataTable(request.StrSql);
                if (dtt.Rows.Count > 0)
                {
                    result.IsSuccess = true;
                    result.RecordNum = dtt.Rows.Count;
                    result.DataTable = dtt;
                }
                else
                {
                    result.IsSuccess = false;
                }
            }
            catch (Exception ex)
            {

            }

            return result;
        }

        /// <summary>
        /// 由DataReader转DataTable
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public virtual ResponseModel GetDr2DtList<T>(T entity, RequestModel request)
        {
            var result = new ResponseModel(); QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }

                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                if ((db.IsNull() || db.IsUnEnable) && !(ModuleName.IsEmpty())) db = DataAccessFactory.CreateDataConnection(ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = request.db;
                if (db.IsNull() || db.ConnectionString.IsEmpty()) db = DataAccessFactory.CreateDataConnection(request.ModuleName);//创建数据库连接
                if (db.IsNull() || db.ConnectionString.IsEmpty())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = request.ShowField;
                if (request.TopNum > 0)
                    qcBuilder.Top = request.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                cmd = qcBuilder.GetQueryCommand();
                DataTable dt = new DataTable();

                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();

                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {
                    dt = DataToModel.Dr2Dt(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = dt.IsHaveRows();
                result.DataTable = dt;
                result.Message = string.Format("返回DataTable数据成功记录数：{0}耗时：{1}", dt.Rows.Count, str);
                return result;

            }
            catch (Exception ex)
            {
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }

        #endregion


        /// <summary>
        /// 监控实体的值用于赋初始值
        /// </summary>
        /// <param name="entity"></param>
        public virtual void TrackUpdateValue<T>(T entity) where T : BaseEntityObj
        {


            MetaData typeDescriptor = MetaDataManager.GetMetaData(entity);

            //entity.Values = typeDescriptor.Values;
            //foreach (var mod in typeDescriptor.FieldsColumns)
            //{
            //    typeDescriptor.Values = SetChanaged("", null, typeDescriptor.Values);
            //}


        }


        /// <summary>
        /// 创建一个数据库访问类
        /// </summary>
        /// <param name="dbp"></param>
        /// <returns></returns>
        public IDbContextServiceProvider CreateDataAccess(DataAccess dbp)
        {
            switch (dbp.DatabaseType)
            {
                case DatabaseType.MSSQLServer:
                    DbContextServiceProvider = new Ant.SqlServer.DbContextServiceProvider(PagingMode.ROW_NUMBER); break;
                case DatabaseType.OleDb:
                    DbContextServiceProvider = new Ant.SQLite.DbContextServiceProvider(); break;
                case DatabaseType.Oracle:
                    DbContextServiceProvider = new Ant.Oracle.DbContextServiceProvider(true); break;
                case DatabaseType.MySQL:
                    DbContextServiceProvider = new Ant.MySql.DbContextServiceProvider(); break;
                case DatabaseType.SQLite:
                    DbContextServiceProvider = new Ant.SQLite.DbContextServiceProvider(); break;
            }
            return DbContextServiceProvider;
        }



        /// <summary>
        /// 在上下文中跟踪实体
        /// </summary>
        /// <param name="entity"></param>
        public virtual void TrackEntity(object entity)
        {
            AntUtils.CheckNull(entity);
            Type entityType = entity.GetType();
            if (AntUtils.IsAnonymousType(entityType))
                return;
            Dictionary<Type, TrackEntityCollection> entityContainer = this.TrackingEntityContainer;
            TrackEntityCollection collection;
            if (!entityContainer.TryGetValue(entityType, out collection))
            {
                MetaData typeDescriptor = MetaDataManager.GetMetaData(entity);
                if (!MetaDataManager.HasPrimaryKey(typeDescriptor.FiledMeta))
                    return;
                PropertyInfo pi = typeDescriptor.FiledMeta.EntityType.GetProperty("PersistType",
               BindingFlags.Public | BindingFlags.NonPublic
               | BindingFlags.Instance | BindingFlags.IgnoreCase);
                if (pi != null && pi.CanWrite)
                    pi.SetValue(entity, EntityPersistType.Update, null);

                collection = new TrackEntityCollection(typeDescriptor);
                entityContainer.Add(entityType, collection);
            }
            collection.TryAddEntity(entity);
        }




        /// <summary>
        /// 给实体赋值
        /// </summary>
        /// <param name="FieldName">字段名称</param>
        /// <param name="defaultValue">默认值</param>
        /// <param name="Values"></param>
        Dictionary<string, EntityValue> SetChanaged(string FieldName, object defaultValue, Dictionary<string, EntityValue> Values)
        {
            if (!Values.ContainsKey(FieldName))
            {
                EntityValue val = new EntityValue();
                val.OriginalValue = defaultValue;
                val.FieldName = FieldName;
                val.IsChanage = false;
                Values.Add(FieldName, val);
            }
            else
            {
                EntityValue val = Values[FieldName];
                if (object.Equals(val.OriginalValue, defaultValue))
                {
                    val.CurrentValue = null;
                    val.IsChanage = false;
                }
                else
                {
                    val.CurrentValue = defaultValue;
                    val.IsChanage = true;
                }
            }
            return Values;
        }

        /// <summary>
        /// 带分页的统计记录
        /// </summary>
        /// <param name="md"></param>
        /// <param name="db"></param>
        /// <param name="sqlWithComment"></param>
        /// <returns></returns>
        private ResponseModel PageSumEnd(MetaData md, DataAccess db, string sqlWithComment)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Sum;
                cmd = qcBuilder.GetQueryCommand();
                var num = db.ExecuteScalar(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters).ToInt32();
                result.RecordNum = num;
                result.IsSuccess = true;
                result.Message = "返回成功";
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }




        /// <summary>
        /// 获取自增的值
        /// </summary>
        /// <returns></returns>
        protected virtual string GetSelectLastInsertIdClause(DatabaseType datatype)
        {
            string str = string.Empty;
            switch (datatype)
            {
                case DatabaseType.MSSQLServer:
                    str = "SELECT ISNULL(SCOPE_IDENTITY(),@@rowcount) as ID ;"; break;
                case DatabaseType.SQLite:
                    str = "SELECT LAST_INSERT_ROWID() as ID ;"; break;
                case DatabaseType.Oracle:
                    str = "select emp_sequence.nextval from dual;"; break;
                case DatabaseType.MySQL:
                    str = ""; break;

            }
            return str;
        }



        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        protected virtual IEntityState TryGetTrackedEntityState(object entity)
        {
            AntUtils.CheckNull(entity);
            Type entityType = entity.GetType();
            Dictionary<Type, TrackEntityCollection> entityContainer = this._trackingEntityContainer;

            if (entityContainer == null)
                return null;

            TrackEntityCollection collection;
            if (!entityContainer.TryGetValue(entityType, out collection))
            {
                return null;
            }

            IEntityState ret = collection.TryGetEntityState(entity);
            return ret;
        }
        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            if (this._disposed)
                return;
            this.Dispose(true);
            this._disposed = true;
        }
        /// <summary>
        /// 释放资源
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {

        }
        void CheckDisposed()
        {
            if (this._disposed)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        /// <param name="da"></param>
        /// <returns></returns>
        ResponseModel ExecuteSqlCommand(DbExpression e, DataAccess da)
        {
            ResponseModel reslut = new ResponseModel();
            IDbExpressionTranslator translator = DbContextServiceProvider.CreateDbExpressionTranslator();//构建哪种数据库类型的SQL语句
            List<DbParam> parameters;
            string cmdText = translator.Translate(e, out parameters);

            if (!e.whereSql.IsEmpty())
            {
                CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo;
                if (Compare.IndexOf(cmdText, "where", CompareOptions.IgnoreCase) != -1)
                {
                    cmdText += " and " + e.whereSql;
                }
                else
                {
                    cmdText += " where " + e.whereSql;
                }
            }
            reslut.StrSql = SqlDataAccess.AppendDbCommandInfo(cmdText, parameters.ToArray());//用户记录SQL语句
            reslut.RecordNum = db.ExecuteNonQuery(cmdText, parameters.ToArray());
            reslut.IsSuccess = reslut.RecordNum > 0;
            reslut.Message = "数据返回成功";
            return reslut;
        }
        /// <summary>
        /// 判断是否存生主键
        /// </summary>
        /// <param name="typeDescriptor"></param>
        static void EnsureEntityHasPrimaryKey(FiledMetaData typeDescriptor)
        {
            if (!MetaDataManager.HasPrimaryKey(typeDescriptor))
            {
                throw new AntORMException(string.Format("映射类型'{0}'未定义主键", typeDescriptor.EntityType.FullName));
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="identity"></param>
        /// <param name="conversionType"></param>
        /// <returns></returns>
        static object ConvertIdentityType(object identity, Type conversionType)
        {
            if (identity.GetType() != conversionType)
                return Convert.ChangeType(identity, conversionType);

            return identity;
        }


        #region 暂时不用的代码

        /// <summary>
        /// 自定义SQL语句
        /// </summary>
        /// <typeparam name="T">返回值对应的实体</typeparam>
        /// <param name="da"></param>
        /// <param name="sql"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        //public IEnumerable<T> SqlQuery<T>(DataAccess da, string sql, dynamic param) where T : new()
        //{
        //    AntUtils.CheckNull(sql, "sql");
        //    object obj = param as object;
        //    var typeDescriptor = MetaDataManager.GetMetaData(obj);
        //    if (db.IsNull() || db.ConnectionString.IsEmpty())
        //    {
        //        if (typeDescriptor.ModuleName.IsEmpty())
        //        {
        //            db = da;
        //        }
        //        else
        //        {
        //            db = DataAccessFactory.CreateDataConnection(typeDescriptor.ModuleName);
        //        }
        //    }

        //    List<DbParam> parameters = new List<DbParam>();
        //    foreach (KeyValuePair<string, DbColumn> kv in typeDescriptor.FieldsColumns)
        //    {
        //        DbParam pa = new DbParam();
        //        pa.Name = kv.Value.Name;
        //        pa.Type = kv.Value.Type;
        //        pa.Value = kv.Value.Value;
        //        parameters.Add(pa);
        //    }
        //    var list = new ORMInternalSqlQuery<T>(db, sql, parameters.ToArray());
        //    return list;
        //}
        /// <summary>
        /// 插入操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="body"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        //public virtual ResponseModel Insert<T>(Expression<Func<T>> body, RequestModel request)
        //{

        //    AntUtils.CheckNull(body);

        //    ResponseModel reslut = new ResponseModel();
        //    System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
        //    sw.Start();
        //    if (request.newSt.IsNull() || request.newSt.NewSt.IsNull())
        //    {
        //        reslut.IsSuccess = false;
        //        reslut.Message = "备注信息不能为空";
        //        return reslut;
        //    }
        //    if (db.IsNull() || db.IsUnEnable)
        //    {
        //        db = request.db;
        //    }
        //    if (db.IsNull() || db.IsUnEnable)
        //    {
        //        reslut.IsSuccess = false;
        //        reslut.Message = "数据库配置不正确";
        //        return reslut;
        //    }
        //    if (db.IfNotNull())
        //    {
        //        CreateDataAccess(db);
        //    }
        //    MetaData md = new MetaData();
        //    md.FiledMeta = MetaDataManager.GetMetaData(typeof(T));

        //    EnsureEntityHasPrimaryKey(md.FiledMeta);

        //    MappingMemberDescriptor keyMemberDescriptor = md.FiledMeta.PrimaryKey;
        //    MappingMemberDescriptor autoIncrementMemberDescriptor = md.FiledMeta.AutoIncrement;

        //    Dictionary<MemberInfo, Expression> insertColumns = InitMemberExtractor.Extract(body);

        //    DbInsertExpression e = new DbInsertExpression(md.FiledMeta.Table);

        //    object keyVal = null;

        //    foreach (var kv in insertColumns)
        //    {
        //        MemberInfo key = kv.Key;
        //        MappingMemberDescriptor memberDescriptor = MetaDataManager.TryGetMappingMemberDescriptor(key, md.FiledMeta);

        //        if (memberDescriptor == null)
        //        {
        //            throw new AntORMException(string.Format("该成员'{0}'不映射任何列", key.Name));
        //        }


        //        if (memberDescriptor == autoIncrementMemberDescriptor)
        //        {
        //            throw new AntORMException(string.Format("不能插入主键'{0}'", memberDescriptor.Column.Name));
        //        }


        //        if (memberDescriptor.IsPrimaryKey)
        //        {
        //            object val = ExpressionEvaluator.Evaluate(kv.Value);
        //            if (val == null)
        //            {
        //                throw new AntORMException(string.Format("主键'{0}'不能为 null", memberDescriptor.MemberInfo.Name));
        //            }

        //            else
        //            {
        //                keyVal = val;
        //                e.InsertColumns.Add(memberDescriptor.Column, DbExpression.Parameter(keyVal));
        //                continue;
        //            }
        //        }

        //        e.InsertColumns.Add(memberDescriptor.Column, md.FiledMeta.Visitor.Visit(kv.Value));
        //    }

        //    //主键为空并且主键又不是自增列
        //    if (keyVal == null && keyMemberDescriptor != autoIncrementMemberDescriptor)
        //    {
        //        throw new AntORMException(string.Format("主键'{0}'不能为 null", keyMemberDescriptor.MemberInfo.Name));
        //    }

        //    if (keyMemberDescriptor != autoIncrementMemberDescriptor)
        //    {
        //        this.ExecuteSqlCommand(e, db);
        //        reslut.IsSuccess = true;
        //        return reslut;
        //    }

        //    IDbExpressionTranslator translator = DbContextServiceProvider.CreateDbExpressionTranslator();
        //    List<DbParam> parameters;
        //    string sql = translator.Translate(e, out parameters);
        //    string strsql = SqlDataAccess.AppendDbCommandInfo(sql, parameters.ToArray());//用户记录SQL语句
        //    sql = string.Concat(sql, ";", this.GetSelectLastInsertIdClause(db.DatabaseType));
        //    reslut.StrSql = sql;
        //    reslut.DBConfig = db.ConnectionString;
        //    sw.Stop();
        //    //SELECT @@IDENTITY 返回的是 decimal 类型
        //    object retIdentity = db.ExecuteScalar(sql, parameters.ToArray());

        //    //if (retIdentity == null || retIdentity == DBNull.Value)
        //    //{
        //    //    throw new AntORMException("无法获取的标识值");
        //    //}

        //    //retIdentity = ConvertIdentityType(retIdentity, autoIncrementMemberDescriptor.MemberInfoType);

        //    if (retIdentity.ToInt32() > 0)
        //    {
        //        reslut.IsSuccess = true;
        //        reslut.Message = "插入记录成功,耗时：" + sw.Elapsed.ToString();
        //        reslut.RecordNum = retIdentity.ToInt32();
        //    }

        //    return reslut;
        //}

        #endregion

    }


    /// <summary>
    /// 接口
    /// </summary>
    public interface IAntORM : IDisposable
    {
        //IDbSession CurrentSession { get; }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        IQuery<T> Queryable<T>() where T : new();
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="db"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        IEnumerable<T> Sqlable<T>(string sql, DataAccess db, params DbParam[] parameters) where T : new();

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="body"></param>
        /// <param name="request"></param>
        /// <returns>PrimaryKey</returns>
        //ResponseModel Insert<T>(Expression<Func<T>> body, RequestModel request);
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        ResponseModel UpdateById<T>(T entity, RequestModel request);
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="body"></param>
        /// <param name="condition"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        ResponseModel UpdateByLambda<T>(Expression<Func<T, T>> body, Expression<Func<T, bool>> condition, RequestModel request);
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        ResponseModel DeleteByModel<T>(T entity, RequestModel request);
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="condition"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        ResponseModel DeleteByLambda<T>(Expression<Func<T, bool>> condition, RequestModel request);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        void TrackEntity(object entity);
    }


    /// <summary>
    /// 跟踪实体的值变化
    /// </summary>
    class TrackEntityCollection
    {
        public TrackEntityCollection(MetaData typeDescriptor)
        {
            this.TypeDescriptor = typeDescriptor;
            this.Entities = new Dictionary<object, IEntityState>(1);
        }
        public MetaData TypeDescriptor { get; private set; }
        /// <summary>
        /// 实体的状态
        /// </summary>
        public Dictionary<object, IEntityState> Entities { get; private set; }
        public bool TryAddEntity(object entity)
        {
            if (this.Entities.ContainsKey(entity))
            {
                return false;
            }

            IEntityState entityState = new EntityState(this.TypeDescriptor, entity);
            this.Entities.Add(entity, entityState);

            return true;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public IEntityState TryGetEntityState(object entity)
        {
            IEntityState ret;
            if (!this.Entities.TryGetValue(entity, out ret))
                ret = null;

            return ret;
        }
    }
}