CS_GIS/Data/Data.ADO/TableClass.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Data;

using Tofly.Data.General;
using Tofly.Data.Metadata;
using Tofly.Core.Util;
using Tofly.Core.Context;
using Tofly.Core.Context.Support;
using Tofly.Data.MetadataManager;

namespace Tofly.Data.ADO
{
    /// <summary>
    /// 定义表操作对象
    /// </summary>
    public abstract class TableClass : ITable
    {
        private IWorkspace adoWorkspace;
        private ITableInfo tableInfo;
        private string tableName;

        public TableClass(IWorkspace pWorkspace, string tableName)
        {
            this.adoWorkspace = pWorkspace;
            this.tableName = tableName;

            TableType tableType = this.adoWorkspace.GetObjectType(tableName);
            if (tableType == General.TableType.Raster || tableType == General.TableType.UnDefine)
                throw new Exception("数据表：" + tableName + "不存在！");
        }

        /// <summary>
        /// 获取表信息
        /// </summary>
        protected virtual ITableInfo TableInfo
        {
            get
            {
                if (tableInfo == null)
                {
                    tableInfo = this.adoWorkspace.GetTableMetadate(tableName);
                    Tofly.Data.Util.AutoFieldUtils.DoAutoField(tableInfo, metadataTable);
                }
                return tableInfo;
            }
        }

        #region ITable 成员

        /// <summary>
        /// 获取当前表空间
        /// </summary>
        public virtual IWorkspace Workspace
        {
            get { return adoWorkspace; }
        }

        private bool hascheckmetadatatable = false;
        private IMetadataTable metadataTable;
        /// <summary>
        /// 获取或设置结构表信息
        /// </summary>
        public virtual IMetadataTable MetadataTable
        {
            get
            {
                lock (this)
                {
                    if (metadataTable == null && TableToMetadataTable != null && !hascheckmetadatatable)
                    {
                        metadataTable = TableToMetadataTable.ToMetadataTable(this);
                        Tofly.Data.Util.AutoFieldUtils.DoAutoField(tableInfo, metadataTable);
                        hascheckmetadatatable = true;
                    }
                    return metadataTable;
                }
            }
            set
            {
                lock (this)
                {
                    metadataTable = value;
                    Tofly.Data.Util.AutoFieldUtils.DoAutoField(tableInfo, metadataTable);
                }
            }
        }

        private ITableToMetadataTable tableToMetadataTable;
        /// <summary>
        /// 定义根据物理表查找结构表接口
        /// </summary>
        public virtual ITableToMetadataTable TableToMetadataTable
        {
            get
            {
                lock (this)
                {
                    if (tableToMetadataTable == null)
                    {
                        IApplicationContext context = ContextRegistry.GetContext();
                        string objName = "TableToMetadataTable";
                        tableToMetadataTable = context.GetObject(objName) as ITableToMetadataTable;
                    }
                }
                return tableToMetadataTable;
            }
            set
            {
                tableToMetadataTable = value;
            }
        }

        /// <summary>
        /// 获取表名称
        /// </summary>
        public string TableName
        {
            get { return tableName; }
        }

        /// <summary>
        /// 获取表类型
        /// </summary>
        public TableType TableType
        {
            get
            {
                if (this.MetadataTable != null)
                    return this.MetadataTable.TableType;
                else
                    return TableInfo.TableType;
            }
            set { }
        }

        /// <summary>
        /// 获取字段信息
        /// </summary>
        public Field[] Fields
        {
            get
            {
                if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                    return this.MetadataTable.Fields;
                else
                    return TableInfo.Fields;
            }
        }

        /// <summary>
        /// 获取字段信息
        /// </summary>
        public Field[] DataBaseFields
        {
            get
            {
                return TableInfo.Fields;
            }
        }

        /// <summary>
        /// 根据字段名获取字段信息
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <returns></returns>
        public Field GetDataBaseField(string fieldName)
        {
            return TableInfo.GetField(fieldName);
        }

        /// <summary>
        /// 获取字段总数
        /// </summary>
        public int FieldCount
        {
            get
            {
                if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                    return this.MetadataTable.FieldCount;
                else
                    return TableInfo.FieldCount;
            }
        }

        /// <summary>
        /// 根据字段名获取字段信息
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <returns></returns>
        public Field GetField(string fieldName)
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetField(fieldName);
            else
                return TableInfo.GetField(fieldName);
        }

