

1
/**//// <summary>
2
/// 数据访问基础类(基于OleDb)
3
/// Copyright (C) 2004-2008 HOMEZZM
4
/// </summary>
5
public abstract class DbHelperOleDb
6
{
7
//数据库连接字符串(web.config来配置),可以动态更改connectionString支持多数据库.
8
public static string connectionString = PubConstant.ConnectionString;
9
public DbHelperOleDb()
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 (OleDbConnection connection = new OleDbConnection(connectionString))
23
{
24
using (OleDbCommand cmd = new OleDbCommand(SQLString, connection))
25
{
26
try
27
{
28
connection.Open();
29
int rows = cmd.ExecuteNonQuery();
30
return rows;
31
}
32
catch (System.Data.OleDb.OleDbException 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 (OleDbConnection conn = new OleDbConnection(connectionString))
48
{
49
conn.Open();
50
OleDbCommand cmd = new OleDbCommand();
51
cmd.Connection = conn;
52
OleDbTransaction 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.OleDb.OleDbException 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 (OleDbConnection connection = new OleDbConnection(connectionString))
83
{
84
OleDbCommand cmd = new OleDbCommand(SQLString, connection);
85
System.Data.OleDb.OleDbParameter myParameter = new System.Data.OleDb.OleDbParameter("@content", OleDbType.VarChar);
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.OleDb.OleDbException 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 (OleDbConnection connection = new OleDbConnection(connectionString))
114
{
115
OleDbCommand cmd = new OleDbCommand(strSQL, connection);
116
System.Data.OleDb.OleDbParameter myParameter = new System.Data.OleDb.OleDbParameter("@fs", OleDbType.Binary);
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.OleDb.OleDbException 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 (OleDbConnection connection = new OleDbConnection(connectionString))
145
{
146
using (OleDbCommand cmd = new OleDbCommand(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.OleDb.OleDbException e)
162
{
163
connection.Close();
164
throw new Exception(e.Message);
165
}
166
}
167
}
168
}
169
/**//// <summary>
170
/// 执行查询语句,返回OleDbDataReader
171
/// </summary>
172
/// <param name="strSQL">查询语句</param>
173
/// <returns>OleDbDataReader</returns>
174
public static OleDbDataReader ExecuteReader(string strSQL)
175
{
176
OleDbConnection connection = new OleDbConnection(connectionString);
177
OleDbCommand cmd = new OleDbCommand(strSQL, connection);
178
try
179
{
180
connection.Open();
181
OleDbDataReader myReader = cmd.ExecuteReader();
182
return myReader;
183
}
184
catch (System.Data.OleDb.OleDbException 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 (OleDbConnection connection = new OleDbConnection(connectionString))
198
{
199
DataSet ds = new DataSet();
200
try
201
{
202
connection.Open();
203
OleDbDataAdapter command = new OleDbDataAdapter(SQLString, connection);
204
command.Fill(ds, "ds");
205
}
206
catch (System.Data.OleDb.OleDbException 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 OleDbParameter[] cmdParms)
225
{
226
using (OleDbConnection connection = new OleDbConnection(connectionString))
227
{
228
using (OleDbCommand cmd = new OleDbCommand())
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.OleDb.OleDbException 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是该语句的OleDbParameter[])</param>
250
public static void ExecuteSqlTran(Hashtable SQLStringList)
251
{
252
using (OleDbConnection conn = new OleDbConnection(connectionString))
253
{
254
conn.Open();
255
using (OleDbTransaction trans = conn.BeginTransaction())
256
{
257
OleDbCommand cmd = new OleDbCommand();
258
try
259
{
260
//循环
261
foreach (DictionaryEntry myDE in SQLStringList)
262
{
263
string cmdText = myDE.Key.ToString();
264
OleDbParameter[] cmdParms = (OleDbParameter[])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 OleDbParameter[] cmdParms)
288
{
289
using (OleDbConnection connection = new OleDbConnection(connectionString))
290
{
291
using (OleDbCommand cmd = new OleDbCommand())
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.OleDb.OleDbException e)
308
{
309
throw new Exception(e.Message);
310
}
311
}
312
}
313
}
314
315
/**//// <summary>
316
/// 执行查询语句,返回OleDbDataReader
317
/// </summary>
318
/// <param name="strSQL">查询语句</param>
319
/// <returns>OleDbDataReader</returns>
320
public static OleDbDataReader ExecuteReader(string SQLString, params OleDbParameter[] cmdParms)
321
{
322
OleDbConnection connection = new OleDbConnection(connectionString);
323
OleDbCommand cmd = new OleDbCommand();
324
try
325
{
326
PrepareCommand(cmd, connection, null, SQLString, cmdParms);
327
OleDbDataReader myReader = cmd.ExecuteReader();
328
cmd.Parameters.Clear();
329
return myReader;
330
}
331
catch (System.Data.OleDb.OleDbException 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 OleDbParameter[] cmdParms)
344
{
345
using (OleDbConnection connection = new OleDbConnection(connectionString))
346
{
347
OleDbCommand cmd = new OleDbCommand();
348
PrepareCommand(cmd, connection, null, SQLString, cmdParms);
349
using (OleDbDataAdapter da = new OleDbDataAdapter(cmd))
350
{
351
DataSet ds = new DataSet();
352
try
353
{
354
da.Fill(ds, "ds");
355
cmd.Parameters.Clear();
356
}
357
catch (System.Data.OleDb.OleDbException ex)
358
{
359
throw new Exception(ex.Message);
360
}
361
return ds;
362
}
363
}
364
}
365
366
367
private static void PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, string cmdText, OleDbParameter[] 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 (OleDbParameter parm in cmdParms)
379
cmd.Parameters.Add(parm);
380
}
381
}
382
383
#endregion
384
385
386
387
}


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
