一个有用的oracle数据库封装类

 转载

//**********************************************************
//2005-06-21 17:37:11
//
功能  
//**********************************************************

using System;
using System.Data.OracleClient;
using System.Data;
using System.Windows.Forms;
using System.Collections;
using System.IO;
using UtilityLibrary.WinControls;

namespace DoReport
{
    /// <summary>
    /// ClsDB
的摘要说明。
    /// </summary>
    public class ClsDB
    {
        /// <summary>
        ///
===吴建明 数据库访问类2005-04-18===
        /// </summary>
        public OracleConnection cn;    //sqlconnection
    
        private OracleCommand cmd;   //sqlcommand
        private OracleDataAdapter ada;  //sqldataAdapter
        private OracleCommandBuilder bldr;
        private DataSet ds;     //
数据集
        public DataRow dr;
        public OracleTransaction tran;
        public String ConnStr;
        public Hashtable  myHT;     //
哈希表

        public ClsDB()     //
不带参数的构造函数
        {
            //
            // TODO:
在此处添加构造函数逻辑
            //
        }

        public ClsDB(string SConnStr)   //
带参数的构造函数
        {
            ConnStr=SConnStr;      //
参数传递
        }

        public void Dispose(OracleConnection Conn)   //
数据库的销毁
        {
            if(cn!=null)
            {
                cn.Close();   //
数据库关闭
                cn.Dispose();//
释放内存
            }
            GC.Collect();      //
强制对代进行垃圾回收
        }
       //
以下2个方法是执行sql脚本的方法 0raclre没通过,sql server可以
        /// <summary>
        ///
执行Sql文件
        /// </summary>
        /// <param name="varFileName"></param>
        /// <returns></returns>
        public  bool ExecuteSqlFile(string varFileName,ProgressBarEx myPrgBar)//sql
语句存储在文件内,通过文件打开,读取
        {
            if(!File.Exists(varFileName))
            {
                return false;
            }

            StreamReader sr = File.OpenText(varFileName);  //
文件打开后给文件读取流  
   
            ArrayList alSql = new ArrayList();   //.net
里的动态数组

            string commandText = "";   //cmd.commandText
指定sql语句

            string varLine = "";
            myPrgBar.Value =0;     //
滚动条的相关设置
            myPrgBar.Maximum=500;

            while(sr.Peek() > -1)   //
文件不为空
            {
                
                varLine = sr.ReadLine(); //
一行一行的读取
                myPrgBar.Value ++;
                if(varLine == "")
                {
                    continue;
                }
                if(varLine.ToLower() != "go")
                {
                    commandText += varLine;
                    commandText += "/r/n";
                }
                else
                {
                    alSql.Add(commandText);   //
数组的动态扩容
                    commandText = "";
                }
            }
   
            sr.Close();

            try
            {
                ExecuteCommand(alSql, myPrgBar);
            }
            catch
            {
                return false;
            }

            return true;
        }


        public  void ExecuteCommand(ArrayList varSqlList,ProgressBarEx myPrgBar)
        {
            Open();
            OracleTransaction varTrans = cn.BeginTransaction();   //
触发器的开始

            OracleCommand command = new OracleCommand();//command
对象的声明
            command.Connection =cn;
            command.Transaction = varTrans;

            try
            {   
                myPrgBar.Value =0;
                myPrgBar.Maximum =varSqlList.Count;
//                myLabel.Text="
开始执行Sql脚本";
                foreach(string varcommandText in varSqlList)
                {
                    myPrgBar.Value ++;
//                    myLabel.Text="
执行Sql脚本"+varcommandText;
                    command.CommandText = varcommandText;
                    command.ExecuteNonQuery();
                }
                varTrans.Commit();//
触发器关闭
//                myLabel.Text="
执行Sql脚本完毕";
            }
            catch(Exception ex)
            {
                varTrans.Rollback(); //
触发器回滚
                MessageBox.Show(ex.Message);//
异常信息提示

                throw ex; //抛出异常
            }
            finally
            {
//                myLabel.Text="
执行Sql脚本失败";
                cn.Close();
            }
        }

