[转]将数据库表存入内存中，随时调用

注意，支持使用Sql语句和只使用表把，把数据库中的表加载到内存。注意，这里的内存是不会释放的。所以此组件是支持在asp.net服务器上使用的。从内存中取出来的表，是由你自定的。数据放置入内存之中,以HashTable对象为存贮对象。提取出来的数据为DataTable对象。也可只得到DataTable表中的一个值，如果你想要DataSet，也可以相互转换。详细使用请使看注解。

    /// <summary>
    /// 对基础数据进行处理。使用.net3.5框架
    /// 作者：若非轻寒 Email:ooofcu@hotmail.com
    /// 原理：把数据库中的表加入到内存对象HashTable中,需要
    /// 调用时,从HashTable对象中取出表或取出部份内容。
    /// </summary>
    public class DataDisposal
    {
        /*      //-----------------范          例-------------------
                /// 作者：若非轻寒 Email:ooofcu@hotmail.com
                DataDisposal g_DataDisposal= new DataDisposal("链接字符串");
                //加载业务基础数据
                g_DataDisposal.AddData("JJ_SFLBB");  
                g_DataDisposal.AddData("JJ_SFWCYYB");
                g_DataDisposal.AddData("JJ_DWXXB");
                //判断指定名称的内称表是否存在
                if(g_DataDisposal.Contains("TableName"))
                    return true;
                //得到业务基础数据,取得整个表
                DataTable dt = g_DataDisposal.GetData("JJ_DWXXB");

                //操作得到数据,在指定的表中按字段取得一个值
                string str = g_DataDisposal.GetTableValue("ID", "0", "DWMC", "JJ_DWXXB");

                //返回一行数据,在指定的表中按主键取得一行值
                DataRow dr = g_DataDisposal.GetDataRow("ID", "00", "JJ_DWXXB");

                 //还有一些其它方法，请自已看
        */

        //private ZIT.I_ZIT_Public g_DBOperation;     //数据访问组件

        private unsafe Hashtable hashTable = new Hashtable(); //用于存贮内存表集合
        private String sConnString = "";

        /// <summary>
        /// 内存数据表集合
        /// </summary>
        public Hashtable HashTableObj
        {
            get { return hashTable; }
            set { hashTable = value; }
        }
        /// <summary>
        /// 构造器
        /// </summary>
        /// <param name="sConnString">数据库链接字符串</param>
        public DataDisposal(string sConnString)
        {
            this.sConnString = sConnString;
            GC.SuppressFinalize(hashTable); //请求系统不要调用此对象的终结器(重要,保证此对象不被垃圾回收)
        }

        /// <summary>
        /// 判断本对象中指定的内存表是否存在
        /// </summary>
        /// <param name="sTableName">表名</param>
        public bool Contains(string sTableName)
        {
            return hashTable.ContainsKey(sTableName);
        }

        /// <summary>
        /// 得到本对象中内存表的数量
        /// </summary>
        /// <returns></returns>
        public int Count()
        {
            return hashTable.Count;
        }

        /// <summary>
        /// 向内存表中加载数据表,加载此表所有数据到内存。参数：数据库表名
        /// </summary>
        /// <param name="sTableName">数据表名</param>
        public void AddData(string sTableName)
        {
            try
            {
                if (hashTable.Contains(sTableName))
                {
                    //MessageBox.Show("已加载此表！程序中止！");
                    return;
                }
                string sSql = "select * from " + sTableName;
                DataTable dtTemp = GetDataTable(sSql);
                dtTemp.TableName = sTableName;
                hashTable.Add(sTableName, dtTemp);
                dtTemp = null;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 按SQL语句向内存表中加载数据表,需要自定一个内存表表名。参数：SQL查询语句,自定义内存表表名
        /// </summary>
        /// <param name="sSql">SQL语句</param>
        /// <param name="sTableName">自定一个内存表名，调用时就用这个表名调用</param>
        public void AddDataSql(string sSql, string sTableName)
        {
            try
            {
                DataTable dtTemp = GetDataTable(sSql);
                dtTemp.TableName = sTableName;
                hashTable.Add(sTableName, dtTemp);
                dtTemp = null;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        /// <summary>
        /// 从内存表集合中取出一个指定表名的内存表
        /// </summary>
        /// <param name="sTableName">内存表表名</param>
        /// <returns></returns>
        public DataTable GetData(string sTableName)
        {
            try
            {
                if (hashTable.Contains(sTableName))
                    return (DataTable)hashTable[sTableName];
                else
                {
                    //MessageBox.Show("指定内存表不存在！");
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return null;
        }

        /// <summary>
        /// 按条件返回一行数据
        /// select * from sTableName where sID=sValue
        /// </summary>
        /// <param name="sTableName">内存表名与数据库中的表名一样</param>
        /// <param name="sID">表字段名</param>
        /// <param name="sValue">表字段值</param>
        /// <returns>一行数据</returns>
        public DataRow GetDataRow(string sTableName, string sID, string sValue)
        {
            try
            {
                //操作得到数据
                DataTable dtTemp = GetData(sTableName);
                LinqList<DataRow> rowsCollection = new LinqList<DataRow>(dtTemp.Rows);
                //隐式类型
                IEnumerable<DataRow> selectedRows = from r in rowsCollection
                                                    where r[sID].ToString() == sValue
                                                    select r;
                dtTemp = null;
                foreach (DataRow dr in selectedRows)
                {
                    //操作
                    return dr;
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return null;
        }

        /// <summary>
        /// 按条件返回一行数据
        /// select * from sTableName where sID1=sValue1 and sID2=sValue2
        /// </summary>
        /// <param name="sTableName">内存表名与数据库中的表名一样</param>
        /// <param name="sID1">表字段名1</param>
        /// <param name="sValue1">表字段值1</param>
        /// <param name="sID2">表字段名2</param>
        /// <param name="sValue2">表字段值2</param>
        /// <returns>一行数据</returns>
        public DataRow GetDataRow(string sTableName, string sID1, string sValue1, string sID2, string sValue2)
        {
            try
            {
                //操作得到数据
                DataTable dtTemp = GetData(sTableName);
                LinqList<DataRow> rowsCollection = new LinqList<DataRow>(dtTemp.Rows);
                IEnumerable<DataRow> selectedRows = from r in rowsCollection
                                                    where r[sID1].ToString() == sValue1 && r[sID2].ToString() == sValue2
                                                    select r; //隐式类型
                dtTemp = null;
                foreach (DataRow dr in selectedRows)
                {
                    //操作
                    return dr;
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            return null;
        }

        /// <summary>
        /// 按条件查询内存表中的数据
        /// select retValue from sTableName where sID=sValue
        /// </summary>
        /// <param name="retValue">要返回的表字段名 </param>
        /// <param name="sTableName">内存表名与数据库中的表名一样</param>
        /// <param name="sID">表字段名</param>
        /// <param name="sValue">表字段值</param>
        /// <returns>返回值为参数retValue所定义的字段，出现异常则提示错误，并返回""</returns>
        public string GetTableValue(string retValue,string sTableName,string sID, string sValue)
        {
            try
            {
                //操作得到数据
                DataTable dtTemp = GetData(sTableName);
                LinqList<DataRow> rowsCollection = new LinqList<DataRow>(dtTemp.Rows);
                IEnumerable<DataRow> selectedRows = from r in rowsCollection
                                                    where r[sID].ToString() == sValue
                                                    select r; //隐式类型
                dtTemp = null;
                foreach (DataRow dr in selectedRows)
                {
                    //操作
                    return dr[retValue].ToString();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 按条件查询内存表中的数据
        /// select retValue from sTableName where sID1=sValue1 and sID2=sValue2
        /// </summary>       
        /// <param name="retValue">要返回的表字段名</param>
        /// <param name="sTableName">内存表名与数据库中的表名一样</param>
        /// <param name="sID1">表字段名1</param>
        /// <param name="sValue1">表字段值1</param>
        /// <param name="sID2">表字段名2</param>
        /// <param name="sValue2">表字段值2</param>
        /// <returns>返回值为参数retValue所定义的字段，出现异常则提示错误，并返回""</returns>
        public string GetTableValue(string retValue, string sTableName,string sID1, string sValue1, string sID2, string sValue2)
        {
            try
            {
                //操作得到数据
                DataTable dtTemp = GetData(sTableName);
                LinqList<DataRow> rowsCollection = new LinqList<DataRow>(dtTemp.Rows);
                IEnumerable<DataRow> selectedRows = from r in rowsCollection
                                                    where r[sID1].ToString() == sValue1 && r[sID2].ToString() == sValue2
                                                    select r; //隐式类型
                dtTemp = null;
                foreach (DataRow dr in selectedRows)
                {
                    //操作
                    return dr[retValue].ToString();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            return "";
        }

        /// <summary>
        /// 删除内存中的特定表
        /// </summary>
        /// <param name="sTableName"></param>
        public void RemoveTable(string sTableName)
        {
            if (hashTable.Contains(sTableName))
                hashTable.Remove(sTableName);
        }

        /// <summary>
        /// 删除内存中的所有表
        /// </summary>
        public void RemoveAllTable()
        {
            hashTable = null;
        }

        /// <summary>
        /// 将DataTable转化为DataSet
        /// </summary>
        /// <param name="dt">将要转化的DataTable</param>
        /// <returns>新的DataSet</returns>
        public DataSet DataTableToDataSet(DataTable dt)
        {
            DataSet ds = new DataSet();
            ds.Tables.Add(dt);
            return ds;
        }

        /// <summary>
        /// 内部方法，确定此模块得到数据库存唯一方法，
        /// 处理数据访问组件访问数据库得到数据
        /// </summary>
        /// <param name="sSql"></param>
        /// <returns></returns>
        private DataTable GetDataTable(string sSql)
        {
            return Query(sSql).Tables[0];     
        }

        /// <summary>
        /// 内部方法，执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        private DataSet Query(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(sConnString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    OleDbDataAdapter command = new OleDbDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.OleDb.OleDbException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
    }

    public class LinqList<T> : IEnumerable<T>, IEnumerable
    {
        IEnumerable items;
        public LinqList(IEnumerable items)
        {
            this.items = items;
        }
        #region
        IEnumerable<DataRow> Members;
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            foreach (T item in items)
                yield return item;
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            IEnumerable<T> ie = this;
            return ie.GetEnumerator();
        }
        #endregion
    }

时间： 2024-10-23 20:10:37

[转]将数据库表存入内存中，随时调用的相关文章

[20140928]数据库建立在内存中.txt

[20140928]数据库建立在内存中.txt --单位正好到了几台新机器,内存128G. --测试一下dbca slient建立数据库,因为完成后可以丢弃,把数据库建立在内存中. # mkdir -p /mnt/ramdisk # mount -t tmpfs -o size=8G tmpfs /mnt/ramdisk # su - oracle --检查环境变量是否设置正确 $ env | grep -i oracle USER=oracle LD_LIBRARY_PATH=/u01/app

从MySQL数据库表中检索数据

在<用MySQL创建数据库和数据库表>文章中,我们如何创建一个数据库和数据库表,并知道如何向数 据库表中添加记录. 那么我们如何从数据库表中检索数据呢? 1.从数据库表中检索信息 实际上,前面我们已经用到了SELECT语句,它用来从数据库表中检索信息. select语句格式一般为: SELECT 检索关键词 FROM 被检索的表 WHERE 检索条件(可选) 以前所使用的" * "表示选择所有的列.下面继续使用我们在上篇文章中创建的表 mytable. 2.查询所有数据:

从从MySQL数据库表中检索数据

  在<用MySQL创建数据库和数据库表>文章中,我们如何创建一个数据库和数据库表,并知道如何向数 据库表中添加记录. 那么我们如何从数据库表中检索数据呢? 1.从数据库表中检索信息 实际上,前面我们已经用到了SELECT语句,它用来从数据库表中检索信息. select语句格式一般为: SELECT 检索关键词 FROM 被检索的表 WHERE 检索条件(可选) 以前所使用的" * "表示选择所有的列.下面继续使用我们在上篇文章中创建的表 mytable. 2.查询所有数据

sqlite数据库-请问怎么用sqlite读取内存中的数据库？

问题描述 请问怎么用sqlite读取内存中的数据库? 我想把sqlite数据库包含到c#项目中,然后用的时候只读,,请问怎么用sqlite读取内存中的数据库? 解决方案 内存中数据库是什么?memcache?直接有库访问 解决方案二: 在程序启动的时候读取到List<实体>里面,以后直接用linq去查询集合. 解决方案三: System.Data.SQLite.dll就是用来操作SQLite的

配置内存中OLTP文件组提高性能

原文:配置内存中OLTP文件组提高性能 在今天的文章里,我想谈下使用内存中OLTP的内存优化文件组来获得持久性,还有如何配置它来获得高性能.在进入正题前,我想简单介绍下使用你数据库里这个特定文件组,内存OLTP是如何获得持久性的. 内存中OLTP的持久性 早些天对内存中OLTP(代号Hekaton)的一个大误解是,人们认为内存中OLTP是不具有ACID属性的--只有ACI属性,没有D属性(Durability).但这不是真的,因为在内存中OLTP里,每个在内存中的操作都是完全日志的.如果你的数据

link中内存表和数据库表联合查询怎么做？为什么提示invaild invoke？

问题描述 link中内存表和数据库表联合查询怎么做?为什么提示invaild invoke? link中内存表和数据库表联合查询怎么做?为什么提示invaild invoke? 解决方案 检查下是不是访问了null的对象?

pl/sql-用PL/SQL生成二维码并以图片形式存入数据库表中

问题描述 用PL/SQL生成二维码并以图片形式存入数据库表中 在数据库中创建一张表 -- Create table create table QRCode ( id varchar2(10), img blob ) tablespace USERS storage ( initial 64K minextents 1 maxextents unlimited ); 用PL/SQL生成二维码并以图片形式存入表QRCode的img字段中

sqlite-如何将导入到数据库表中的数据保存在程序中，而不用每次换调试机时还得重新导入数据

问题描述 如何将导入到数据库表中的数据保存在程序中,而不用每次换调试机时还得重新导入数据 如题:我有一张excel的表,我将其存为.csv文件,然后通过dos命令下的sqlite3命令导入到了数据库表中,问题是如果不换机子,导入到该数据库表中的数据永久有效.如果我换机子调试的话,该数据库表中的数据就不存在了,会报错,请问有没有解决办法?谢谢! 解决方案 最好存入远程数据库每次启动同步下来数据就可以了,sqlite是系统自带的数据库具体的就是http://blog.csdn.net/tianyit

select-winfrom中如何把SqlServer数据库表查询出来的数据插入access数据库表中

问题描述 winfrom中如何把SqlServer数据库表查询出来的数据插入access数据库表中 sqlserver里面的数据是根据条件查询出来的,现在是把查询出来的数据,给他导入到access数据库中,但是不知道在C#后台中怎么写 跨数据库去执行insert select,求解啊啊啊啊啊啊 解决方案 大概的代码 DataTable table = new DataTable() SqlConnection sqlconn = new SqlConnection(connectionStr);