连接Oracle数据库的OracleHelper.cs

时间：2014-05-12 16:09:43 收藏：0 阅读：493
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
using 
System;
using 
System.Configuration;
using 
System.Data;
using 
System.Data.OracleClient;
using 
System.Collections;
 
namespace 
DBUtility {
 
    /// <summary>
    /// A helper class used to execute queries against an Oracle database
    /// </summary>
    public 
abstract class OracleHelper {
 
        //Create a hashtable for the parameter cached
        private 
static Hashtable parmCache = Hashtable.Synchronized(new 
Hashtable());
 
        /// <summary>
        /// Execute a database query which does not include a select
        /// </summary>
        /// <param name="connString">Connection string to database</param>
        /// <param name="cmdType">Command type either stored procedure or SQL</param>
        /// <param name="cmdText">Acutall SQL Command</param>
        /// <param name="commandParameters">Parameters to bind to the command</param>
        /// <returns></returns>
        public 
static int ExecuteNonQuery(string 
connectionString, CommandType cmdType, string 
cmdText, params 
OracleParameter[] commandParameters) {
            // Create a new Oracle command
            OracleCommand cmd = new 
OracleCommand();
 
            //Create a connection
            using 
(OracleConnection connection = new 
OracleConnection(connectionString)) {
 
                //Prepare the command
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
 
                //Execute the command
                int 
val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return 
val;
            }
        }
 
        /// <summary>
        /// Execute an OracleCommand (that returns no resultset) against an existing database transaction 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new OracleParameter(":prodid", 24));
        /// </remarks>
        /// <param name="trans">an existing database transaction</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or PL/SQL command</param>
        /// <param name="commandParameters">an array of OracleParamters used to execute the command</param>
        /// <returns>an int representing the number of rows affected by the command</returns>
        public 
static int ExecuteNonQuery(OracleTransaction trans, CommandType cmdType, string 
cmdText, params 
OracleParameter[] commandParameters) {
            OracleCommand cmd = new 
OracleCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            int 
val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return 
val;
        }
 
        /// <summary>
        /// Execute an OracleCommand (that returns no resultset) against an existing database connection 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new OracleParameter(":prodid", 24));
        /// </remarks>
        /// <param name="conn">an existing database connection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or PL/SQL command</param>
        /// <param name="commandParameters">an array of OracleParamters used to execute the command</param>
        /// <returns>an int representing the number of rows affected by the command</returns>
        public 
static int ExecuteNonQuery(OracleConnection connection, CommandType cmdType, string 
cmdText, params 
OracleParameter[] commandParameters) {
 
            OracleCommand cmd = new 
OracleCommand();
 
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            int 
val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return 
val;
        }
 
        /// <summary>
        /// Execute a select query that will return a result set
        /// </summary>
        /// <param name="connString">Connection string</param>
        //// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or PL/SQL command</param>
        /// <param name="commandParameters">an array of OracleParamters used to execute the command</param>
        /// <returns></returns>
        public 
static OracleDataReader ExecuteReader(string 
connectionString, CommandType cmdType, string 
cmdText, params 
OracleParameter[] commandParameters) {
 
            //Create the command and connection
            OracleCommand cmd = new 
OracleCommand();
            OracleConnection conn = new 
OracleConnection(connectionString);
 
            try 
{
                //Prepare the command to execute
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
 
                //Execute the query, stating that the connection should close when the resulting datareader has been read
                OracleDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return 
rdr;
 
            }
            catch 
{
 
                //If an error occurs close the connection as the reader will not be used and we expect it to close the connection
                conn.Close();
                throw;
            }
        }
 
        /// <summary>
        /// Execute an OracleCommand that returns the first column of the first record against the database specified in the connection string 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new OracleParameter(":prodid", 24));
        /// </remarks>
        /// <param name="connectionString">a valid connection string for a SqlConnection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or PL/SQL command</param>
        /// <param name="commandParameters">an array of OracleParamters used to execute the command</param>
        /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
        public 
static object ExecuteScalar(string 
connectionString, CommandType cmdType, string 
cmdText, params 
OracleParameter[] commandParameters) {
            OracleCommand cmd = new 
OracleCommand();
 
            using 
(OracleConnection conn = new 
OracleConnection(connectionString)) {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                object 
val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return 
val;
            }
        }
 
        /// <summary>
        /// Execute a OracleCommand (that returns a 1x1 resultset)  against the specified SqlTransaction
        /// using the provided parameters.
        /// </summary>
        /// <param name="transaction">A   valid SqlTransaction</param>
        /// <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">The stored procedure name   or PL/SQL command</param>
        /// <param name="commandParameters">An array of   OracleParamters used to execute the command</param>
        /// <returns>An   object containing the value in the 1x1 resultset generated by the command</returns>
        public 
static object ExecuteScalar(OracleTransaction transaction, CommandType commandType, string 
commandText, params 
OracleParameter[] commandParameters) {
            if(transaction == null)
                throw 
new ArgumentNullException("transaction");
            if(transaction != null 
&& transaction.Connection == null)
                throw 
new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
 
            // Create a command and prepare it for execution
            OracleCommand cmd = new 
OracleCommand();
 
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
 
            // Execute the command & return the results
            object 
retval = cmd.ExecuteScalar();
 
            // Detach the SqlParameters from the command object, so they can be used again
            cmd.Parameters.Clear();
            return 
retval;
        }
 
        /// <summary>
        /// Execute an OracleCommand that returns the first column of the first record against an existing database connection 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar(conn, CommandType.StoredProcedure, "PublishOrders", new OracleParameter(":prodid", 24));
        /// </remarks>
        /// <param name="conn">an existing database connection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or PL/SQL command</param>
        /// <param name="commandParameters">an array of OracleParamters used to execute the command</param>
        /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
        public 
static object ExecuteScalar(OracleConnection connectionString, CommandType cmdType, string 
cmdText, params 
OracleParameter[] commandParameters) {
            OracleCommand cmd = new 
OracleCommand();
 
            PrepareCommand(cmd, connectionString, null, cmdType, cmdText, commandParameters);
            object 
val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return 
val;
        }
 
        /// <summary>
        /// Add a set of parameters to the cached
        /// </summary>
        /// <param name="cacheKey">Key value to look up the parameters</param>
        /// <param name="commandParameters">Actual parameters to cached</param>
        public 
static void CacheParameters(string 
cacheKey, params 
OracleParameter[] commandParameters) {
            parmCache[cacheKey] = commandParameters;
        }
 
        /// <summary>
        /// Fetch parameters from the cache
        /// </summary>
        /// <param name="cacheKey">Key to look up the parameters</param>
        /// <returns></returns>
        public 
static OracleParameter[] GetCachedParameters(string 
cacheKey) {
            OracleParameter[] cachedParms = (OracleParameter[])parmCache[cacheKey];
 
            if 
(cachedParms == null)
                return 
null;
 
            // If the parameters are in the cache
            OracleParameter[] clonedParms = new 
OracleParameter[cachedParms.Length];
 
            // return a copy of the parameters
            for 
(int 
i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (OracleParameter)((ICloneable)cachedParms[i]).Clone();
 
            return 
clonedParms;
        }
 
        /// <summary>
        /// Internal function to prepare a command for execution by the database
        /// </summary>
        /// <param name="cmd">Existing command object</param>
        /// <param name="conn">Database connection object</param>
        /// <param name="trans">Optional transaction object</param>
        /// <param name="cmdType">Command type, e.g. stored procedure</param>
        /// <param name="cmdText">Command test</param>
        /// <param name="commandParameters">Parameters for the command</param>
        private 
static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trans, CommandType cmdType, string 
cmdText, OracleParameter[] commandParameters) {
 
            //Open the connection if required
            if 
(conn.State != ConnectionState.Open)
                conn.Open();
 
            //Set up the command
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;
 
            //Bind it to the transaction if it exists
            if 
(trans != null)
                cmd.Transaction = trans;
 
            // Bind the parameters passed in
            if 
(commandParameters != null) {
                foreach 
(OracleParameter parm in 
commandParameters)
                    cmd.Parameters.Add(parm);
            }
        }
 
        /// <summary>
        /// Converter to use boolean data type with Oracle
        /// </summary>
        /// <param name="value">Value to convert</param>
        /// <returns></returns>
        public 
static string OraBit(bool 
value) {
            if(value)
                return 
"Y";
            else
                return 
"N";
        }
 
        /// <summary>
        /// Converter to use boolean data type with Oracle
        /// </summary>
        /// <param name="value">Value to convert</param>
        /// <returns></returns>
        public 
static bool OraBool(string 
value) {
            if(value.Equals("Y"))
                return 
true;
            else
                return 
false;
        } 
    }
}
连接Oracle数据库的OracleHelper.cs,布布扣,bubuko.com