MESProductionWeb/AntORM/Ant.ORM/DataBaise/HelpSQL/PersistSingle.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Data;
using System.Data.Common;
using System.Reflection;
using Ant.Data;
using System.Transactions;
using System.Configuration;
using Ant.Frame;
using Ant.ORM;
using Ant.Common;
using Ant.Descriptors;
using System.Linq;

namespace Ant.ORM
{
    /// <summary>
    /// 单表操作数据持久类
    /// <remarks>要求配置Ant.Data配置节</remarks>
    /// </summary>
    public static class PersistSingle
    {
        private static object lockHelper = new object();
        //private static string logfile = ConfigurationManager.AppSettings["DataDynamicsARLic"].ToLower();
        private static Dictionary<string, QueryParameterCollection> SqlCmd = new Dictionary<string, QueryParameterCollection>();


        #region 将实体转成SQL语句

        #region 添加修改方法


        /// <summary>
        /// 保存数据
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static ResponseModel SaveDesc<T>(this 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
            {

                TypeDescriptor md = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                if (request.db.IsNull())
                    request.db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (request.db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(request.db.DatabaseType);//构建生成哪种SQL语句
                qcBuilder.TypeDes = 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 = request.db.ConnectionString;
                int num = 0; var location = cmd.CommandText.EndsWith(ConstSql.SQL_SCOPE_IDENTITY, StringComparison.CurrentCultureIgnoreCase);
                if (location)
                {
                    num = (!cmd.CommandText.IsEmpty()) ? request.db.ExecuteScalar(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters).ToInt32() : 0;//执行SQL语句
                    result.RecordNum = num;
                }
                else
                {
                    num = (!cmd.CommandText.IsEmpty()) ? request.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 (request.db.IfNotNull()) request.db.Close();
            }
            return result;
        }


        /// <summary>
        /// 根据查询实体去批量更新数据
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static ResponseModel UpdateEntityDesc(this object entity, ResquestUpdateModel request)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = (request.QueryModel.IfNotNull()) ? TypeDescriptor.ParserMeta(entity, request.QueryModel) : TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                if (request.db.IsNull()) request.db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接
                if (request.db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(request.db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                qcBuilder.PersistType = EntityPersistType.Update;
                qcBuilder.Predicate = request.Predicate;
                cmd = qcBuilder.GetQueryCommand();//解析SQL语句
                int num = request.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 = request.db.ConnectionString;
                if (!request.db.IsNull()) request.db.Close();
            }
            return result;
        }



        /// <summary>
        /// 更新自带Where条件的数据
        /// </summary>
        /// <param name="entyvlaue">更新的数据</param>
        /// <param name="filter">更新的条件</param>
        /// <param name="db">连接数据库对象</param>
        /// <returns></returns>
        public static bool UpdateEntity(object entyvlaue, object filter, DataAccess db = null)
        {
            try
            {
                SqlCmd = new Dictionary<string, QueryParameterCollection>();
                TypeDescriptor md = TypeDescriptor.ParserMeta(entyvlaue, filter);//获取实体的元数据
                if (!string.IsNullOrEmpty(md.WhereSql))
                {
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//根据不同的数据库类型创建不同的SQL语句的类
                    qcBuilder.TypeDes = md;
                    qcBuilder.PersistType = EntityPersistType.Update;
                    qcBuilder.Fields = MetaDataManager.GetEntityFields(entyvlaue);
                    QueryCommand cmd = qcBuilder.GetQueryCommand();//解析SQL语句
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    int num = db.ExecuteNonQuery(cmd.CommandText, cmd.Parameters);//执行SQL语句
                    return num > 0;
                }
                else
                {
                    SqlCmd.Add("没有更新Where条件，无法更新操作", null);
                    return false;
                }

            }
            catch (Exception ex)
            {

                return false;
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
        }
        #endregion

        #region 删除DELETE方法



        /// <summary>
        /// 删除最终方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static ResponseModel DeleteDesc(this object 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();
                TypeDescriptor md = TypeDescriptor.ParserMeta(entity); //获取实体的元数据

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

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(request.db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = 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 = request.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>
        /// 删除操作
        /// public static bool DeleteById<T>(this object entity, string oid, DataAccess db = null) where T : EntityBase, new()
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="oid"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static bool DeleteById(this object entity, string oid, DataAccess db = null)
        {
            SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                TypeDescriptor md = TypeDescriptor.ParserMeta(entity); //获取实体的元数据
                md.WhereSql = ModPerkey(md.PrimaryKey.MemberInfo.Name, oid);//自定义查询
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接
                using (db)
                {
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.TypeDes = md;
                    qcBuilder.PersistType = EntityPersistType.Delete;
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    int num = 0;
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    num = db.ExecuteNonQuery(cmd.CommandText, cmd.Parameters);//执行SQL语句
                    return num > 0;
                }
            }
            catch (Exception ex)
            {

                throw ex;
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
        }

        #endregion

        #region 获取单个实体


        /// <summary>
        /// 获取单个实体简化版
        /// </summary>
        /// <typeparam name="entity">实体类型</typeparam>
        /// <param name="oid">主键ID</param>
        /// <param name="db">数据库对象</param>
        /// <returns></returns>
        public static dynamic GetById(this object entity, string oid, DataAccess db = null)
        {
            var obj = Activator.CreateInstance(entity.GetType()); SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                if (!string.IsNullOrEmpty(oid))
                {
                    QueryCommandBuilders querycommd = new QueryCommandBuilders();
                    TypeDescriptor md = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接
                    using (db)
                    {
                        QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                        qcBuilder.TypeDes = md;
                        qcBuilder.PersistType = EntityPersistType.Query;
                        md.WhereSql = ModPerkey(md.PrimaryKey.MemberInfo.Name, oid);//自定义查询
                        qcBuilder.Top = "1";
                        qcBuilder.SqlType = SqlEnum.MainSql;
                        QueryCommand cmd = qcBuilder.GetQueryCommand();
                        SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                        using (IDataReader rdr = db.ExecuteDataReader(cmd.CommandText, cmd.Parameters))
                        {
                            obj = DataToModel.Dr2EnObj(rdr, entity);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
            return obj;
        }


        /// <summary>
        /// 获取单个实体最终方法
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static ResponseModel GetEntityDesc(this object entity, RequestModel request)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            object obj = Activator.CreateInstance(entity.GetType());
            DataAccess db = request.db;
            var result = new ResponseModel(); var typeDescriptor = TypeDescriptor.ParserMeta(entity);

            QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {

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

                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType); //构建生成哪种SQL语句
                qcBuilder.TypeDes = 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))
                {
                    DataTable dtt = DataToModel.Dr2Dt(rdr);
                    obj = DataToModel.Dt2EnObj(dtt, entity);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = obj.IfNotNull();
                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();
            }
        }



        #endregion

        #region 分页查询调用方法

        /// <summary>
        /// 获取分页数据返回实体集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static ResponseModel GetPageListEnd(this object entity, RequestModel request)
        {
            var result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            var db = request.db;
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                //QueryCommandBuilders querycommd = new QueryCommandBuilders();
                var typeDescriptor = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                //if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接

                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = typeDescriptor;//实体属性
                qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
                qcBuilder.PageNo = request.StartNum;
                qcBuilder.PageSize = request.PageSize;
                //qcBuilder.SelectField = enty.SelectField;
                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(dt, entity);
                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>
        /// 带分页的统计记录
        /// </summary>
        /// <param name="md"></param>
        /// <param name="db"></param>
        /// <param name="sqlWithComment"></param>
        /// <returns></returns>
        private static ResponseModel PageSumEnd(TypeDescriptor md, DataAccess db, string sqlWithComment)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = 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>
        /// <param name="entity"></param>
        /// <param name="enty"></param>
        /// <returns></returns>
        //private ResponseTable GetPageRecordDtEnd(string showfield, int startNum, int pageSize)
        public static ResponseModel GetPageRecordDtEnd(this object entity, RequestModel enty)
        {
            DataAccess db = enty.db; QueryCommand cmd = new QueryCommand();
            ResponseModel result = new ResponseModel();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                var typeDescriptor = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(typeDescriptor.ModuleName, DataConfigEnum.WriteData);//创建数据库连接

                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = typeDescriptor;//实体属性
                qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
                qcBuilder.PageNo = enty.StartNum;
                qcBuilder.PageSize = enty.PageSize;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = enty.ShowField;
                cmd = qcBuilder.GetQueryCommand();

                System.Diagnostics.StackFrame[] sfs = enty.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框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                DataTable dt = db.ExecuteDataTable(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = dt.Rows.Count > 0;
                result.RecordNum = PageSumEnd(typeDescriptor, db, sqlWithComment).RecordNum;
                result.DataTable = dt;
                result.Message = "查询返回成功,用时：" + str;

                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }


        #region 分页查询
        /// <summary>
        /// 分页查询startNum开始记录，pageSize几条记录进行分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">所有参数及查询条件</param>
        /// <param name="pageSize">页数</param>
        /// <param name="startNum">开始记录</param>
        /// <returns>返回查询的记录</returns>
        public static DataTable GetPageDataTable(object entity, int startNum, int pageSize)
        {
            DataTable dt = new DataTable(); DataAccess db = null; SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                if (entity != null)
                {
                    QueryCommandBuilders querycommd = new QueryCommandBuilders();
                    MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.Md = md;
                    qcBuilder.PersistType = EntityPersistType.QueryPage;
                    qcBuilder.PageNo = startNum;
                    qcBuilder.PageSize = pageSize;
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    querycommd.Add(qcBuilder);
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    dt = db.ExecuteDataTable(cmd.CommandText, cmd.Parameters);
                }
            }
            catch (Exception ex)
            {

            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
            return dt;
        }
        /// <summary>
        /// 分页查询startNum开始记录，pageSize几条记录进行分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">所有参数及查询条件</param>
        /// <param name="pageSize">页数</param>
        /// <param name="startNum">开始记录</param>
        /// <returns>返回查询的记录</returns>
        public static DataSet GetPageDataSet(object entity, int startNum, int pageSize)
        {
            DataAccess db = null; SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                if (entity != null)
                {
                    QueryCommandBuilders querycommd = new QueryCommandBuilders();
                    MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.Md = md;
                    qcBuilder.PersistType = EntityPersistType.QueryPage;
                    qcBuilder.PageNo = startNum;
                    qcBuilder.PageSize = pageSize;
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    querycommd.Add(qcBuilder);
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    return db.ExecuteDataSet(cmd.CommandText, cmd.Parameters);
                }
                else
                    return new DataSet();
            }
            catch (Exception ex)
            {

                return new DataSet();
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
        }
        /// <summary>
        /// 分页查询startNum开始记录，pageSize几条记录进行分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">所有参数及查询条件</param>
        /// <param name="pageSize">页数</param>
        /// <param name="startNum">开始记录</param>
        /// <returns>返回查询的记录</returns>
        public static List<T> GetPageList<T>(object entity, int startNum, int pageSize) where T : EntityBase, new()
        {
            List<T> objlist = new List<T>(); DataAccess db = null; SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                QueryCommandBuilders querycommd = new QueryCommandBuilders();
                MetaData md = new MetaData();
                if (entity != null)
                {
                    md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.Md = md;
                    qcBuilder.PersistType = EntityPersistType.QueryPage;
                    qcBuilder.PageNo = startNum;
                    qcBuilder.PageSize = pageSize;
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    querycommd.Add(qcBuilder);
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    DataTable dt = db.ExecuteDataTable(cmd.CommandText, cmd.Parameters);
                    if (!object.Equals(dt, null)) objlist = DataToModel.Dt2EnList<T>(dt);
                }
            }
            catch (Exception ex)
            {

            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
            return objlist;
        }

        #endregion

        #region 统计表记录

        /// <summary>
        /// 数据的总记录
        /// </summary>
        /// <returns></returns>
        public static ResponseModel SumDesc(this object entity, RequestModel request)
        {
            DataAccess db = null; ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                var typeDescriptor = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(typeDescriptor.ModuleName, DataConfigEnum.WriteData);//创建数据库连接 
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                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);
                }
                return PageSumEnd(typeDescriptor, db, sqlWithComment);



            }
            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>
        /// <typeparam name="T">实体类型</typeparam>
        /// <returns></returns>
        public static int Sum(this object entity)
        {
            DataAccess db = null; SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                if (entity != null)
                {
                    QueryCommandBuilders querycommd = new QueryCommandBuilders();
                    var typeDescriptor = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(typeDescriptor.ModuleName);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.TypeDes = typeDescriptor;
                    qcBuilder.PersistType = EntityPersistType.Sum;
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    return Convert.ToInt32(db.ExecuteScalar(cmd.CommandText, cmd.Parameters));
                }
                else
                    return 0;
            }
            catch (Exception ex)
            {
                throw ex;

            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
        }


        #endregion

        #endregion

        #region 查询SELECT方法



        #region GetDataReaderList方法



        /// <summary>
        /// 由DataReader转DataTable
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static ResponseModel GetDr2DtListEnd(this object entity, RequestModel request)
        {
            var result = new ResponseModel(); DataAccess db = request.db; QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = 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();

                //dt = db.ExecuteDataTable(cmd.CommandText, cmd.Parameters);
                //sw.Stop();
                //string str = sw.Elapsed.ToString();

                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("返回数据成功记录数：{0}耗时：{1}", dt.Rows.Count, 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();
            }
            return result;
        }


        /// <summary>
        /// 通过DataReader返回List集合这种效率高
        /// </summary>
        /// <param name="entity">显示字段</param>
        /// <param name="request">数据对象</param>
        /// <returns>返回Object类型的数据</returns>
        public static ResponseModel GetDr2EnListEnd<T>(this object entity, RequestModel request)
        {
            var result = new ResponseModel(); DataAccess db = request.db; QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = TypeDescriptor.ParserMeta(entity);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                qcBuilder.ShowField = request.ShowField;
                if (request.TopNum > 0)
                    qcBuilder.Top = request.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                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>
        /// 通过DataReader返回List集合这种效率高
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="entity">查询条件</param>
        /// <returns>返回Object类型的数据</returns>
        public static object GetDataReaderList(this object entity)
        {
            DataAccess db = null; SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                if (entity != null)
                {
                    QueryCommandBuilders querycommd = new QueryCommandBuilders();
                    MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.Md = md;
                    qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    querycommd.Add(qcBuilder);
                    object objlist = new object();
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    using (IDataReader rdr = db.ExecuteDataReader(cmd.CommandText, cmd.Parameters))
                    {
                        objlist = DataToModel.Dr2EnList(rdr, entity);
                    }
                    return objlist;
                }
                else
                    return null;
            }
            catch (Exception ex)
            {

                return null;
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
        }


        /// <summary>
        /// 通过DataReader返回List集合这种效率高
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="entity">查询条件</param>
        /// <returns>返回的实体本身的数据</returns>
        public static object GetDataReaderList<T>(object entity)
        {
            DataAccess db = null; SqlCmd = new Dictionary<string, QueryParameterCollection>();
            try
            {
                if (entity != null)
                {
                    QueryCommandBuilders querycommd = new QueryCommandBuilders();
                    MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                    if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                    QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                    qcBuilder.Md = md;
                    qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                    QueryCommand cmd = qcBuilder.GetQueryCommand();
                    querycommd.Add(qcBuilder);
                    List<T> objt = new List<T>(); List<object> obj = new List<object>();
                    SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                    using (IDataReader rdr = db.ExecuteDataReader(cmd.CommandText, cmd.Parameters))
                    {
                        objt = DataToModel.Dr2EnList<T>(rdr);
                    }
                    return objt;
                }
                else
                    return null;
            }
            catch (Exception ex)
            {

                return null;
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }
        }
        #endregion





        #endregion

        #endregion



        /// <summary>
        /// 获取是否存在的SQL
        /// </summary>
        /// <returns></returns>
        public static string GetExistsSql()
        {
            return "IF EXISTS (SELECT 1 FROM {0} WHERE {1}) SELECT 1 ELSE SELECT 0";
        }


        #region 执行SQL和存储过程
        public static bool Exists(string strSql)
        {
            DataAccess db = DataAccessFactory.GetWriteDataDefault;
            object obj = db.ExecuteScalar(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="strSql"></param>
        /// <returns></returns>
        public static bool ExecuteSql(string strSql)
        {
            DataAccess db = DataAccessFactory.GetWriteDataDefault;
            object obj = db.ExecuteScalar(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, DataAccess db)
        {
            int rows = db.ExecuteNonQuery(SQLString);
            return rows;
        }
        /// <summary>
        /// 通过此方法可以执行存储过程
        /// </summary>
        /// <param name="commtext">存储过程</param>
        /// <param name="entity">参数</param>
        /// <returns></returns>
        public static bool Execomm(string commtext, object entity)
        {
            DataAccess db = DataAccessFactory.GetWriteDataDefault;
            try
            {
                MetaData md = MetaDataManager.GetMetaData(entity);//获取实体的元数据
                MSSqlQueryCommandBuilder qcBuilder = new MSSqlQueryCommandBuilder(); ;//Ant.ORM
                qcBuilder.EntityType = md.FiledMeta.EntityType;//实体类型
                qcBuilder.PersistType = EntityPersistType.eNonDelete;//操作类型
                qcBuilder.Fields = MetaDataManager.GetEntityFields(entity);
                //注：需要修改
                QueryCommand cmd = qcBuilder.GetQueryCommand();//转成SQL语句
                SqlCmd.Add(cmd.CommandText, cmd.Parameters);
                return db.ExecuteNonQuery(commtext, CommandType.StoredProcedure, cmd.Parameters) > 0;
                //DAO.ExecuteSql(cmd.CommandText);
            }
            catch (Exception ex)
            {

                return false;
            }
            finally
            {
                if (!db.IsNull()) db.Close();
            }

        }
        #endregion

        /// <summary>
        /// Object转换成实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static List<T> ObjListToEnList<T>(object obj)
        {
            List<T> ListEnty = new List<T>();
            if (!object.Equals(obj, null))
            {

                List<object> listmod = (List<object>)obj;
                foreach (object mod in listmod)
                {
                    T enty = (T)mod;
                    ListEnty.Add(enty);
                }
                return ListEnty;
            }
            else
                return null;
        }
        /// <summary>
        /// 将dt转化成Json数据将dt转化成Json数据 格式如 table[{id:1,title:'体育'},id:2,title:'娱乐'}]
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="fromCount">序号的初始值</param>
        /// <param name="totalCountStr">表记录名称</param>
        /// <param name="tbname">表名称</param>
        /// <returns></returns>
        public static string DataTable2JSON(DataTable dt, int fromCount, string totalCountStr, string tbname)
        {
            StringBuilder jsonBuilder = new StringBuilder();
            jsonBuilder.Append(totalCountStr + ":" + dt.Rows.Count + "," + tbname + ": [");
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                if (i > 0)
                    jsonBuilder.Append(",");
                jsonBuilder.Append("{");
                jsonBuilder.Append("no:" + (fromCount + i + 1) + ",");
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    if (j > 0)
                        jsonBuilder.Append(",");

                    jsonBuilder.Append(dt.Columns[j].ColumnName.ToLower() + ": '" + dt.Rows[i][j].ToString().Replace("\\", "\\\\").Replace("\'", "\\\'").Replace("\t", " ").Replace("\r", " ").Replace("\n", "<br/>") + "'");
                }
                jsonBuilder.Append("}");
            }
            jsonBuilder.Append("]");
            return jsonBuilder.ToString();

        }
        /// <summary>
        /// 查询条件表达式
        /// </summary>
        /// <param name="type"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        private static string ModiFilter(Type type, string strwhere)
        {
            string tmpFilter = strwhere;
            if (!tmpFilter.StartsWith(" "))
                tmpFilter = " " + tmpFilter;
            MetaData md = new MetaData();
            md.FiledMeta = MetaDataManager.GetMetaData(type);//获取实体的元数据
            foreach (string s in md.FiledMeta.FieldMeteDatas.Keys)
            {
                string pattern = new StringBuilder(@"\s").Append(s).Append(@"[\s|+|-|*|/|=|&|\^|!|>|<|~|(|)]").ToString();
                if (Regex.IsMatch(tmpFilter, pattern))
                {
                    MatchCollection matches = Regex.Matches(tmpFilter, pattern);
                    foreach (Match match in matches)
                    {
                        tmpFilter = Regex.Replace(tmpFilter, match.Value, match.Value.Replace(s, md.FiledMeta.FieldMeteDatas[s].ColumnName));
                    }
                }
            }
            return tmpFilter;
        }

        /// <summary>
        /// 查询条件表达式
        /// </summary>
        /// <param name="type"></param>
        /// <param name="oid">主键值</param>
        /// <returns></returns>
        private static string ModPerkey(string oid, string value)
        {
            string tmpFilter = value;
            if (!string.IsNullOrEmpty(tmpFilter))
                tmpFilter = oid + "='" + tmpFilter + "'";
            return tmpFilter;
        }



    }
}