NET-数据访问基础类(基于Oracle)

  1    /**//// <summary>
  2        /// 数据访问基础类(基于Oracle)    
  3        /// Copyright (C) 2004-2008 HOMEZZM    
  4    /// </summary>
  5    public abstract class DbHelperOra
  6    {
  7        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.        
  8        public static string connectionString = PubConstant.ConnectionString;     
  9        public DbHelperOra()
 10        {            
 11        }
 12        
 13        执行简单SQL语句#region  执行简单SQL语句
 14
 15        /**//// <summary>
 16        /// 执行SQL语句，返回影响的记录数
 17        /// </summary>
 18        /// <param name="SQLString">SQL语句</param>
 19        /// <returns>影响的记录数</returns>
 20        public static int ExecuteSql(string SQLString)
 21        {
 22            using (OracleConnection connection = new OracleConnection(connectionString))
 23            {                
 24                using (OracleCommand cmd = new OracleCommand(SQLString,connection))
 25                {
 26                    try
 27                    {        
 28                        connection.Open();
 29                        int rows=cmd.ExecuteNonQuery();
 30                        return rows;
 31                    }
 32                    catch(System.Data.OracleClient.OracleException E)
 33                    {                    
 34                        connection.Close();
 35                        throw new Exception(E.Message);
 36                    }
 37                }                
 38            }
 39        }
 40        
 41        /**//// <summary>
 42        /// 执行多条SQL语句，实现数据库事务。
 43        /// </summary>
 44        /// <param name="SQLStringList">多条SQL语句</param>        
 45        public static void ExecuteSqlTran(ArrayList SQLStringList)
 46        {
 47            using (OracleConnection conn = new OracleConnection(connectionString))
 48            {
 49                conn.Open();
 50                OracleCommand cmd = new OracleCommand();
 51                cmd.Connection=conn;                
 52                OracleTransaction tx=conn.BeginTransaction();            
 53                cmd.Transaction=tx;                
 54                try
 55                {           
 56                    for(int n=0;n<SQLStringList.Count;n++)
 57                    {
 58                        string strsql=SQLStringList[n].ToString();
 59                        if (strsql.Trim().Length>1)
 60                        {
 61                            cmd.CommandText=strsql;
 62                            cmd.ExecuteNonQuery();
 63                        }
 64                    }                                        
 65                    tx.Commit();                    
 66                }
 67                catch(System.Data.OracleClient.OracleException E)
 68                {        
 69                    tx.Rollback();
 70                    throw new Exception(E.Message);
 71                }
 72            }
 73        }
 74        /**//// <summary>
 75        /// 执行带一个存储过程参数的的SQL语句。
 76        /// </summary>
 77        /// <param name="SQLString">SQL语句</param>
 78        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
 79        /// <returns>影响的记录数</returns>
 80        public static int ExecuteSql(string SQLString,string content)
 81        {                
 82            using (OracleConnection connection = new OracleConnection(connectionString))
 83            {
 84                OracleCommand cmd = new OracleCommand(SQLString,connection);
 85                System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter("@content", OracleType.NVarChar);
 86                myParameter.Value = content ;
 87                cmd.Parameters.Add(myParameter);
 88                try
 89                {
 90                    connection.Open();
 91                    int rows=cmd.ExecuteNonQuery();
 92                    return rows;
 93                }
 94                catch(System.Data.OracleClient.OracleException E)
 95                {                
 96                    throw new Exception(E.Message);
 97                }
 98                finally
 99                {
100                    cmd.Dispose();
101                    connection.Close();
102                }    
103            }
104        }        
105        /**//// <summary>
106        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
107        /// </summary>
108        /// <param name="strSQL">SQL语句</param>
109        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
110        /// <returns>影响的记录数</returns>
111        public static int ExecuteSqlInsertImg(string strSQL,byte[] fs)
112        {        
113            using (OracleConnection connection = new OracleConnection(connectionString))
114            {
115                OracleCommand cmd = new OracleCommand(strSQL,connection);
116                System.Data.OracleClient.OracleParameter myParameter = new System.Data.OracleClient.OracleParameter("@fs", OracleType.LongRaw);
117                myParameter.Value = fs ;
118                cmd.Parameters.Add(myParameter);
119                try
120                {
121                    connection.Open();
122                    int rows=cmd.ExecuteNonQuery();
123                    return rows;
124                }
125                catch(System.Data.OracleClient.OracleException E)
126                {                
127                    throw new Exception(E.Message);
128                }
129                finally
130                {
131                    cmd.Dispose();
132                    connection.Close();
133                }                
134            }
135        }
136        
137        /**//// <summary>
138        /// 执行一条计算查询结果语句，返回查询结果（object）。
139        /// </summary>
140        /// <param name="SQLString">计算查询结果语句</param>
141        /// <returns>查询结果（object）</returns>
142        public static object GetSingle(string SQLString)
143        {
144            using (OracleConnection connection = new OracleConnection(connectionString))
145            {
146                using(OracleCommand cmd = new OracleCommand(SQLString,connection))
147                {
148                    try
149                    {
150                        connection.Open();
151                        object obj = cmd.ExecuteScalar();
152                        if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
153                        {                    
154                            return null;
155                        }
156                        else
157                        {
158                            return obj;
159                        }                
160                    }
161                    catch(System.Data.OracleClient.OracleException e)
162                    {                        
163                        connection.Close();
164                        throw new Exception(e.Message);
165                    }    
166                }
167            }
168        }
169        /**//// <summary>
170        /// 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
171        /// </summary>
172        /// <param name="strSQL">查询语句</param>
173        /// <returns>OracleDataReader</returns>
174        public static OracleDataReader ExecuteReader(string strSQL)
175        {
176            OracleConnection connection = new OracleConnection(connectionString);            
177            OracleCommand cmd = new OracleCommand(strSQL,connection);                
178            try
179            {
180                connection.Open();
181                OracleDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
182                return myReader;
183            }
184            catch(System.Data.OracleClient.OracleException e)
185            {                                
186                throw new Exception(e.Message);
187            }            
188            
189        }        
190        /**//// <summary>
191        /// 执行查询语句，返回DataSet
192        /// </summary>
193        /// <param name="SQLString">查询语句</param>
194        /// <returns>DataSet</returns>
195        public static DataSet Query(string SQLString)
196        {
197            using (OracleConnection connection = new OracleConnection(connectionString))
198            {
199                DataSet ds = new DataSet();
200                try
201                {
202                    connection.Open();
203                    OracleDataAdapter command = new OracleDataAdapter(SQLString,connection);                
204                    command.Fill(ds,"ds");
205                }
206                catch(System.Data.OracleClient.OracleException ex)
207                {                
208                    throw new Exception(ex.Message);
209                }            
210                return ds;
211            }            
212        }
213
214
215        #endregion
216
217        执行带参数的SQL语句#region 执行带参数的SQL语句
218
219        /**//// <summary>
220        /// 执行SQL语句，返回影响的记录数
221        /// </summary>
222        /// <param name="SQLString">SQL语句</param>
223        /// <returns>影响的记录数</returns>
224        public static int ExecuteSql(string SQLString,params OracleParameter[] cmdParms)
225        {
226            using (OracleConnection connection = new OracleConnection(connectionString))
227            {                
228                using (OracleCommand cmd = new OracleCommand())
229                {
230                    try
231                    {        
232                        PrepareCommand(cmd, connection, null,SQLString, cmdParms);
233                        int rows=cmd.ExecuteNonQuery();
234                        cmd.Parameters.Clear();
235                        return rows;
236                    }
237                    catch(System.Data.OracleClient.OracleException E)
238                    {                
239                        throw new Exception(E.Message);
240                    }
241                }                
242            }
243        }
244        
245            
246        /**//// <summary>
247        /// 执行多条SQL语句，实现数据库事务。
248        /// </summary>
249        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的OracleParameter[]）</param>
250        public static void ExecuteSqlTran(Hashtable SQLStringList)
251        {            
252            using (OracleConnection conn = new OracleConnection(connectionString))
253            {
254                conn.Open();
255                using (OracleTransaction trans = conn.BeginTransaction()) 
256                {
257                    OracleCommand cmd = new OracleCommand();
258                    try 
259                    {
260                        //循环
261                        foreach (DictionaryEntry myDE in SQLStringList)
262                        {    
263                            string     cmdText=myDE.Key.ToString();
264                            OracleParameter[] cmdParms=(OracleParameter[])myDE.Value;
265                            PrepareCommand(cmd,conn,trans,cmdText, cmdParms);
266                            int val = cmd.ExecuteNonQuery();
267                            cmd.Parameters.Clear();
268
269                            trans.Commit();
270                        }                    
271                    }
272                    catch 
273                    {
274                        trans.Rollback();
275                        throw;
276                    }
277                }                
278            }
279        }
280    
281                
282        /**//// <summary>
283        /// 执行一条计算查询结果语句，返回查询结果（object）。
284        /// </summary>
285        /// <param name="SQLString">计算查询结果语句</param>
286        /// <returns>查询结果（object）</returns>
287        public static object GetSingle(string SQLString,params OracleParameter[] cmdParms)
288        {
289            using (OracleConnection connection = new OracleConnection(connectionString))
290            {
291                using (OracleCommand cmd = new OracleCommand())
292                {
293                    try
294                    {
295                        PrepareCommand(cmd, connection, null,SQLString, cmdParms);
296                        object obj = cmd.ExecuteScalar();
297                        cmd.Parameters.Clear();
298                        if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
299                        {                    
300                            return null;
301                        }
302                        else
303                        {
304                            return obj;
305                        }                
306                    }
307                    catch(System.Data.OracleClient.OracleException e)
308                    {                
309                        throw new Exception(e.Message);
310                    }                    
311                }
312            }
313        }
314        
315        /**//// <summary>
316        /// 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
317        /// </summary>
318        /// <param name="strSQL">查询语句</param>
319        /// <returns>OracleDataReader</returns>
320        public static OracleDataReader ExecuteReader(string SQLString,params OracleParameter[] cmdParms)
321        {        
322            OracleConnection connection = new OracleConnection(connectionString);
323            OracleCommand cmd = new OracleCommand();                
324            try
325            {
326                PrepareCommand(cmd, connection, null,SQLString, cmdParms);
327                OracleDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
328                cmd.Parameters.Clear();
329                return myReader;
330            }
331            catch(System.Data.OracleClient.OracleException e)
332            {                                
333                throw new Exception(e.Message);
334            }                    
335            
336        }        
337        
338        /**//// <summary>
339        /// 执行查询语句，返回DataSet
340        /// </summary>
341        /// <param name="SQLString">查询语句</param>
342        /// <returns>DataSet</returns>
343        public static DataSet Query(string SQLString,params OracleParameter[] cmdParms)
344        {
345            using (OracleConnection connection = new OracleConnection(connectionString))
346            {
347                OracleCommand cmd = new OracleCommand();
348                PrepareCommand(cmd, connection, null,SQLString, cmdParms);
349                using( OracleDataAdapter da = new OracleDataAdapter(cmd) )
350                {
351                    DataSet ds = new DataSet();    
352                    try
353                    {                                                
354                        da.Fill(ds,"ds");
355                        cmd.Parameters.Clear();
356                    }
357                    catch(System.Data.OracleClient.OracleException ex)
358                    {                
359                        throw new Exception(ex.Message);
360                    }            
361                    return ds;
362                }                
363            }            
364        }
365
366
367        private static void PrepareCommand(OracleCommand cmd,OracleConnection conn,OracleTransaction trans, string cmdText, OracleParameter[] cmdParms) 
368        {
369            if (conn.State != ConnectionState.Open)
370                conn.Open();
371            cmd.Connection = conn;
372            cmd.CommandText = cmdText;
373            if (trans != null)
374                cmd.Transaction = trans;
375            cmd.CommandType = CommandType.Text;//cmdType;
376            if (cmdParms != null) 
377            {
378                foreach (OracleParameter parm in cmdParms)
379                    cmd.Parameters.Add(parm);
380            }
381        }
382
383        #endregion
384
385        存储过程操作#region 存储过程操作
386
387        /**//// <summary>
388        /// 执行存储过程 返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
389        /// </summary>
390        /// <param name="storedProcName">存储过程名</param>
391        /// <param name="parameters">存储过程参数</param>
392        /// <returns>OracleDataReader</returns>
393        public static OracleDataReader RunProcedure(string storedProcName, IDataParameter[] parameters )
394        {
395            OracleConnection connection = new OracleConnection(connectionString);
396            OracleDataReader returnReader;
397            connection.Open();
398            OracleCommand command = BuildQueryCommand( connection,storedProcName, parameters );
399            command.CommandType = CommandType.StoredProcedure;
400            returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);                
401            return returnReader;            
402        }
403        
404        
405        /**//// <summary>
406        /// 执行存储过程
407        /// </summary>
408        /// <param name="storedProcName">存储过程名</param>
409        /// <param name="parameters">存储过程参数</param>
410        /// <param name="tableName">DataSet结果中的表名</param>
411        /// <returns>DataSet</returns>
412        public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName )
413        {
414            using (OracleConnection connection = new OracleConnection(connectionString))
415            {
416                DataSet dataSet = new DataSet();
417                connection.Open();
418                OracleDataAdapter sqlDA = new OracleDataAdapter();
419                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters );
420                sqlDA.Fill( dataSet, tableName );
421                connection.Close();
422                return dataSet;
423            }
424        }
425
426        
427        /**//// <summary>
428        /// 构建 OracleCommand 对象(用来返回一个结果集，而不是一个整数值)
429        /// </summary>
430        /// <param name="connection">数据库连接</param>
431        /// <param name="storedProcName">存储过程名</param>
432        /// <param name="parameters">存储过程参数</param>
433        /// <returns>OracleCommand</returns>
434        private static OracleCommand BuildQueryCommand(OracleConnection connection,string storedProcName, IDataParameter[] parameters)
435        {            
436            OracleCommand command = new OracleCommand( storedProcName, connection );
437            command.CommandType = CommandType.StoredProcedure;
438            foreach (OracleParameter parameter in parameters)
439            {
440                command.Parameters.Add( parameter );
441            }
442            return command;            
443        }
444        
445        /**//// <summary>
446        /// 执行存储过程，返回影响的行数        
447        /// </summary>
448        /// <param name="storedProcName">存储过程名</param>
449        /// <param name="parameters">存储过程参数</param>
450        /// <param name="rowsAffected">影响的行数</param>
451        /// <returns></returns>
452        public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected )
453        {
454            using (OracleConnection connection = new OracleConnection(connectionString))
455            {
456                int result;
457                connection.Open();
458                OracleCommand command = BuildIntCommand(connection,storedProcName, parameters );
459                rowsAffected = command.ExecuteNonQuery();
460                result = (int)command.Parameters["ReturnValue"].Value;
461                //Connection.Close();
462                return result;
463            }
464        }
465        
466        /**//// <summary>
467        /// 创建 OracleCommand 对象实例(用来返回一个整数值)    
468        /// </summary>
469        /// <param name="storedProcName">存储过程名</param>
470        /// <param name="parameters">存储过程参数</param>
471        /// <returns>OracleCommand 对象实例</returns>
472        private static OracleCommand BuildIntCommand(OracleConnection connection,string storedProcName, IDataParameter[] parameters)
473        {
474            OracleCommand command = BuildQueryCommand(connection,storedProcName, parameters );
475            command.Parameters.Add( new OracleParameter ( "ReturnValue",
476                OracleType.Int32, 4, ParameterDirection.ReturnValue,
477                false,0,0,string.Empty,DataRowVersion.Default,null ));
478            return command;
479        }
480        #endregion    
481
482    }