        //
以上是执行sql脚本文件

        //**********************************>>
基本数据库操作篇 <<**********************************//

        /// <summary>
        ///
打开数据库方法
        /// </summary>
        public void Open()
        {
            try
            {
                if(cn == null)   //
判定数据库是否声明
                {
                    cn = new OracleConnection(ConnStr);  //
声明数据库对象
                }
                if (cn.State== ConnectionState.Closed) //
判定数据库连接状态
                {
                    cn.Open();
                   
                }
            }
            catch (Exception ex)
            {
                if(MessageBox.Show("
数据库连接失败!/n请检查数据库连接属性!","错误", MessageBoxButtons.RetryCancel,MessageBoxIcon.Error)==DialogResult.Retry )
                {
                    Open();  
                }
                else
                {    
                    throw ex;
                }

            }
            finally
            {
            }
        }

        /// <summary>
        ///
打开数据库,不返回提示
        /// </summary>
        public void Open(int No)
        {
            try
            {
                if(cn == null)
                {
                    cn = new OracleConnection(ConnStr);
                }
                if (cn.State== ConnectionState.Closed)
                {
                    cn.Open();
                }
                
            }
            catch (Exception ex)
            {
                throw ex;    //
抛出异常
            }
            finally
            {
            }
        }

        /// <summary>
        ///
关闭数据库
        /// </summary>
        public void Close()
        {
            if (cn != null)
            {
                cn.Close();
            }
        }
    

        /// <summary>
        ///
返回一个SqlParameter实例
        /// </summary>
        /// <param name="ParamName"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public OracleParameter MakeParam(string ParamName,object Value)
        {
            return new OracleParameter(ParamName, Value);
        }

        /// <summary>
        ///
调用存储过程创建一个SqlCommand对象
        /// </summary>
        /// <param name="procName">
存储过程</param>
        /// <returns></returns>
        private OracleCommand CreateCommand(string procName)
        {
            Open();
            OracleCommand cmd = new OracleCommand(procName, cn);
            cmd.CommandType = CommandType.StoredProcedure;   //
存储过程类型
            return cmd;
        }
        /// <summary>
        ///
调用存储过程创建一个SqlCommand对象
        /// </summary>
        /// <param name="procName">
存储过程</param>
        /// <param name="prams">
给存储过程传递传输SqlParameter对象</param>
        /// <returns></returns>
        private OracleCommand CreateCommand(string procName, OracleParameter[] prams)
        {
            Open();
            OracleCommand cmd = new OracleCommand(procName, cn);
            cmd.CommandType = CommandType.StoredProcedure;
            if (prams != null)
            {
                foreach (OracleParameter parameter in prams)
                    cmd.Parameters.Add(parameter);
            }
            //
这一段sql 需要,oracle则需要屏蔽
//            cmd.Parameters.Add(
//                new OracleParameter("ReturnValue",OracleType.Int32, 4,
//                ParameterDirection.ReturnValue, false, 0, 0,
//                string.Empty, DataRowVersion.Default, null));
            return cmd;
        }


        /// <summary>
        ///
执行存储过程
        /// </summary>
        /// <param name="procName">
存储过程名称</param>
        /// <returns></returns>
        public void RunProc(string procName)
        {
            OracleCommand cmd = CreateCommand(procName); //
调用此方法产生
            cmd.ExecuteNonQuery();
        }
        /// <summary>
        ///
执行存储过程
        /// </summary>
        /// <param name="procName">
存储过程名称</param>
        /// <param name="prams">
给存储过程传递传输SqlParameter对象</param>
        /// <returns></returns>
        public void RunProc(string procName, OracleParameter[] prams)
        {
            OracleCommand cmd = CreateCommand(procName, prams);
            cmd.ExecuteNonQuery();
        }

        /// <summary>
        ///
执行存储过程
        /// </summary>
        /// <param name="procName">
存储过程名称</param>
        /// <param name="prams">
给存储过程传递传输SqlParameter对象</param>
        /// <param name="dataReader">
输出一个DataReader对象</param>
        public void RunProc(string procName, OracleParameter[] prams, out OracleDataReader dataReader)
        {
            OracleCommand cmd = CreateCommand(procName, prams);
            dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
        }

        /// <summary>
        ///
获得DataSet对象
        /// </summary>
        /// <param name="str_Sql">SQL
语句</param>
        /// <returns></returns>
        public DataSet GetDs(string str_Sql)
        {
            Open();
            ada = new OracleDataAdapter(str_Sql,cn);  //
声明适配器
            DataSet ds = new DataSet();
            bldr = new OracleCommandBuilder(ada);
            ada.Fill(ds);
            cn.Close();
            return ds;
        }
        /// <summary>
        ///
获得DataSet对象
        /// </summary>
        /// <param name="tablename">
内存表ID</param>
        /// <param name="str_Sql">SQL
语句</param>
        /// <returns></returns>
        public DataSet GetDs(string tablename,string str_Sql)
        {
            Open();
            OracleDataAdapter Ada = new OracleDataAdapter(str_Sql,cn);
            DataSet ds = new DataSet();
            bldr = new OracleCommandBuilder(Ada);
            Ada.Fill(ds,tablename);
            cn.Close();
            return ds;
        }
        /// <summary>
        ///
获得DataTable对象
        /// </summary>
        /// <param name="str_Sql">SQL
语句</param>
        /// <returns></returns>
        public DataTable GetTable(string str_Sql)
        {
            return GetDs(str_Sql).Tables[0];
        }
        /// <summary>
        ///
获得DataTable对象
        /// </summary>
        /// <param name="tablename">
内存表ID</param>
        /// <param name="str_Sql">SQL
语句</param>
        /// <returns></returns>
        public DataTable GetTable(string tablename,string str_Sql)
        {
            return GetDs(str_Sql).Tables[tablename];
        }

        public OracleDataReader GetDataReader(string str_Sql)
        {
            try
            {
            Open();
            OracleCommand cmd = new OracleCommand(str_Sql,cn);
            OracleDataReader dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
            return dataReader;
            }
            catch(Exception ex)
            {
                throw ex;
            }

        }
        /// <summary>
        ///
执行Sql语句
        /// </summary>
        /// <param name="str_Sql">Sql
语句</param>
        public void RunSql(string str_Sql)
        {
            Open();
            OracleCommand cmd = new OracleCommand(str_Sql,cn);
            cmd.ExecuteNonQuery();
            cn.Close();
        }

        //**********************************>>
数据库操作篇(包括添加Add,修改Edit,删除Del,详细Detail) <<**********************************//
        
        /// <summary>
        ///
获得表记录数
        /// </summary>
        /// <param name="table_name">
表名或者表名+条件,GetRsCount("t_user where id="+Request["id"])</param>
        /// <returns></returns>
        public int GetRsCount(string table_name)
        {
            string strSql;
            int intCount;
            Open();
            strSql="select count(*) from "+table_name;
            OracleCommand cmd=new OracleCommand(strSql,cn);
            intCount=(int)cmd.ExecuteScalar();
            cn.Close();
            return intCount;
        }
        /// <summary>
        ///
获得单个int类型字段总和
        /// </summary>
        /// <param name="field">
字段</param>
        /// <param name="table_name">
表名或者表名+条件,GetFiledSum("id","t_user where id="+Request["id"])</param>
        /// <returns></returns>
        public string GetFiledSum(string field,string table_name)
        {
            string SumValue;
            Open();
            OracleCommand cmd=new OracleCommand("select sum("+field+") as s from "+table_name,cn);
            SumValue=cmd.ExecuteScalar().ToString();
            cn.Close();
            return SumValue;
        }
        public string GetFiledSum(string field)
        {
            string SumValue;
            Open();
            OracleCommand cmd=new OracleCommand(field,cn);
            SumValue=cmd.ExecuteScalar().ToString();
            cn.Close();
            return SumValue;
        }
        /// <summary>
        ///
获得单个字段值
        /// </summary>
        /// <param name="str_Sql">Sql
语句</param>
        /// <returns></returns>
        public string GetFiledValue(string str_Sql)
        {
            string str;
            Open();
            OracleCommand cmd=new OracleCommand(str_Sql,cn);
            str=cmd.ExecuteScalar().ToString();
            cn.Close();
            return str;
        }

        /// <summary>
        ///
获得表记录数
        /// </summary>
        /// <param name="table_name">
表名或者表名+条件,GetRsCount("t_user where id="+Request["id"])</param>
        /// <returns></returns>
        public int GetMaxId(string filed,string table_name)
        {
            string strSql;
            int intCount;
            Open();
            strSql="select max("+filed+") from "+table_name;
            OracleCommand cmd=new OracleCommand(strSql,cn);
            object obj=cmd.ExecuteScalar();
            if (obj==System.DBNull.Value)
            {
                intCount=1;
            }
            else
            {
                intCount = Convert.ToInt32(cmd.ExecuteScalar())+1;
            }
            cn.Close();
            return intCount;
        }

        /// <summary>
        ///
通过SqlCommandBuilder对象增加数据库记录
        /// </summary>
        /// <param name="sql">Select-SQL
语句</param>
        public void Builder(string str_Sql)
        {
            Open();
            ada=new OracleDataAdapter(str_Sql,cn);
            OracleCommandBuilder myCommandBuilder=new OracleCommandBuilder(ada);
            ds=new DataSet();
            ada.Fill(ds);
            dr=ds.Tables[0].NewRow();
        }
        /// <summary>
        ///
关闭SqlCommandBuilder对象
        /// </summary>
        public void BuilderClose()
        {
            ds.Tables[0].Rows.Add(dr);
            ada.Update(ds);     //
 更新数据库                    
            cn.Close(); //
关闭数据库
            ds.Clear(); //
清空DataSet对象
        }
        /// <summary>
        ///
通过SqlCommandBuilder对象修改数据库记录
        /// </summary>
        /// <param name="sql">Select-SQL
语句</param>
        public void BuilderEdit(string str_Sql)
        {
            Open();
            ada=new OracleDataAdapter(str_Sql,cn);
            OracleCommandBuilder myCommandBuilder=new OracleCommandBuilder(ada);
            ds=new DataSet();
            ada.Fill(ds);
            dr=ds.Tables[0].Rows[0];
        }
        /// <summary>
        ///
关闭SqlCommandBuilder对象
        /// </summary>
        public void BuilderEditClose()
        {
            ada.Update(ds);     //
 更新数据库                    
            cn.Close(); //
关闭数据库
            ds.Clear(); //
清空DataSet对象
        }

        
        //**********************************>>
事务处理篇 <<**********************************//

        /// <summary>
        ///
开始事务
        /// </summary>
        public void TranBegin()
        {
            Open();
            tran=cn.BeginTransaction();
        }
        /// <summary>
        ///
结束事务
        /// </summary>
        public void TranEnd()
        {
            tran.Commit(); //
结束事务
            if (cn!=null)
            {
                cn.Dispose(); //
关闭数据库
                cn.Close(); //
关系数据库
            }
            if (ds!=null)
            {
                ds.Clear();
            }
        }

        public OracleDataReader TranGetDataReader(string str_Sql)
        {
            Open();
            OracleCommand cmd=new OracleCommand(str_Sql,cn);
            OracleDataReader dr=cmd.ExecuteReader();
            return dr;
        }

        public DataSet TranGetDs(string str_Sql)
        {
            Open();
            OracleDataAdapter Ada = new OracleDataAdapter(str_Sql,cn);
            Ada.SelectCommand.Transaction=tran;
            DataSet ds = new DataSet();
            Ada.Fill(ds);
            //cn.Close();
            return ds;
        }

        public DataTable TranGetTable(string str_Sql)
        {
            return TranGetDs(str_Sql).Tables[0];
        }


        /// <summary>
        ///
获得表记录数
        /// </summary>
        /// <param name="table_name">
表名或者表名+条件,GetRsCount("t_user where id="+Request["id"])</param>
        /// <returns></returns>
        public int TranGetRsCount(string table_name)
        {
            string strSql;
            int intCount;
            strSql="select count(*) from "+table_name;
            OracleCommand cmd=new OracleCommand(strSql,cn);
            cmd.Transaction=tran;
            intCount=(int)cmd.ExecuteScalar();
            return intCount;
        }

        /// <summary>
        ///
获得单个int类型字段总和
        /// </summary>
        /// <param name="field">
字段</param>
        /// <param name="table_name">
表名或者表名+条件,GetFiledSum("id","t_user where id="+Request["id"])</param>
        /// <returns></returns>
        public string TranGetFiledSum(string field,string table_name)
        {
            string SumValue;
            OracleCommand cmd=new OracleCommand("select sum("+field+") as s from "+table_name,cn);
            cmd.Transaction=tran;
            SumValue=cmd.ExecuteScalar().ToString();
            return SumValue;
        }

        /// <summary>
        ///
获得单个字段值
        /// </summary>
        /// <param name="str_Sql">Sql
语句</param>
        /// <returns></returns>
        public string TranGetFiledValue(string str_Sql)
        {
            string str;
            OracleCommand cmd=new OracleCommand(str_Sql,cn);
            cmd.Transaction=tran;
            str=cmd.ExecuteScalar().ToString();
            return str;
        }

        /// <summary>
        ///
执行Sql语句
        /// </summary>
        /// <param name="str_Sql">Sql
语句</param>
        public void TranRunSql(string str_Sql)
        {
            OracleCommand cmd = new OracleCommand(str_Sql,cn);
            cmd.Transaction=tran;
            cmd.ExecuteNonQuery();
        }

        /// <summary>
        ///
通过SqlCommandBuilder对象增加数据库记录
        /// </summary>
        /// <param name="sql">Select-SQL
语句</param>
        public void TranBuilder(string str_Sql)
        {
            ada=new OracleDataAdapter(str_Sql,cn);
            ada.SelectCommand.Transaction=tran;
            OracleCommandBuilder myCommandBuilder=new OracleCommandBuilder(ada);
            ds=new DataSet();
            ada.Fill(ds);
            dr=ds.Tables[0].NewRow();
        }
        /// <summary>
        ///
关闭SqlCommandBuilder对象
        /// </summary>
        public void TranBuilderClose()
        {
            ds.Tables[0].Rows.Add(dr);
            ada.Update(ds);     //
 更新数据库                    
        }
        /// <summary>
        ///
通过SqlCommandBuilder对象修改数据库记录
        /// </summary>
        /// <param name="sql">Select-SQL
语句</param>
        public void TranBuilderEdit(string str_Sql)
        {
            ada=new OracleDataAdapter(str_Sql,cn);
            ada.SelectCommand.Transaction=tran;
            OracleCommandBuilder myCommandBuilder=new OracleCommandBuilder(ada);
            ds=new DataSet();
            ada.Fill(ds);
            dr=ds.Tables[0].Rows[0];
        }
        /// <summary>
        ///
关闭SqlCommandBuilder对象
        /// </summary>
        public void TranBuilderEditClose()
        {
            ada.Update(ds);     //
 更新数据库                    
        }
        /// <summary>
        ///
事务回滚
        /// </summary>
        public void TranRollback()
        {
            tran.Rollback(); //
数据库回滚
            cn.Dispose(); //
关闭数据库
            cn.Close(); //
关系数据库
        }


    }

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值