

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
}


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

278

279

280

281

282


283

284

285

286

287

288



289

290



291

292



293

294



295

296

297

298

299



300

301

302

303



304

305

306

307

308



309

310

311

312

313

314

315


316

317

318

319

320

321



322

323

324

325



326

327

328

329

330

331

332



333

334

335

336

337

338


339

340

341

342

343

344



345

346



347

348

349

350



351

352

353



354

355

356

357

358



359

360

361

362

363

364

365

366

367

368



369

370

371

372

373

374

375

376

377



378

379

380

381

382

383

384

385


386

387


388

389

390

391

392

393

394



395

396

397

398

399

400

401

402

403

404

405


406

407

408

409

410

411

412

413



414

415



416

417

418

419

420

421

422

423

424

425

426

427


428

429

430

431

432

433

434

435



436

437

438

439



440

441

442

443

444

445


446

447

448

449

450

451

452

453



454

455



456

457

458

459

460

461

462

463

464

465

466


467

468

469

470

471

472

473



474

475

476

477

478

479

480

481

482