        /// <summary>
        /// 获取主键
        /// </summary>
        /// <param name="fields"></param>
        /// <returns></returns>
        public Field[] GetKeyFields()
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetKeyFields();
            else
                return TableInfo.GetKeyFields();
        }

        /// <summary>
        /// 获取主键
        /// </summary>
        /// <param name="fields"></param>
        /// <returns></returns>
        public Field[] GetKeyNoAutoFields()
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetKeyNoAutoFields();
            else
                return TableInfo.GetKeyNoAutoFields();
        }

        /// <summary>
        /// 获取唯一值，非key和auto
        /// </summary>
        /// <returns></returns>
        public Field[] GetUniqueFields()
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetUniqueFields();
            else
                return TableInfo.GetUniqueFields();
        }

        /// <summary>
        /// 获取自动增值字段
        /// </summary>
        /// <param name="fields"></param>
        /// <returns></returns>
        public Field[] GetAutoFields()
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetAutoFields();
            else
                return TableInfo.GetAutoFields();
        }

        /// <summary>
        /// 获取自动增值字段
        /// </summary>
        /// <param name="fields"></param>
        /// <returns></returns>
        public Field GetAutoField()
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetAutoField();
            else
                return TableInfo.GetAutoField();
        }

        /// <summary>
        /// 获取OID字段
        /// </summary>
        public string OIDFieldName
        {
            get
            {
                Field field = GetAutoField();
                if (field == null)
                    return null;
                else
                    return field.FieldName;
            }
        }

        /// <summary>
        /// 获取需要编码规则的字段
        /// </summary>
        /// <returns></returns>
        public Field[] GetCodeRuleFields()
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetCodeRuleFields();
            else
                return TableInfo.GetCodeRuleFields();
        }

        /// <summary>
        /// 获取查询字符串
        /// </summary>
        /// <param name="onlyCanShow">是否只是显示字段</param>
        /// <returns></returns>
        public String GetSelectFields(bool onlyCanShow)
        {
            if (this.MetadataTable != null && this.MetadataTable.FieldCount > 0)
                return this.MetadataTable.GetSelectFields(onlyCanShow);
            else
                return TableInfo.GetSelectFields(onlyCanShow);
        }

        /// <summary>
        /// 添加字段
        /// </summary>
        /// <param name="field"></param>
        public virtual void AddField(Field field)
        {
            TableInfoClass pInfo = TableInfo as TableInfoClass;
            if (pInfo == null)
                throw new NotSupportedException();
            if (field != null && !StringUtils.IsNullOrSpace(field.FieldName))
            {
                if (!pInfo.InnerFields.ContainsKey(field.FieldName.ToUpper().Trim()))
                {
                    pInfo.InnerFields.Add(field.FieldName.ToUpper().Trim(), field);
                    this.adoWorkspace.AddTableField(field, tableName);
                    if (this.MetadataTable != null)
                        this.MetadataTable.AddField(field);
                }
            }
        }

        /// <summary>
        /// 添加逻辑字段
        /// </summary>
        /// <param name="field"></param>
        public void AddLogicField(Field field)
        {
            TableInfoClass pInfo = TableInfo as TableInfoClass;
            if (pInfo == null)
                throw new NotSupportedException();
            if (field != null && !StringUtils.IsNullOrSpace(field.FieldName))
            {
                if (!pInfo.InnerFields.ContainsKey(field.FieldName.ToUpper().Trim()))
                {
                    pInfo.InnerFields.Add(field.FieldName.ToUpper().Trim(), field);

                    if (this.MetadataTable != null)
                        this.MetadataTable.AddLogicField(field);
                }
            }
        }

        /// <summary>
        /// 移除字段
        /// </summary>
        /// <param name="field"></param>
        public virtual void RemoveField(Field field)
        {
            TableInfoClass pInfo = TableInfo as TableInfoClass;
            if (pInfo == null)
                throw new NotSupportedException();

            if (field != null && !StringUtils.IsNullOrSpace(field.FieldName))
            {
                if (pInfo.InnerFields.ContainsKey(field.FieldName.ToUpper().Trim()))
                {
                    pInfo.InnerFields.Remove(field.FieldName.ToUpper().Trim());
                    this.adoWorkspace.DeleteTableField(field.FieldName, tableName);
                }
            }
        }

        /// <summary>
        /// 移除字段
        /// </summary>
        /// <param name="fields"></param>
        public virtual void RemoveFields(List<Field> fields)
        {
            if (fields == null || fields.Count == 0)
                return;

            if (this.Workspace.WorkspaceType != WorkspaceType.SqlLite)
            {
                for (int i = 0; i < fields.Count; i++)
                    this.RemoveField(fields[i]);
            }
            else
            {
                string sSelectFields = null;
                List<string> fieldstrings = new List<string>();
                for (int i = 0; i < fields.Count; i++)
                {
                    fieldstrings.Add(fields[i].FieldName);
                }

                for (int i = 0; i < this.FieldCount; i++)
                {
                    Field pField = this.Fields[i];
                    if (pField == null)
                        continue;
                    if (fieldstrings.Contains(pField.FieldName))
                        continue;

                    sSelectFields += pField.FieldName + ",";
                }

                string temptablename = this.TableName + "_Temp";
                if (!string.IsNullOrEmpty(sSelectFields))
                {
                    sSelectFields = sSelectFields.Substring(0, sSelectFields.Length - 1);

                    //执行sql语句（数据也同样也添加过去）
                    string strSql = string.Format("CREATE TABLE {0} AS SELECT {1} FROM {2}", temptablename, sSelectFields, this.TableName);
                    this.Workspace.ExecuteSql(strSql);

                    //第二步  删除最初的表
                    strSql = string.Format("DROP TABLE IF EXISTS {0}", this.TableName);
                    this.Workspace.ExecuteSql(strSql);

                    //第三步  修改创建的表名为原表名
                    strSql = string.Format("ALTER TABLE {0} RENAME TO {1}", temptablename, this.TableName);
                    this.Workspace.ExecuteSql(strSql);
                }
            }
        }

        /// <summary>
        /// 移除字段
        /// </summary>
        /// <param name="field"></param>
        public void RemoveLogicField(Field field)
        {
            TableInfoClass pInfo = TableInfo as TableInfoClass;
            if (pInfo == null)
                throw new NotSupportedException();

            if (field != null && !StringUtils.IsNullOrSpace(field.FieldName))
            {
                if (pInfo.InnerFields.ContainsKey(field.FieldName.ToUpper().Trim()))
                {
                    pInfo.InnerFields.Remove(field.FieldName.ToUpper().Trim());
                    if (this.MetadataTable != null)
                        this.MetadataTable.RemoveLogicField(field);
                }
            }
        }        

        /// <summary>
        /// 更新字段
        /// </summary>
        /// <param name="field"></param>
        public virtual void UpdateField(Field field)
        {
            TableInfoClass pInfo = TableInfo as TableInfoClass;
            if (pInfo == null)
                throw new NotSupportedException();

            if (field != null && !StringUtils.IsNullOrSpace(field.FieldName))
            {
                if (pInfo.InnerFields.ContainsKey(field.FieldName.ToUpper().Trim()))
                {
                    pInfo.InnerFields[field.FieldName.ToUpper().Trim()] = field;
                    this.adoWorkspace.UpdateTableField(field, tableName);
                }
                else
                {
                    throw new Exception();
                }
            }
        }

        /// <summary>
        /// 返回DataReader数据
        /// </summary>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <param name="dataDelegate">数据委托</param>
        public virtual void GetDataReader(IQueryFilter queryFilter, DataReaderDelegate dataDelegate)
        {
            if (dataDelegate == null)
                return;
            string sql = QueryFilter.ConvertToSql(this, queryFilter);
            if (queryFilter == null)
                adoWorkspace.GetDataReader(sql, dataDelegate);
            else
                adoWorkspace.GetDataReader(sql, dataDelegate, queryFilter.WhereParameter);
        }

        /// <summary>
        /// 执行SQL语句返回查询结果object
        /// </summary>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns>执行出错返回 null</returns>
        public virtual object GetExecuteScalar(IQueryFilter queryFilter)
        {
            string sql = QueryFilter.ConvertToSql(this, queryFilter);
            return adoWorkspace.GetExecuteScalar(sql, queryFilter.WhereParameter);
        }

        /// <summary>
        /// 返回DataTable数据
        /// </summary>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public virtual DataTable GetDataTable(IQueryFilter queryFilter)
        {
            string sql = QueryFilter.ConvertToSql(this, queryFilter);
            DataTable dt = null;
            if (queryFilter == null)
            {
                dt = adoWorkspace.GetDataTable(sql);
            }
            else
            {
                dt = adoWorkspace.GetDataTable(sql, queryFilter.WhereParameter);
            }
            return dt;
        }

        /// <summary>
        /// 将数据绑定到自定义数据类型上
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public virtual List<T> GetEntityList<T>(IQueryFilter queryFilter) where T : IRow, new()
        {
            List<T> entityBaseList = new List<T>();
            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, Object tag)
            {
                while (reader.Read())
                {
                    if (reader.Row is T)
                    {
                        entityBaseList.Add((T)reader.Row);
                    }
                    else
                    {
                        T entity = new T();
                        entity.OriginalObjects = reader.Row.OriginalObjects;
                        entity.CurrentObjects = reader.Row.CurrentObjects;
                        entityBaseList.Add(entity);
                    }
                }
            });

            return entityBaseList;
        }

        /// <summary>
        /// 将数据绑定到自定义数据类型上
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public virtual T GetEntity<T>(IQueryFilter queryFilter) where T : IRow, new()
        {
            T entity = default(T);
            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, Object tag)
            {
                if (reader.Read())
                {
                    if (reader.Row is T)
                    {
                        entity = (T)reader.Row;
                    }
                    else
                    {
                        entity = new T();
                        entity.OriginalObjects = reader.Row.OriginalObjects;
                        entity.CurrentObjects = reader.Row.CurrentObjects;
                    }
                }
            });
            return entity;
        }

        /// <summary>
        /// 返回DataReader数据
        /// </summary>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <param name="dataDelegate">数据委托</param>
        public void GetDataReaderByRow(IRow queryFilter, DataReaderDelegate dataDelegate)
        {
            GetDataReader(RowToQueryFilter(queryFilter), dataDelegate);
        }

        private IQueryFilter RowToQueryFilter(IRow entity)
        {
            if (entity == null)
                return null;

            string strWhere = "";
            List<GlobalParameter> paraList = new List<GlobalParameter>();
            foreach (KeyValuePair<string, object> item in entity.CurrentObjects)
            {
                if (item.Value == null)
                    continue;

                strWhere += item.Key + "=@" + item.Key + " and ";
                paraList.Add(new GlobalParameter("@" + item.Key, item.Value));
            }

            if (strWhere != "")
            {
                IQueryFilter queryFilter = new QueryFilter();
                queryFilter.WhereString = strWhere.Remove(strWhere.Length - 4);
                queryFilter.WhereParameter = paraList.ToArray();
                return queryFilter;
            }
            return null;
        }

        /// <summary>
        /// 返回DataTable数据
        /// </summary>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public DataTable GetDataTableByRow(IRow queryFilter)
        {
            return GetDataTable(RowToQueryFilter(queryFilter));
        }

        /// <summary>
        /// 将数据绑定到自定义数据类型上
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public List<T> GetEntityListByRow<T>(IRow queryFilter) where T : IRow, new()
        {
            return GetEntityList<T>(RowToQueryFilter(queryFilter));
        }

        /// <summary>
        /// 将数据绑定到自定义数据类型上
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public T GetEntityByRow<T>(IRow queryFilter) where T : IRow, new()
        {
            return GetEntity<T>(RowToQueryFilter(queryFilter));
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="queryFilter">查询SQL参数</param>
        /// <param name="pageInfo">分页信息</param>
        /// <param name="dataDelegate">DataReader数据读取</param>
        public virtual void PageSelect(IQueryFilter queryFilter, PageInfo pageInfo, DataReaderDelegate dataDelegate)
        {
            PageSelect(queryFilter, pageInfo, dataDelegate, null);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="queryFilter">查询SQL参数</param>
        /// <param name="pageInfo">分页信息</param>
        /// <param name="dataDelegate">DataReader数据读取</param>
        public virtual void PageSelect(IQueryFilter queryFilter, PageInfo pageInfo, DataReaderDelegate dataDelegate, FinshPageCountHander pageCountHander)
        {
            if (dataDelegate == null)
                return;

            PageParameter pageParameter = PageParameter.ToPageParameter(this, queryFilter);
            adoWorkspace.PageSelect(pageParameter, pageInfo, dataDelegate, pageCountHander);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="queryFilter">查询SQL参数</param>
        /// <param name="pageInfo">分页信息</param>
        /// <returns></returns>
        public virtual System.Data.DataTable PageSelect(IQueryFilter queryFilter, PageInfo pageInfo)
        {
            return InnerPageSelect(queryFilter, pageInfo, null);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="queryFilter">查询SQL参数</param>
        /// <param name="pageInfo">分页信息</param>
        /// <returns></returns>
        public virtual System.Data.DataTable PageSelect(IQueryFilter queryFilter, PageInfo pageInfo, FinshPageCountHander pageCountHander)
        {
            return InnerPageSelect(queryFilter, pageInfo, pageCountHander);
        }

        private DataTable InnerPageSelect(IQueryFilter queryFilter, PageInfo pageInfo, FinshPageCountHander pageCountHander)
        {
            PageParameter pageParameter = PageParameter.ToPageParameter(this, queryFilter);
            return adoWorkspace.PageSelect(pageParameter, pageInfo, pageCountHander);
        }

        /// <summary>
        /// 获取指定条件下的数据行数
        /// </summary>
        /// <param name="queryFilter"></param>
        /// <returns></returns>
        public virtual int GetRowCount(IQueryFilter queryFilter)
        {
            if (queryFilter == null)
                queryFilter = new QueryFilter();
            queryFilter.SelectFields = "count(1)";
            object obj = GetExecuteScalar(queryFilter);
            if (obj == null || obj.ToString().Trim() == "")
                return 0;
            else
            {
                int count=0;
                int.TryParse(obj.ToString(), out count);
                return count;
            }
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="queryFilter"></param>
        /// <param name="pageInfo"></param>
        /// <returns></returns>
        public virtual List<T> PageSelect<T>(IQueryFilter queryFilter, PageInfo pageInfo) where T : IRow, new()
        {
            return PageSelect<T>(queryFilter, pageInfo, null);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="queryFilter"></param>
        /// <param name="pageInfo"></param>
        /// <returns></returns>
        public virtual List<T> PageSelect<T>(IQueryFilter queryFilter, PageInfo pageInfo, FinshPageCountHander pageCountHander) where T : IRow, new()
        {
            List<T> entityBaseList = new List<T>();
            PageSelect(queryFilter, pageInfo, delegate(Tofly.Data.General.IDataReader reader, object tag)
            {
                while (reader.Read())
                {
                    T entity = new T();
                    entity.OriginalObjects = reader.Row.OriginalObjects;
                    entity.CurrentObjects = reader.Row.CurrentObjects;
                    entityBaseList.Add(entity);
                }
            }, pageCountHander);

            return entityBaseList;
        }

        /// <summary>
        /// 获取字段的唯一值
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="maxCount">最大返回数（建议设置 100）</param>
        /// <returns></returns>
        public List<object> GetUniqueValue(string fieldName, int maxCount)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 获取字段的唯一值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="convertToCaption">是否将唯一值转换为显示值</param>
        /// <returns></returns>
        public virtual List<String> GetUniqueValue(String fieldName)
        {
            return GetUniqueValue(fieldName, new QueryFilter());
        }

        /// <summary>
        /// 获取唯一值
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="filter">查询条件</param>
        public List<String> GetUniqueValue(string fieldName, IQueryFilter filter)
        {
            Field fm = GetField(fieldName);
            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.SelectFields = fieldName;
            queryFilter.GroupByString = fieldName;
            queryFilter.OrderByString = fieldName;

            //加获取唯一值条件
            if(filter !=null && !String.IsNullOrEmpty(filter.WhereString))
                queryFilter.WhereString = filter.WhereString;

            List<string> result = new List<string>();
            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, object tag)
            {
                while (reader.Read())
                {
                    object obj = reader.Row[fieldName];
                    if (obj != null && obj != DBNull.Value && obj.ToString() != "")
                    {
                        result.Add(obj.ToString());
                    }
                }
            });

            return result;
        }

        /// <summary>
        /// 获取字段的唯一值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="convertToCaption">是否将唯一值转换为显示值</param>
        /// <returns></returns>
        public virtual List<UniqueValue> GetUniqueValueEx(String fieldName)
        {
            Field fm = GetField(fieldName);
            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.SelectFields = fieldName;
            queryFilter.GroupByString = fieldName;
            queryFilter.OrderByString = fieldName;

            List<UniqueValue> result = new List<UniqueValue>();
            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, object tag)
            {
                while (reader.Read())
                {
                    object obj = reader.Row[fieldName];
                    if (obj != null && obj != DBNull.Value && obj.ToString() != "")
                    {
                        UniqueValue uniqueValue = new UniqueValue();
                        uniqueValue.Value = obj;
                        if (fm != null)
                            uniqueValue.SearchValue = DbValueConvertUtils.ConvertToCaption(fm.DataType, obj);
                        else
                            uniqueValue.SearchValue = obj.ToString();
                        if (fm.IsCode)
                        {
                            string key = obj.ToString();
                            if (fm.Domain.ContainsKey(key))
                                uniqueValue.CaptionValue = fm.Domain[key];
                            else
                                uniqueValue.CaptionValue = obj.ToString();
                        }
                        else
                            uniqueValue.CaptionValue = obj.ToString();
                        result.Add(uniqueValue);
                    }
                }
            });

            return result;
        }


        /// <summary>
        /// 获取字段的唯一值
        /// 默认是不将显示值转换为显示值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public virtual void GetUniqueValue(String fieldName, UniqueValueDelegate drDelegate)
        {
            if (drDelegate == null)
                return;

            Field fm = GetField(fieldName);
            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.SelectFields = fieldName;
            queryFilter.GroupByString = fieldName;
            queryFilter.OrderByString = fieldName;

            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, object tag)
            {
                while (reader.Read())
                {
                    object obj = reader.Row[fieldName];
                    if (obj != null && obj != DBNull.Value && obj.ToString() != "")
                    {
                        if (!drDelegate(obj.ToString()))
                            break;
                    }
                }
            });
        }


        private DataTable cachetable = null;
        /// <summary>
        /// 获取多字段的唯一值
        /// 默认是不将显示值转换为显示值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public virtual void GetUniqueValueEx(String[] fieldNames, UniqueValueDelegateEx drDelegate)
        {
            if (drDelegate == null)
                return;
            if (fieldNames.Length <= 0)
                return;

            //TODO 如果只有一个字段，则直接走单字段获取唯一直方法
            if (fieldNames.Length == 1)
            {
                GetUniqueValueEx(fieldNames[0], drDelegate);
                return;
            }
            string maxRelationField = null;
            if (this.MetadataTable != null)
            {
                
                MetadataField metaField = this.metadataTable.GetField(fieldNames[0]);
                if (metaField != null)
                {
                    string relationgroupName = metaField.RelationGroup;
                    MetadataField[] metaFields = this.metadataTable.Fields;
                    if (metaFields!=null && metaFields.Length > 0)
                    {
                        int maxRelationIndex = 0; int maxIndex = 0;
                        for (int i = 0; i < metaFields.Length; i++)
                        {
                            if (metaFields[i].RelationGroup == relationgroupName)
                                if (maxRelationIndex < metaFields[i].RelationIndex)
                                {
                                    maxRelationIndex = metaFields[i].RelationIndex;
                                    maxIndex = i;
                                }
                        }
                        if (metaFields[maxIndex].IsCode)
                        {
                            foreach (KeyValuePair<string, string> domain in metaFields[maxIndex].Domain)
                            {
                                if (domain.Key.Length > 4)
                                {
                                    this.GetUniqueValueEx(fieldNames[fieldNames.Length - 1], drDelegate);
                                    return;
                                }
                                break;
                            }
                        }
                    }
                }
                
            }


            //Field fm = GetField(fieldName);
            StringBuilder fieldName = new StringBuilder();
            fieldName.Append(fieldNames[0]);
            for (int i = 1; i < fieldNames.Length; i++)
            {
                fieldName.AppendFormat(", {0}", fieldNames[i]);
            }
            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.SelectFields = fieldName.ToString();
            queryFilter.GroupByString = fieldName.ToString();
            queryFilter.OrderByString = fieldNames[0];
            IMetadataTable domaintable=null;
            if (this.MetadataTable != null)
                domaintable = MetadataWorkspaceFactory.OpenMetadataWorkspace().OpenTable(this.metadataTable.GetField(fieldNames[0]).CodeTablePK);
            else 
                domaintable= this.tableToMetadataTable.ToMetadataTable(this);

            string IDField = null;
            string pIDField = null;
            string codeField = null;
            string captionField = null;
            if (domaintable != null)
            {
                cachetable = domaintable.Table.GetDataTable(new QueryFilter());
                IDField = domaintable.IDFieldName;
                pIDField = domaintable.PIDFieldName;
                codeField = domaintable.CodeFieldName;
                captionField = domaintable.CaptionFieldName;
            }

            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, object tag)
            {
                while (reader.Read())
                {
                    UniqueValue uniqueValue = new UniqueValue();
                    StringBuilder searchValue = new StringBuilder();
                    StringBuilder captionValue = new StringBuilder();
                    StringBuilder whereValue = new StringBuilder();
                    string pID = null;

                    object obj = reader.Row[fieldNames[0]];
                    Field fm = GetField(fieldNames[0]);

                    if (obj != null && obj != DBNull.Value)
                    {
                        uniqueValue.Value = obj;
                        if (fm != null)
                            searchValue.Append(DbValueConvertUtils.ConvertToCaption(fm.DataType, obj));
                        else
                            searchValue.Append(obj.ToString());
                        whereValue.AppendFormat("{0}={1}", codeField, DbValueConvertUtils.ConvertToCaption(fm.DataType, obj));

                        if (fm.IsCode)
                        {

                            string key = obj.ToString();
                            if (fm.Domain.ContainsKey(key) && cachetable != null)
                            {
                                    DataRow[] rows = cachetable.Select(whereValue.ToString());
                                    if (rows.Length > 0)
                                    {
                                        pID = rows[0][IDField].ToString();
                                        captionValue.Append(rows[0][captionField]);
                                    }
                                    else
                                        captionValue.Append(obj.ToString());
                                //captionValue.Append(fm.Domain[key]);
                            }
                            else
                                captionValue.Append(obj.ToString());
                        }
                        else
                            captionValue.Append(obj.ToString());


                        string strWhere = null;
                        for (int j = 1; j < fieldNames.Length; j++)
                        {
                            whereValue.Clear();
                            obj = reader.Row[fieldNames[j]];
                            fm = GetField(fieldNames[j]);
                            if (obj != null && obj != DBNull.Value)
                            {
                                uniqueValue.Value = obj;
                                if (fm != null)
                                    searchValue.AppendFormat(",{0}", DbValueConvertUtils.ConvertToCaption(fm.DataType, obj));
                                else
                                    searchValue.AppendFormat(",{0}", obj.ToString());
                                whereValue.AppendFormat("{0}={1}", codeField, DbValueConvertUtils.ConvertToCaption(fm.DataType, obj));
                                strWhere = whereValue.ToString() + " And " + pIDField + "='" + pID + "'";
                                if (fm.IsCode)
                                {

                                    string key = obj.ToString();
                                    if (fm.Domain.ContainsKey(key) && cachetable != null)
                                    {
                                        DataRow[] rows = cachetable.Select(strWhere);
                                        if (rows.Length > 0)
                                        {
                                            pID = rows[0][IDField].ToString();
                                            captionValue.AppendFormat(",{0}", rows[0][captionField]);
                                        }
                                        else
                                            captionValue.AppendFormat(",{0}", obj.ToString());
                                        //captionValue.Append(fm.Domain[key]);
                                    }
                                    else
                                        captionValue.AppendFormat(",{0}", obj.ToString());
                                }
                                else
                                    captionValue.AppendFormat(",{0}", obj.ToString());
                            }
                        }
                        uniqueValue.CaptionValue = captionValue.ToString();
                        uniqueValue.SearchValue = searchValue.ToString();
                        if (!drDelegate(uniqueValue))
                            break;
                    }
                }
            });
        }

        /// <summary>
        /// 获取字段的唯一值
        /// 默认是不将显示值转换为显示值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public virtual void GetUniqueValueEx(String fieldName, UniqueValueDelegateEx drDelegate, string definitionExpression = "")
        {
            if (drDelegate == null)
                return;

            Field fm = GetField(fieldName);
            IQueryFilter queryFilter = new QueryFilter();
            if (!string.IsNullOrEmpty(definitionExpression))
                queryFilter.WhereString = definitionExpression;
            queryFilter.SelectFields = fieldName;
            queryFilter.GroupByString = fieldName;
            queryFilter.OrderByString = fieldName;

            GetDataReader(queryFilter, delegate(Tofly.Data.General.IDataReader reader, object tag)
            {
                while (reader.Read())
                {
                    object obj = reader.Row[fieldName];
                    if (obj != null && obj != DBNull.Value && obj.ToString() != "")
                    {
                        UniqueValue uniqueValue = new UniqueValue();
                        uniqueValue.Value = obj;
                        if (fm != null)
                            uniqueValue.SearchValue = DbValueConvertUtils.ConvertToCaption(fm.DataType, obj);
                        else
                            uniqueValue.SearchValue = obj.ToString();
                        if (fm.IsCode)
                        {
                            string key = obj.ToString();
                            if (fm.Domain.ContainsKey(key))
                                uniqueValue.CaptionValue = fm.Domain[key];
                            else
                                uniqueValue.CaptionValue = obj.ToString();
                        }
                        else
                            uniqueValue.CaptionValue = obj.ToString();
                        if (!drDelegate(uniqueValue))
                            break;
                    }
                }
            });
        }

        /// <summary>
        /// 将值转换为显示值
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="value">字段值</param>
        /// <returns></returns>
        public virtual string ConvertToCaption(string fieldName, object value)
        {
            if (value == null)
                return "";

            Field fm = GetField(fieldName);
            if (fm != null)
                return DbValueConvertUtils.ConvertToCaption(fm.DataType, value);
            else
                return value.ToString();
        }

        /// <summary>
        /// 获取某列的最大值
        /// </summary>
        /// <param name="fieldName">列名</param>
        /// <returns>正常返回最大值；异常时返回-1；</returns>
        public virtual long GetSpecFieldMaxValue(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            //定义默认返回值
            long result = -1;

            // 组织获取最大值SQL
            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.SelectFields = "max(" + fieldName + ") as maxfieldname";
            queryFilter.WhereString = otherCondition;
            queryFilter.WhereParameter = paras;
            string sql = QueryFilter.ConvertToSql(this, queryFilter);
            //获取最大值
            adoWorkspace.GetDataReader(sql, delegate(Tofly.Data.General.IDataReader reader, Object tag)
            {
                if (reader.Read())
                {
                    result = reader.Row.GetValue<long>("maxfieldname");
                }
            });
            
            return result;
        }

        /// <summary>
        /// 获取某列的最小值
        /// </summary>
        /// <param name="fieldName">列名</param>
        /// <returns>正常返回最小值；异常时返回-1；</returns>
        public virtual long GetSpecFieldMinValue(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            //定义默认返回值
            long result = -1;

            // 组织获取最大值SQL
            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.SelectFields = "min(" + fieldName + ") as minfieldname";
            queryFilter.WhereString = otherCondition;
            queryFilter.WhereParameter = paras;
            string sql = QueryFilter.ConvertToSql(this, queryFilter);

            //获取最大值
            adoWorkspace.GetDataReader(sql, delegate(Tofly.Data.General.IDataReader reader, Object tag)
            {
                if (reader.Read())
                {
                    result = reader.Row.GetValue<long>("minfieldname");
                }
            });
            
            return result;
        }

        /// <summary>
        /// 获取某列的最大值(字符型按数值排列)
        /// </summary>
        /// <param name="fieldName">列名</param>
        /// <returns>正常返回最大值；异常时返回-1；</returns>
        public virtual long GetSpecFieldMaxValueStrByInt(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            //定义默认返回值
            long result = -1;

            Field sortField = this.GetField(fieldName);
            if (sortField == null)
                return result;
            if (sortField.DataType == GlobalDataType.Char || sortField.DataType == GlobalDataType.String || sortField.DataType == GlobalDataType.Text)
            {
                //组织获取最大值SQL
                IQueryFilter queryFilter = new QueryFilter();
                queryFilter.SelectFields = fieldName;
                queryFilter.WhereString = otherCondition;
                queryFilter.WhereParameter = paras;
                List<long> maxList = new List<long>();
                long itemLenght = 0;
                object objRel = null;

                List<RowBase> rbs = this.GetEntityList<RowBase>(queryFilter);

                foreach (RowBase pRow in rbs)
                {
                    objRel = pRow.GetValue<object>(fieldName);
                    if (objRel == null)
                        maxList.Add(0);
                    else if (long.TryParse(objRel.ToString(), out itemLenght))
                        maxList.Add(itemLenght);
                }

                if (maxList.Count <= 0)
                    return 0;
                maxList.Sort(new Comparison<long>(delegate(long a, long b)
                {
                    return b.CompareTo(a);
                }));
                return maxList[0];
            }
            else
            {
                result = GetSpecFieldMaxValue(fieldName, otherCondition, paras);
            }
            return result;
        }

        /// <summary>
        /// 获取某列的最小值(字符型按数值排列)
        /// </summary>
        /// <param name="fieldName">列名</param>
        /// <returns>正常返回最小值；异常时返回-1；</returns>
        public virtual long GetSpecFieldMinValueStrByInt(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            //定义默认返回值
            long result = -1;

            Field sortField = this.GetField(fieldName);
            if (sortField == null)
                return result;
            if (sortField.DataType == GlobalDataType.Char || sortField.DataType == GlobalDataType.String || sortField.DataType == GlobalDataType.Text)
            {
                //组织获取最大值SQL
                IQueryFilter queryFilter = new QueryFilter();
                queryFilter.SelectFields = fieldName;
                queryFilter.WhereString = otherCondition;
                queryFilter.WhereParameter = paras;
                string sql = QueryFilter.ConvertToSql(this, queryFilter);
                List<long> maxList = new List<long>();
                long itemLenght = 0;
                object objRel = null;

                List<RowBase> rbs = this.GetEntityList<RowBase>(queryFilter);

                foreach (RowBase pRow in rbs)
                {
                    objRel = pRow.GetValue<object>(fieldName);
                    if (objRel == null)
                        maxList.Add(0);
                    else if (long.TryParse(objRel.ToString(), out itemLenght))
                        maxList.Add(itemLenght);
                }

                if (maxList.Count <= 0)
                    return 0;
                maxList.Sort(new Comparison<long>(delegate(long a, long b)
                {
                    return a.CompareTo(b);
                }));
                return maxList[0];
            }
            else
            {
                result = GetSpecFieldMaxValue(fieldName, otherCondition, paras);
            }
            return result;
        }

        /// <summary>
        /// 获取某列的最大未使用值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="otherCondition"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public virtual long GetSpecFieldMaxUnuseValue(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 获取某列的最小未使用值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="otherCondition"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public virtual long GetSpecFieldMinUnuseValue(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 获取某列的最大未使用值(字符型按数值排列)
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="otherCondition"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public virtual long GetSpecFieldMaxUnuseValueStrByInt(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            ////定义默认返回值
            //long result = -1;

            //Field sortField = this.GetField(fieldName);
            //if (sortField == null)
            //    return result;
            //if (sortField.DataType == GlobalDataType.Char || sortField.DataType == GlobalDataType.String || sortField.DataType == GlobalDataType.Text)
            //{
            //    //组织获取最大值SQL
            //    IQueryFilter queryFilter = new QueryFilter();
            //    queryFilter.SelectFields = fieldName;
            //    queryFilter.WhereString = otherCondition;
            //    queryFilter.WhereParameter = paras;
            //    string sql = QueryFilter.ConvertToSql(this, queryFilter);
            //    List<long> maxList = new List<long>();
            //    long itemLenght = 0;
            //    object objRel = null;
            //    adoWorkspace.GetDataReader(sql, delegate(Tofly.Data.General.IDataReader reader, Object tag)
            //    {
            //        while (reader.Read())
            //        {
            //            objRel = reader.Row.GetValue<object>(fieldName);
            //            if (objRel == null)
            //                maxList.Add(0);
            //            else if (long.TryParse(objRel.ToString(), out itemLenght))
            //                maxList.Add(itemLenght);
            //        }
            //    });

            //    string maxValue = "";
            //    for (int j = 0; j < sortField.MaxLen; j++)
            //    {
            //        maxValue += "9";
            //    }
            //    long mValue = -1;
            //    long.TryParse(maxValue, out mValue);

            //    if (maxList.Count <= 0)
            //        return mValue;
            //    maxList.Sort(new Comparison<long>(delegate(long a, long b)
            //    {
            //        return b.CompareTo(a);
            //    }));

            //    long firstValue = maxList[0];
            //    if (firstValue < mValue)
            //        return mValue;
            //    else if (firstValue > mValue)
            //        return -1;
            //    else if (firstValue == mValue)
            //    {
            //        long value = -1;
            //        for (int i = 0; i < maxList.Count; i++)
            //        {
            //            value = maxList[i];
            //            value--;
            //            if (!maxList.Contains(value))
            //                return value;
            //        }
            //    }
            //    return -1;
            //}
            //else
            //{
            //    //result = GetSpecFieldMaxValue(fieldName, otherCondition, paras);
            //}
            //return result;
            throw new NotImplementedException();
        }

        /// <summary>
        /// 获取某列的最小未使用值(字符型按数值排列)
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="otherCondition"></param>
        /// <param name="paras"></param>
        /// <returns></returns>
        public virtual long GetSpecFieldMinUnuseValueStrByInt(string fieldName, string otherCondition, params GlobalParameter[] paras)
        {
            //定义默认返回值
            long result = -1;

            Field sortField = this.GetField(fieldName);
            if (sortField == null)
                return result;
            if (sortField.DataType == GlobalDataType.Char || sortField.DataType == GlobalDataType.String || sortField.DataType == GlobalDataType.Text)
            {
                //组织获取最大值SQL
                IQueryFilter queryFilter = new QueryFilter();
                queryFilter.SelectFields = fieldName;
                queryFilter.WhereString = otherCondition;
                queryFilter.WhereParameter = paras;
                string sql = QueryFilter.ConvertToSql(this, queryFilter);
                List<long> maxList = new List<long>();
                long itemLenght = 0;
                object objRel = null;
                adoWorkspace.GetDataReader(sql, delegate(Tofly.Data.General.IDataReader reader, Object tag)
                {
                    while (reader.Read())
                    {
                        objRel = reader.Row.GetValue<object>(fieldName);
                        if (objRel == null)
                            maxList.Add(0);
                        else if (long.TryParse(objRel.ToString(), out itemLenght))
                            maxList.Add(itemLenght);
                    }
                });
                if (maxList.Count <= 0)
                    return 1;
                maxList.Sort(new Comparison<long>(delegate(long a, long b)
                {
                    return a.CompareTo(b);
                }));

                long firstValue = maxList[0];
                if (firstValue > 1)
                    return 1;
                long value = -1;
                for (int i = 0; i < maxList.Count; i++)
                {
                    value = maxList[i];
                    value++;
                    if (!maxList.Contains(value))
                        return value;
                }
                return -1;
            }
            else
            {
                //result = GetSpecFieldMaxValue(fieldName, otherCondition, paras);
            }
            return result;
        }

        /// <summary>
        /// 获取下一个要素，如果没有返回null
        /// </summary>
        /// <typeparam name="T">EntityBase</typeparam>
        /// <param name="t">当前对象</param>
        /// <param name="byFieldName">查询依据字段，不支持多字段</param>
        /// <param name="whereString">过滤条件</param>
        /// <param name="orderByType">当前的排序方式</param>
        /// <returns></returns>
        public virtual T GetNextEntity<T>(T t, string byFieldName, string whereString, OrderByType orderByType) where T : IRow, new()
        {
            return GetNextEntity<T>(t, byFieldName, whereString, orderByType, false);
        }

        /// <summary>
        /// 获取下一个要素，如果没有返回null
        /// </summary>
        /// <typeparam name="T">EntityBase</typeparam>
        /// <param name="t">当前对象</param>
        /// <param name="byFieldName">查询依据字段，不支持多字段</param>
        /// <param name="whereString">过滤条件</param>
        /// <param name="orderByType">当前的排序方式</param>
        /// <param name="addCaptionField">域值转换</param>
        /// <returns></returns>
        public virtual T GetNextEntity<T>(T t, string byFieldName, string whereString, OrderByType orderByType, bool addCaptionField)
            where T : IRow, new()
        {
            if (t == null || StringUtils.IsNullOrEmpty(byFieldName))
                return default(T);

            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.AddCaptionField = addCaptionField;
            switch (orderByType)
            {
                case OrderByType.ASC:
                    queryFilter.WhereString = byFieldName + " > @curvalue ";
                    queryFilter.OrderByString = byFieldName + " ASC ";
                    break;
                case OrderByType.DESC:
                    queryFilter.WhereString = byFieldName + " < @curvalue ";
                    queryFilter.OrderByString = byFieldName + " DESC ";
                    break;
            }

            if (!StringUtils.IsNullOrSpace(whereString))
                queryFilter.WhereString += " and (" + whereString + ") ";

            queryFilter.WhereParameter = new GlobalParameter[] { 
                new GlobalParameter("@curvalue",t.GetValue<object>(byFieldName))
            };
            return GetEntity<T>(queryFilter);
        }

        /// <summary>
        /// 获取上一个要素，如果没有返回null
        /// </summary>
        /// <typeparam name="T">EntityBase</typeparam>
        /// <param name="t">当前对象</param>
        /// <param name="byFieldName">查询依据字段，不支持多字段</param>
        /// <param name="whereString">过滤条件</param>
        /// <param name="orderByType">当前的排序方式</param>
        /// <returns></returns>
        public virtual T GetPerEntity<T>(T t, string byFieldName, string whereString, OrderByType orderByType) where T : IRow, new()
        {
            return GetPerEntity<T>(t, byFieldName, whereString, orderByType, false);
        }

        /// <summary>
        /// 获取上一个要素，如果没有返回null
        /// </summary>
        /// <typeparam name="T">EntityBase</typeparam>
        /// <param name="t">当前对象</param>
        /// <param name="byFieldName">查询依据字段，不支持多字段</param>
        /// <param name="whereString">过滤条件</param>
        /// <param name="orderByType">当前的排序方式</param>
        /// <param name="addCaptionField">域值转换</param>
        /// <returns></returns>
        public virtual T GetPerEntity<T>(T t, string byFieldName, string whereString, OrderByType orderByType, bool addCaptionField) where T : IRow, new()
        {
            if (t == null || StringUtils.IsNullOrEmpty(byFieldName))
                return default(T);

            IQueryFilter queryFilter = new QueryFilter();
            queryFilter.AddCaptionField = addCaptionField;
            switch (orderByType)
            {
                case OrderByType.ASC:
                    queryFilter.WhereString = byFieldName + " < @curvalue ";
                    queryFilter.OrderByString = byFieldName + " DESC ";
                    break;
                case OrderByType.DESC:
                    queryFilter.WhereString = byFieldName + " > @curvalue ";
                    queryFilter.OrderByString = byFieldName + " ASC ";
                    break;
            }

            if (!StringUtils.IsNullOrSpace(whereString))
                queryFilter.WhereString += " and (" + whereString + ") ";

            queryFilter.WhereParameter = new GlobalParameter[] { 
                new GlobalParameter("@curvalue",t.GetValue<object>(byFieldName))
            };
            return GetEntity<T>(queryFilter);
        }

        private bool useeditinterceptor = true;
        /// <summary>
        /// 获取或者设置是否使用拦截接口
        /// </summary>
        public virtual bool UseEditInterceptor
        {
            get { return useeditinterceptor; }
            set { useeditinterceptor = value; }
        }

        /// <summary>
        /// 更新或添加行
        /// </summary>
        /// <param name="row">数据行</param>
        public virtual void Save(IRow entity)
        {
            if (entity == null)
                return;

            if (entity.IsNew)
            {
                Insert(entity);
                entity.ChangeObjects();
            }
            else
            {
                Update(entity);
                entity.ChangeObjects();
            }
        }

        /// <summary>
        /// 更新或添加行
        /// </summary>
        /// <param name="entitys">数据行</param>
        public virtual void Save(List<IRow> entitys)
        {
            if (entitys == null || entitys.Count <= 0)
                return;

            List<IRow> newEntity = new List<IRow>();
            List<IRow> oldEntity = new List<IRow>();

            foreach (IRow item in entitys)
            {
                if (item.IsNew)
                    newEntity.Add(item);
                else
                    oldEntity.Add(item);
            }

            Insert(newEntity);
            Update(oldEntity);
        }

        /// <summary>
        /// 添加新行
        /// </summary>
        /// <param name="entity"></param>
        protected virtual void Insert(List<IRow> entitys)
        {
            foreach (IRow entity in entitys)
            {
                Insert(entity);
                entity.ChangeObjects();
            }
        }

        /// <summary>
        /// 更新数据行
        /// </summary>
        /// <param name="entity"></param>
        protected virtual void Update(List<IRow> entitys)
        {
            List<ListSqlItem> listSql = new List<ListSqlItem>();
            foreach (IRow entity in entitys)
            {
                List<GlobalParameter> setParameter = new List<GlobalParameter>();
                string sql = "";
                GetUpdateWhere(entity, ref sql, ref setParameter);
                if (!StringUtils.IsNullOrSpace(sql))
                    listSql.Add(new ListSqlItem(sql, setParameter.ToArray()));
            }
            adoWorkspace.ExecuteSql(listSql);
            foreach (IRow entity in entitys)
            {
                entity.ChangeObjects();
            }
        }

        /// <summary>
        /// 添加新行
        /// </summary>
        /// <param name="entity"></param>
        protected virtual void Insert(IRow entity)
        {
            List<GlobalParameter> whereParameter = new List<GlobalParameter>();
            object obj = null;
            string sql = "";

            // 插入新行
            string fieldList = "";
            whereParameter.Clear();
            foreach (Field item in Fields)
            {
                if (item.IsAuto
                    && (adoWorkspace.WorkspaceType == WorkspaceType.Oracle
                    || adoWorkspace.WorkspaceType == WorkspaceType.SqlLite
                    ))
                {
                    fieldList += "[" + item.FieldName + "],";
                    sql += "{AUTOFIELDVALUE},";
                }
                else
                {
                    obj = entity.GetValue<object>(item.FieldName);
                    if (obj != null)
                    {
                        // 数据对象的最大值，和最小值不处理
                        if (item.DataType == GlobalDataType.Date || item.DataType == GlobalDataType.DateTime)
                        {
							if (adoWorkspace.WorkspaceType != WorkspaceType.Oracle)
							{
								if (obj.Equals(DateTime.MinValue) || obj.Equals(DateTime.MaxValue))
									obj = DBNull.Value;
								else
								{
									obj = Convert.ToDateTime(obj).ToString("yyyy-MM-dd HH:MM:ss");
								}
							}
                        }

                        fieldList += "[" + item.FieldName + "],";
                        sql += "@" + item.FieldName + ",";
                        whereParameter.Add(new GlobalParameter("@" + item.FieldName, obj));
                    }
                }
            }

            if (sql.Length > 0)
            {
                fieldList = fieldList.Remove(fieldList.Length - 1);
                sql = sql.Remove(sql.Length - 1);
                sql = "Insert into " + tableName + " (" + fieldList + ") values (" + sql + ")";

                // 回填自动增值列的值
                Field[] autoKey = GetAutoFields();
                if (autoKey.Length == 1)
                {
                    switch (adoWorkspace.WorkspaceType)
                    {
                        case WorkspaceType.Oracle:
                            //string autoSql = SdeHelper.GetAutoFieldValueSql(this, autoKey[0]);
                            //autoSql = "select " + autoSql + " from dual";
                            //obj = adoWorkspace.GetExecuteScalar(autoSql);

                            //sql = sql.Replace("{AUTOFIELDVALUE}", obj.ToString());
                            //adoWorkspace.ExecuteSql(sql, whereParameter.ToArray());

                            //if (obj != null && obj != DBNull.Value)
                            //    entity.SetValue(autoKey[0].FieldName, obj);
                            //break;
                        case WorkspaceType.SqlLite:
                            string autoSql2 = "select max(" + autoKey[0].FieldName + ") from " + tableName;
                            obj = adoWorkspace.GetExecuteScalar(autoSql2);
                            long autoIndex = 1;
                            if (obj != null)
                            {
                                long.TryParse(obj.ToString(), out autoIndex);
                                autoIndex++;
                            }

                            sql = sql.Replace("{AUTOFIELDVALUE}", autoIndex.ToString());
                            adoWorkspace.ExecuteSql(sql, whereParameter.ToArray());
                            entity.SetValue(autoKey[0].FieldName, autoIndex);
                            break;
                        case WorkspaceType.SqlServer:
                        case WorkspaceType.SqlServerExpress:
                            adoWorkspace.ExecuteSql(sql, whereParameter.ToArray());
                            sql += ";SELECT IDENT_CURRENT('" + tableName + "');";
                            obj = adoWorkspace.GetExecuteScalar(sql, whereParameter.ToArray());
                            if (obj != null && obj != DBNull.Value)
                                entity.SetValue(autoKey[0].FieldName, obj);
                            break;
                        case WorkspaceType.Access:
                            adoWorkspace.ExecuteSql(sql, whereParameter.ToArray());
                            sql = "select @@identity as id";
                            obj = adoWorkspace.GetExecuteScalar(sql);
                            if (obj != null && obj != DBNull.Value)
                                entity.SetValue(autoKey[0].FieldName, obj);
                            break;
                        case WorkspaceType.MySQL:
                            String mysqlDbName = this.adoWorkspace.Database;
                            mysqlDbName = mysqlDbName.Substring(mysqlDbName.LastIndexOf("/") + 1);
                            String autoSqla = "select auto_increment from information_schema.tables where table_name='"
                                    + tableName + "' and TABLE_SCHEMA='"
                                    + mysqlDbName + "'";
                            obj = adoWorkspace.GetExecuteScalar(autoSqla, null);
                            //将自动填充的值赋上
                            if (sql.IndexOf("{AUTOFIELDVALUE}") > 0 && null == obj)
                            {
                                throw new Exception("请设置表的主键.");
                            }
                            sql = sql.Replace("{AUTOFIELDVALUE}", obj.ToString());
                            adoWorkspace.ExecuteSql(sql, whereParameter.ToArray());
                            if (obj != null)
                                entity.SetValue(autoKey[0].FieldName, obj);
                            break;
                        case WorkspaceType.FileGDB:
                        case WorkspaceType.Folder:
                        case WorkspaceType.ExcelFile:
                        case WorkspaceType.DbfFolder:
                        default:
                            throw new Exception();
                    }
                }
                else
                {
                    adoWorkspace.ExecuteSql(sql, whereParameter.ToArray());
                }
            }
        }

        /// <summary>
        /// 更新数据行
        /// </summary>
        /// <param name="entity"></param>
        protected virtual void Update(IRow entity)
        {
            List<GlobalParameter> setParameter = new List<GlobalParameter>();
            string sql = "";
            GetUpdateWhere(entity, ref sql, ref setParameter);
            if (StringUtils.IsNullOrSpace(sql))
                return;
            adoWorkspace.ExecuteSql(sql, setParameter.ToArray());
        }

        private void GetUpdateWhere(IRow entity, ref string sql, ref List<GlobalParameter> setParameter)
        {
            string whereString = "";
            object obj = null;
            List<GlobalParameter> whereParameters = new List<GlobalParameter>();

            // 根据自动增值列更新数据
            Field[] autoFields = GetAutoFields();
            int i = 0;
            if (autoFields != null && autoFields.Length > 0)
            {
                obj = entity[autoFields[0].FieldName, DataVersion.Original];
                if (obj != null)
                {
                    whereString = "[" + autoFields[0].FieldName + "]=@" + autoFields[0].FieldName + i.ToString();
                    whereParameters.Add(new GlobalParameter("@" + autoFields[0].FieldName + i.ToString(), obj));
                }
                i++;
            }

            // 根据主键进行更新
            if (whereString.Length <= 0)
            {
                Field[] keys = GetKeyNoAutoFields();
                if (keys == null || keys.Length <= 0)
                    throw new ArgumentException("无法更新当前数据！原因：无法确定更新主键！");

                foreach (Field item in keys)
                {
                    obj = entity[item.FieldName, DataVersion.Original];
                    if (obj == null)
                        throw new ArgumentException("主键[" + item.FieldName + "]取值错误！");

                    whereString += "[" + item.FieldName + "]=@" + item.FieldName + i.ToString() + " and ";
                    whereParameters.Add(new GlobalParameter("@" + item.FieldName + i.ToString(), obj));
                    i++;
                }
                whereString = whereString.Remove(whereString.Length - 4);
            }

            foreach (Field item in Fields)
            {
                if (!entity.HasChange(item.FieldName))
                    continue;

                obj = entity.GetValue<Object>(item.FieldName);
                if (!item.IsAuto && !item.ReadOnly)
                {
                    if (obj == null)
                        obj = DBNull.Value;

                    // 数据是日期类型，并且为最大值和最小值时，不做处理
                    if (item.DataType == GlobalDataType.Date || item.DataType == GlobalDataType.DateTime)
                    {
	                    if (adoWorkspace.WorkspaceType != WorkspaceType.Oracle)
	                    {
		                    if (obj.Equals(DateTime.MinValue) || obj.Equals(DateTime.MaxValue))
			                    obj = DBNull.Value;
		                    else
		                    {
								obj = Convert.ToDateTime(obj).ToString("yyyy-MM-dd HH:MM:ss");
		                    }
	                    }
                    }

                    sql += "[" + item.FieldName + "]=@" + item.FieldName + ",";
                    setParameter.Add(new GlobalParameter("@" + item.FieldName, obj));
                }
            }
            if (sql.Length > 0)
            {
                sql = sql.Remove(sql.Length - 1);
                sql = "update " + tableName + " set " + sql + " where " + whereString;
                setParameter.AddRange(whereParameters);
            }
        }

        /// <summary>
        /// 删除表记录
        /// </summary>
        /// <param name="queryFilter">过滤条件接口</param>
        /// <returns></returns>
        public virtual void Delete(IQueryFilter queryFilter)
        {
            InnerDelete(queryFilter);
        }

        private void InnerDelete(IQueryFilter queryFilter)
        {
            string sql = "delete from " + tableName;
            if (queryFilter != null
                && !StringUtils.IsNullOrSpace(queryFilter.WhereString))
            {
                sql += " where " + queryFilter.WhereString;
                adoWorkspace.ExecuteSql(sql, queryFilter.WhereParameter);
            }
            else
                adoWorkspace.ExecuteSql(sql);
        }

        /// <summary>
        /// 删除记录行
        /// </summary>
        /// <param name="row"></param>
        public virtual void DeleteByRow(IRow row)
        {
            if (row == null)
            {
                InnerDelete(null);
                return;
            }

            if (row.IsNew)
            {
                IQueryFilter queryFilter = RowToQueryFilter(row);
                InnerDelete(queryFilter);
            }
            else
            {
                IQueryFilter queryFilter = Tofly.Data.Util.QueryFilterConverter.EntityBaseToIQueryFilter(row, this);
                InnerDelete(queryFilter);
            }
        }

        /// <summary>
        /// 更新表记录
        /// 注：如果是树形表，更新了ID，不处理下级PID
        /// </summary>
        /// <param name="updateFilter"></param>
        public virtual void Update(IUpdateFilter updateFilter)
        {
            if (updateFilter == null || StringUtils.IsNullOrSpace(updateFilter.SetFields))
                return;

            string sql = UpdateFilter.ConvertToSql(this, updateFilter);
            adoWorkspace.ExecuteSql(sql, updateFilter.WhereParameter);
        }

        /// <summary>
        /// 直接更新数据（不自动打开工作空间的编辑）
        /// </summary>
        /// <param name="updateFilter"></param>
        public void DirectUpdate(IUpdateFilter updateFilter)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region 扩展方法

        /// <summary>
        /// 获取结构表的连接信息
        /// </summary>
        /// <returns></returns>
        public string ToConnectionString()
        {
            return adoWorkspace.ToConnectionString() + "," + tableName;
        }

        #endregion

        #region IDisposable

        private bool disposed = false;

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (!this.disposed)
            {

            }
            disposed = true;
        }

        ~TableClass()
        {
            Dispose(false);
        }

        #endregion
    }
}