|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
原文地址：http://www.cnblogs.com/hyqing/p/3704065.html
